@wengine-ai/llms 2.3.231 → 2.3.234

package/dist/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { pluginManager } from './plugin-manager';
+export { tokenSpeedPlugin } from './token-speed';
+export * from './output';

package/dist/plugins/output/console-handler.d.ts

@@ -0,0 +1,23 @@
+import { OutputHandler, OutputOptions, ConsoleOutputConfig } from './types';
+/**
+ * Console output handler
+ * Supports colored output and multiple log levels
+ */
+export declare class ConsoleOutputHandler implements OutputHandler {
+    type: "console";
+    private config;
+    private colors;
+    constructor(config?: ConsoleOutputConfig);
+    /**
+     * Format output data
+     */
+    private formatData;
+    /**
+     * Convert object to Markdown format
+     */
+    private toMarkdown;
+    /**
+     * Output data
+     */
+    output(data: any, options?: OutputOptions): Promise<boolean>;
+}

package/dist/plugins/output/index.d.ts

@@ -0,0 +1,29 @@
+export * from './types';
+export { ConsoleOutputHandler } from './console-handler';
+export { WebhookOutputHandler } from './webhook-handler';
+export { TempFileOutputHandler } from './temp-file-handler';
+export { outputManager, output, outputTo } from './output-manager';
+/**
+ * Convenience function: Create and register a Console output handler
+ * @param config Console output handler configuration
+ * @returns Output manager instance
+ */
+export declare function registerConsoleOutput(config?: import('./types').ConsoleOutputConfig): any;
+/**
+ * Convenience function: Create and register a Webhook output handler
+ * @param config Webhook output handler configuration
+ * @returns Output manager instance
+ */
+export declare function registerWebhookOutput(config: import('./types').WebhookOutputConfig): any;
+/**
+ * Convenience function: Create and register a Temp File output handler
+ * @param config Temp file output handler configuration
+ * @returns Output manager instance
+ */
+export declare function registerTempFileOutput(config?: import('./types').TempFileOutputConfig): any;
+/**
+ * Convenience function: Register output handlers in batch
+ * @param configs Output handler configuration array
+ * @returns Output manager instance
+ */
+export declare function registerOutputHandlers(configs: import('./types').OutputHandlerConfig[]): any;

package/dist/plugins/output/output-manager.d.ts

@@ -0,0 +1,108 @@
+import { OutputHandler, OutputOptions, OutputHandlerConfig } from './types';
+/**
+ * Output manager
+ * Manages multiple output handlers and provides unified output interface
+ */
+declare class OutputManager {
+    private handlers;
+    private defaultOptions;
+    /**
+     * Register output handler
+     * @param name Output handler name
+     * @param handler Output handler instance
+     */
+    registerHandler(name: string, handler: OutputHandler): void;
+    /**
+     * Register output handlers in batch
+     * @param configs Output handler configuration array
+     */
+    registerHandlers(configs: OutputHandlerConfig[]): void;
+    /**
+     * Create output handler instance
+     * @param config Output handler configuration
+     */
+    private createHandler;
+    /**
+     * Remove output handler
+     * @param name Output handler name
+     */
+    unregisterHandler(name: string): boolean;
+    /**
+     * Get output handler
+     * @param name Output handler name
+     */
+    getHandler(name: string): OutputHandler | undefined;
+    /**
+     * Get all output handlers
+     */
+    getAllHandlers(): Map<string, OutputHandler>;
+    /**
+     * Clear all output handlers
+     */
+    clearHandlers(): void;
+    /**
+     * Set default output options
+     * @param options Output options
+     */
+    setDefaultOptions(options: OutputOptions): void;
+    /**
+     * Get default output options
+     */
+    getDefaultOptions(): OutputOptions;
+    /**
+     * Output data to all registered output handlers
+     * @param data Data to output
+     * @param options Output options
+     * @returns Promise<{success: string[], failed: string[]}> Names of successful and failed handlers
+     */
+    output(data: any, options?: OutputOptions): Promise<{
+        success: string[];
+        failed: string[];
+    }>;
+    /**
+     * Output data to specified output handlers
+     * @param handlerNames Array of output handler names
+     * @param data Data to output
+     * @param options Output options
+     * @returns Promise<{success: string[], failed: string[]}> Names of successful and failed handlers
+     */
+    outputTo(handlerNames: string[], data: any, options?: OutputOptions): Promise<{
+        success: string[];
+        failed: string[];
+    }>;
+    /**
+     * Output data to specified type of output handlers
+     * @param type Output handler type
+     * @param data Data to output
+     * @param options Output options
+     * @returns Promise<{success: string[], failed: string[]}> Names of successful and failed handlers
+     */
+    outputToType(type: string, data: any, options?: OutputOptions): Promise<{
+        success: string[];
+        failed: string[];
+    }>;
+}
+/**
+ * Global output manager instance
+ */
+export declare const outputManager: OutputManager;
+/**
+ * Convenience method: Quickly output data to all registered handlers
+ * @param data Data to output
+ * @param options Output options
+ */
+export declare function output(data: any, options?: OutputOptions): Promise<{
+    success: string[];
+    failed: string[];
+}>;
+/**
+ * Convenience method: Quickly output data to specified type of handlers
+ * @param type Output handler type ('console' | 'webhook' | 'websocket')
+ * @param data Data to output
+ * @param options Output options
+ */
+export declare function outputTo(type: string, data: any, options?: OutputOptions): Promise<{
+    success: string[];
+    failed: string[];
+}>;
+export {};

