@caeliq/llms 1.0.55 → 1.0.57

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./server";
+export { default } from "./server";

package/dist/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { pluginManager } from './plugin-manager';
+export { tokenSpeedPlugin, getTokenSpeedStats, getGlobalTokenSpeedStats } 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,110 @@
+import { OutputHandler, OutputOptions, OutputHandlerConfig } from './types';
+/**
+ * Output manager
+ * Manages multiple output handlers and provides unified output interface
+ */
+declare class OutputManager {
+    private handlers;
+    private defaultOptions;
+    private logger;
+    setLogger(logger: any): void;
+    /**
+     * 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,53 @@
+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;
+    /**
+     * Extract session ID from user_id string
+     * Format: "user_..._session_<uuid>"
+     */
+    private extractSessionId;
+    /**
+     * 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,37 @@
+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;
+    private logger;
+    setLogger(logger: any): void;
+    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,22 @@
+import { CCRPlugin } from './types';
+/**
+ * Token statistics interface
+ */
+export interface TokenStats {
+    requestId: string;
+    sessionId?: string;
+    startTime: number;
+    firstTokenTime?: number;
+    lastTokenTime: number;
+    tokenCount: number;
+    tokensPerSecond: number;
+    timeToFirstToken?: number;
+    stream: boolean;
+    tokenTimestamps: number[];
+}
+export declare function getTokenSpeedStats(requestId: string): TokenStats | undefined;
+export declare function getGlobalTokenSpeedStats(): TokenStats[];
+/**
+ * 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,60 @@
+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";
+declare module "fastify" {
+    interface FastifyRequest {
+        provider?: string;
+        model?: string;
+        scenarioType?: string;
+    }
+    interface FastifyInstance {
+        _server?: Server;
+    }
+}
+interface ServerOptions extends FastifyServerOptions {
+    initialConfig?: AppConfig;
+}
+declare class Server {
+    app: FastifyInstance;
+    configService: ConfigService;
+    providerService: ProviderService;
+    transformerService: TransformerService;
+    tokenizerService: TokenizerService;
+    constructor(options?: ServerOptions);
+    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;
+    registerNamespace(name: string, options?: any): Promise<void>;
+    start(): Promise<void>;
+}
+export default Server;
+export { sessionUsageCache };
+export { router };
+export { calculateTokenCount };
+export { searchProjectBySession };
+export type { RouterScenarioType, RouterFallbackConfig } 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, getTokenSpeedStats, getGlobalTokenSpeedStats, CCRPlugin, CCRPluginOptions, PluginMetadata } from "./plugins";
+export { SSEParserTransform, SSESerializerTransform, rewriteStream } from "./utils/sse";
+export { isClientAbortError } from "./utils/retry";
+export { sanitizeHeadersForLog, diffHeadersForLog, } from "./utils/redact";
+export { exchangeAuthorizationCode, fetchUserEmail, resolveProjectId, saveTokens, loadTokens, getValidAccessToken, ANTIGRAVITY_CLIENT_ID, ANTIGRAVITY_CLIENT_SECRET, ANTIGRAVITY_REDIRECT_URI, ANTIGRAVITY_SCOPES, type AntigravityTokens, } from "./utils/antigravity-auth";

package/dist/services/config.d.ts

@@ -0,0 +1,32 @@
+export interface ConfigOptions {
+    envPath?: string;
+    jsonPath?: string;
+    useEnvFile?: boolean;
+    useJsonFile?: boolean;
+    useEnvironmentVariables?: boolean;
+    initialConfig?: AppConfig;
+    logger?: any;
+}
+export interface AppConfig {
+    [key: string]: any;
+}
+export declare class ConfigService {
+    private config;
+    private options;
+    private logger;
+    constructor(options?: ConfigOptions);
+    private loadConfig;
+    private loadJsonConfig;
+    private loadEnvConfig;
+    private loadEnvironmentVariables;
+    private parseEnvConfig;
+    private isAbsolutePath;
+    get<T = any>(key: keyof AppConfig): T | undefined;
+    get<T = any>(key: keyof AppConfig, defaultValue: T): T;
+    getAll(): AppConfig;
+    getHttpsProxy(): string | undefined;
+    has(key: keyof AppConfig): boolean;
+    set(key: keyof AppConfig, value: any): void;
+    reload(): void;
+    getConfigSummary(): string;
+}

package/dist/services/provider.d.ts

@@ -0,0 +1,34 @@
+import { LLMProvider, RegisterProviderRequest, ModelRoute, RequestRouteInfo } from "../types/llm";
+import { ConfigService } from "./config";
+import { TransformerService } from "./transformer";
+export declare class ProviderService {
+    private readonly configService;
+    private readonly transformerService;
+    private readonly logger;
+    private providers;
+    private modelRoutes;
+    constructor(configService: ConfigService, transformerService: TransformerService, logger: any);
+    private initializeCustomProviders;
+    private initializeFromProvidersArray;
+    /** Match TransformerService: instances used in provider use[] need the service logger. */
+    private attachTransformerLogger;
+    registerProvider(request: RegisterProviderRequest): LLMProvider;
+    getProviders(): LLMProvider[];
+    getProvider(name: string): LLMProvider | undefined;
+    updateProvider(id: string, updates: Partial<LLMProvider>): LLMProvider | null;
+    deleteProvider(id: string): boolean;
+    toggleProvider(name: string, enabled: boolean): boolean;
+    resolveModelRoute(modelName: string): RequestRouteInfo | null;
+    getAvailableModelNames(): string[];
+    getModelRoutes(): ModelRoute[];
+    private parseTransformerConfig;
+    getAvailableModels(): Promise<{
+        object: string;
+        data: Array<{
+            id: string;
+            object: string;
+            owned_by: string;
+            provider: string;
+        }>;
+    }>;
+}