package/dist/plugins/output/temp-file-handler.d.ts

@@ -0,0 +1,48 @@
+import { OutputHandler, OutputOptions } from './types';
+/**
+ * Temp file output handler configuration
+ */
+export interface TempFileOutputConfig {
+    /**
+     * Subdirectory under system temp directory (default: 'claude-code-router')
+     */
+    subdirectory?: string;
+    /**
+     * File extension (default: 'json')
+     */
+    extension?: string;
+    /**
+     * Whether to include timestamp in filename (default: true)
+     */
+    includeTimestamp?: boolean;
+    /**
+     * Custom prefix for temp files (default: 'session')
+     */
+    prefix?: string;
+}
+/**
+ * Temp file output handler
+ * Writes data to temporary files in system temp directory
+ */
+export declare class TempFileOutputHandler implements OutputHandler {
+    type: "temp-file";
+    private config;
+    private baseDir;
+    constructor(config?: TempFileOutputConfig);
+    /**
+     * Ensure directory exists
+     */
+    private ensureDir;
+    /**
+     * Get file path for temp file
+     */
+    private getFilePath;
+    /**
+     * Output data to temp file
+     */
+    output(data: any, options?: OutputOptions): Promise<boolean>;
+    /**
+     * Get the base directory where temp files are stored
+     */
+    getBaseDir(): string;
+}

package/dist/plugins/output/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Output handler interface
+ * All output handlers must implement this interface
+ */
+export interface OutputHandler {
+    /**
+     * Output handler type name
+     */
+    type: string;
+    /**
+     * Output data
+     * @param data Data to output
+     * @param options Output options
+     * @returns Promise<boolean> Whether output was successful
+     */
+    output(data: any, options?: OutputOptions): Promise<boolean>;
+}
+/**
+ * Output options
+ */
+export interface OutputOptions {
+    /**
+     * Output format
+     */
+    format?: 'json' | 'text' | 'markdown';
+    /**
+     * Whether to include timestamp
+     */
+    timestamp?: boolean;
+    /**
+     * Custom prefix
+     */
+    prefix?: string;
+    /**
+     * Additional metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Timeout (milliseconds)
+     */
+    timeout?: number;
+}
+/**
+ * Console output handler configuration
+ */
+export interface ConsoleOutputConfig {
+    /**
+     * Whether to use colored output
+     */
+    colors?: boolean;
+    /**
+     * Log level
+     */
+    level?: 'log' | 'info' | 'warn' | 'error' | 'debug';
+}
+/**
+ * Webhook output handler configuration
+ */
+export interface WebhookOutputConfig {
+    /**
+     * Webhook URL
+     */
+    url: string;
+    /**
+     * HTTP request method
+     */
+    method?: 'POST' | 'PUT' | 'PATCH';
+    /**
+     * Request headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Authentication information
+     */
+    auth?: {
+        type: 'bearer' | 'basic' | 'custom';
+        token?: string;
+        username?: string;
+        password?: string;
+        custom?: {
+            header: string;
+            value: string;
+        };
+    };
+    /**
+     * Retry configuration
+     */
+    retry?: {
+        maxAttempts: number;
+        backoffMs: number;
+    };
+    /**
+     * Whether to handle failures silently (only log, don't throw)
+     */
+    silent?: boolean;
+}
+/**
+ * WebSocket output handler configuration (reserved for future use)
+ */
+export interface WebSocketOutputConfig {
+    /**
+     * WebSocket URL
+     */
+    url: string;
+    /**
+     * Reconnection configuration
+     */
+    reconnect?: {
+        maxAttempts: number;
+        intervalMs: number;
+    };
+    /**
+     * Heartbeat configuration
+     */
+    heartbeat?: {
+        intervalMs: number;
+        message?: string;
+    };
+}
+/**
+ * Temp file output handler configuration
+ */
+export interface TempFileOutputConfig {
+    /**
+     * Subdirectory under system temp directory (default: 'claude-code-router')
+     */
+    subdirectory?: string;
+    /**
+     * File extension (default: 'json')
+     */
+    extension?: string;
+    /**
+     * Whether to include timestamp in filename (default: true)
+     */
+    includeTimestamp?: boolean;
+    /**
+     * Custom prefix for temp files (default: 'session')
+     */
+    prefix?: string;
+}
+/**
+ * Output handler registration configuration
+ */
+export interface OutputHandlerConfig {
+    /**
+     * Output handler type
+     */
+    type: 'console' | 'webhook' | 'websocket' | 'temp-file';
+    /**
+     * Whether enabled
+     */
+    enabled?: boolean;
+    /**
+     * Configuration options
+     */
+    config?: ConsoleOutputConfig | WebhookOutputConfig | WebSocketOutputConfig | TempFileOutputConfig;
+}

package/dist/plugins/output/webhook-handler.d.ts

@@ -0,0 +1,35 @@
+import { OutputHandler, OutputOptions, WebhookOutputConfig } from './types';
+/**
+ * Webhook output handler
+ * Supports sending data to HTTP endpoints with retry and authentication
+ */
+export declare class WebhookOutputHandler implements OutputHandler {
+    type: "webhook";
+    private config;
+    private defaultTimeout;
+    constructor(config: WebhookOutputConfig);
+    /**
+     * Build request headers
+     */
+    private buildHeaders;
+    /**
+     * Build request body
+     */
+    private buildBody;
+    /**
+     * Send HTTP request
+     */
+    private sendRequest;
+    /**
+     * Delay function (for retry backoff)
+     */
+    private delay;
+    /**
+     * Send request with retry
+     */
+    private sendWithRetry;
+    /**
+     * Output data to Webhook
+     */
+    output(data: any, options?: OutputOptions): Promise<boolean>;
+}

package/dist/plugins/plugin-manager.d.ts

@@ -0,0 +1,62 @@
+import { FastifyInstance } from 'fastify';
+import { CCRPlugin, PluginMetadata } from './types';
+/**
+ * Plugin manager
+ */
+declare class PluginManager {
+    private plugins;
+    private pluginInstances;
+    /**
+     * Register a plugin
+     * @param plugin Plugin instance
+     * @param options Plugin configuration options
+     */
+    registerPlugin(plugin: CCRPlugin, options?: any): void;
+    /**
+     * Enable a single plugin
+     * @param name Plugin name
+     * @param fastify Fastify instance
+     */
+    enablePlugin(name: string, fastify: FastifyInstance): Promise<void>;
+    /**
+     * Enable all registered plugins in batch
+     * @param fastify Fastify instance
+     */
+    enablePlugins(fastify: FastifyInstance): Promise<void>;
+    /**
+     * Get list of registered plugins
+     */
+    getPlugins(): PluginMetadata[];
+    /**
+     * Get plugin instance
+     * @param name Plugin name
+     */
+    getPlugin(name: string): CCRPlugin | undefined;
+    /**
+     * Check if plugin is registered
+     * @param name Plugin name
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Check if plugin is enabled
+     * @param name Plugin name
+     */
+    isPluginEnabled(name: string): boolean;
+    /**
+     * Dynamically enable/disable plugin
+     * @param name Plugin name
+     * @param enabled Whether to enable
+     */
+    setPluginEnabled(name: string, enabled: boolean): void;
+    /**
+     * Remove plugin
+     * @param name Plugin name
+     */
+    removePlugin(name: string): void;
+    /**
+     * Clear all plugins
+     */
+    clear(): void;
+}
+export declare const pluginManager: PluginManager;
+export {};

package/dist/plugins/token-speed.d.ts

@@ -0,0 +1,5 @@
+import { CCRPlugin } from './types';
+/**
+ * Token speed measurement plugin
+ */
+export declare const tokenSpeedPlugin: CCRPlugin;

package/dist/plugins/types.d.ts

@@ -0,0 +1,25 @@
+import { FastifyPluginAsync } from 'fastify';
+/**
+ * Plugin configuration interface
+ */
+export interface CCRPluginOptions {
+    enabled?: boolean;
+    [key: string]: any;
+}
+/**
+ * Plugin interface
+ */
+export interface CCRPlugin {
+    name: string;
+    version?: string;
+    description?: string;
+    register: FastifyPluginAsync<CCRPluginOptions>;
+}
+/**
+ * Plugin metadata
+ */
+export interface PluginMetadata {
+    name: string;
+    enabled: boolean;
+    options?: any;
+}

package/dist/server.d.ts

@@ -0,0 +1,110 @@
+import { FastifyInstance, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, FastifyRegisterOptions, preHandlerHookHandler, onRequestHookHandler, preParsingHookHandler, preValidationHookHandler, preSerializationHookHandler, onSendHookHandler, onResponseHookHandler, onTimeoutHookHandler, onErrorHookHandler, onRouteHookHandler, onRegisterHookHandler, onReadyHookHandler, onListenHookHandler, onCloseHookHandler, FastifyServerOptions } from "fastify";
+import { ConfigService, AppConfig } from "./services/config";
+import { ProviderService } from "./services/provider";
+import { TransformerService } from "./services/transformer";
+import { TokenizerService } from "./services/tokenizer";
+import { router, calculateTokenCount, searchProjectBySession } from "./utils/router";
+import { sessionUsageCache } from "./utils/cache";
+import { ActiveProbeService } from "./services/active-probe";
+import type { CcrPreHandlerCallbacks } from "./ccr/request-pipeline";
+declare module "fastify" {
+    interface FastifyRequest {
+        provider?: string;
+        model?: string;
+        scenarioType?: string;
+    }
+    interface FastifyInstance {
+        _server?: Server;
+    }
+}
+export interface ServerOptions extends FastifyServerOptions {
+    initialConfig?: AppConfig;
+    jsonPath?: string;
+    envPath?: string;
+    useEnvFile?: boolean;
+    useJsonFile?: boolean;
+    useEnvironmentVariables?: boolean;
+}
+declare class Server {
+    app: FastifyInstance;
+    configService: ConfigService;
+    providerService: ProviderService;
+    transformerService: TransformerService;
+    tokenizerService: TokenizerService;
+    activeProbeService?: ActiveProbeService;
+    recordUsage?: (data: any) => void;
+    private readonly readiness;
+    private mainNamespaceRegistered;
+    private signalHandlersRegistered;
+    ccrPreHandlerCallbacks?: CcrPreHandlerCallbacks;
+    constructor(options?: ServerOptions);
+    ready(): Promise<void>;
+    register<Options extends FastifyPluginOptions = FastifyPluginOptions>(plugin: FastifyPluginAsync<Options> | FastifyPluginCallback<Options>, options?: FastifyRegisterOptions<Options>): Promise<void>;
+    addHook(hookName: "onRequest", hookFunction: onRequestHookHandler): void;
+    addHook(hookName: "preParsing", hookFunction: preParsingHookHandler): void;
+    addHook(hookName: "preValidation", hookFunction: preValidationHookHandler): void;
+    addHook(hookName: "preHandler", hookFunction: preHandlerHookHandler): void;
+    addHook(hookName: "preSerialization", hookFunction: preSerializationHookHandler): void;
+    addHook(hookName: "onSend", hookFunction: onSendHookHandler): void;
+    addHook(hookName: "onResponse", hookFunction: onResponseHookHandler): void;
+    addHook(hookName: "onTimeout", hookFunction: onTimeoutHookHandler): void;
+    addHook(hookName: "onError", hookFunction: onErrorHookHandler): void;
+    addHook(hookName: "onRoute", hookFunction: onRouteHookHandler): void;
+    addHook(hookName: "onRegister", hookFunction: onRegisterHookHandler): void;
+    addHook(hookName: "onReady", hookFunction: onReadyHookHandler): void;
+    addHook(hookName: "onListen", hookFunction: onListenHookHandler): void;
+    addHook(hookName: "onClose", hookFunction: onCloseHookHandler): void;
+    /**
+     * Register one API namespace with an explicit request-phase pipeline.
+     *
+     * Namespace hook order is independent of external/global hook registration:
+     * request normalize → adapter → router → provider model normalization → handler.
+     */
+    registerNamespace(name: string, options?: any): Promise<void>;
+    start(): Promise<void>;
+}
+export default Server;
+export { sessionUsageCache };
+export { router };
+export { calculateTokenCount };
+export { searchProjectBySession };
+export { extractSessionIdFromUserId, normalizeSessionId } from "./utils/session-id";
+export { applyClientAdapter, builtinClientAdapterRegistry, clearClientAdapterCaches, detectClientType, getClientAdapter, isClientType, } from "./clients/adapters";
+export type { ClientAdapter, ClientContext, ClientType, ClientUsageScope, } from "./clients/adapters";
+export type { RouterScenarioType, RouterFallbackConfig } from "./utils/router";
+export { ProjectRoutingError, diagnoseResolutionFailure } from "./utils/router";
+export { ConfigService } from "./services/config";
+export { ProviderService } from "./services/provider";
+export { TransformerService } from "./services/transformer";
+export { TokenizerService } from "./services/tokenizer";
+export { pluginManager, tokenSpeedPlugin } from "./plugins";
+export type { CCRPlugin, CCRPluginOptions, PluginMetadata } from "./plugins";
+export { SSEParserTransform, SSESerializerTransform, rewriteStream } from "./utils/sse";
+export { getHealthStore, ProviderHealthStore } from "./services/provider-health";
+export type { ProviderHealthState, HealthPoolConfig } from "./services/provider-health";
+export { getAllRateLimitInfo, getRateLimitInfo, initRateLimitPersistence } from "./services/rate-limit";
+export type { RateLimitInfo } from "./services/rate-limit";
+export { getQuotaAdapter } from "./services/quota-adapters";
+export type { QuotaAdapter, ProviderQuotaResult } from "./services/quota-adapters";
+export { getAllQuotaResults, getQuotaResult, storeQuotaResult, initQuotaStorePersistence } from "./services/quota-store";
+export { initProviderHealthPersistence } from "./services/provider-health";
+export type { StoredQuotaResult } from "./services/quota-store";
+export { getActiveProbeService, startActiveProbe, stopActiveProbe, resetActiveProbeService, ActiveProbeService } from "./services/active-probe";
+export type { ActiveProbeConfig } from "./services/active-probe";
+export { setRuntimeDebugLog, getRuntimeDebugLog } from "./utils/debug-log";
+export { closeProxyDispatchers, getConfiguredProxyUrl, getProxyDispatcher, isGlobalProxyEnabled, resolveProviderProxyUrl } from "./services/proxy";
+/**
+ * Create the full CCR runtime. Loaded lazily to avoid a module cycle between
+ * the base Server class and the CCR composition root.
+ */
+export declare function createCcrServer(options?: import("./ccr/create-server").CcrRunOptions): Promise<Server>;
+/** Backward-compatible name used by the CLI and the legacy server facade. */
+export declare const getServer: typeof createCcrServer;
+export type { CcrRunOptions as RunOptions } from "./ccr/create-server";
+export type { IAgent, ITool } from "./ccr/agents/type";
+export { initDir, initConfig, readConfigFile, readConfigFileRaw, writeConfigFile, backupConfigFile } from "./ccr/config";
+export { normalizeUsagePayload, mergeUsageCapture } from "./ccr/usage-merge";
+export { collectReachableModelKeys, reconcileHealthStore, clearProviderHealth } from "./ccr/health-reconcile";
+export { listAnthropicCompatibleModels } from "./ccr/models";
+export { apiKeyAuth } from "./ccr/auth";
+export * as usageStore from "./ccr/usage-store";