@sethdouglasford/claude-flow/dist/swarm/optimizations/connection-pool.d.ts

Claude Code Flow - Advanced AI-powered development workflows with SPARC methodology

/**
 * Connection Pool for Claude API
 * Manages reusable connections to improve performance
 */
import { EventEmitter } from "node:events";
import { Anthropic } from "@anthropic-ai/sdk";
export declare class ClaudeAPI {
    private client;
    private connected;
    private apiKey;
    private baseURL?;
    private defaultModel;
    constructor(options: {
        apiKey: string;
        baseURL?: string;
        defaultModel?: string;
    });
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    isConnected(): boolean;
    complete(options: {
        messages: Anthropic.Messages.MessageParam[];
        model?: string;
        max_tokens?: number;
        temperature?: number;
        system?: string;
        tools?: Anthropic.Messages.Tool[];
        tool_choice?: Anthropic.Messages.ToolChoice;
        stop_sequences?: string[];
        stream?: boolean;
    }): Promise<Anthropic.Messages.Message>;
    streamComplete(options: {
        messages: Anthropic.Messages.MessageParam[];
        model?: string;
        max_tokens?: number;
        temperature?: number;
        system?: string;
        tools?: Anthropic.Messages.Tool[];
        tool_choice?: Anthropic.Messages.ToolChoice;
        stop_sequences?: string[];
        onChunk?: (chunk: any) => void;
    }): Promise<Anthropic.Messages.Message>;
    healthCheck(): Promise<boolean>;
    getModel(): string;
    setModel(model: string): void;
}
export interface PoolConfig {
    min: number;
    max: number;
    acquireTimeoutMillis: number;
    idleTimeoutMillis: number;
    evictionRunIntervalMillis: number;
    testOnBorrow: boolean;
    apiKey: string;
    baseURL?: string;
    defaultModel?: string;
}
export interface PooledConnection {
    id: string;
    api: ClaudeAPI;
    inUse: boolean;
    createdAt: Date;
    lastUsedAt: Date;
    useCount: number;
    totalRequests: number;
    totalErrors: number;
    avgResponseTime: number;
}
export interface PoolStats {
    total: number;
    active: number;
    idle: number;
    waiting: number;
    created: number;
    destroyed: number;
    borrowed: number;
    returned: number;
    totalRequests: number;
    totalErrors: number;
    avgResponseTime: number;
    poolUtilization: number;
}
export declare class ClaudeConnectionPool extends EventEmitter {
    private connections;
    private waitingQueue;
    private config;
    private logger;
    private evictionTimer?;
    private healthCheckTimer?;
    private isShuttingDown;
    private stats;
    constructor(config: Partial<PoolConfig> & {
        apiKey: string;
    });
    private initialize;
    private createConnection;
    acquire(): Promise<PooledConnection>;
    release(connection: PooledConnection): Promise<void>;
    execute<T>(fn: (api: ClaudeAPI) => Promise<T>): Promise<T>;
    private testConnection;
    private destroyConnection;
    private evictIdleConnections;
    private performHealthChecks;
    drain(): Promise<void>;
    private hasActiveConnections;
    getStats(): PoolStats;
    getConnectionDetails(): Array<{
        id: string;
        inUse: boolean;
        createdAt: Date;
        lastUsedAt: Date;
        useCount: number;
        totalRequests: number;
        totalErrors: number;
        avgResponseTime: number;
    }>;
    warmUp(): Promise<void>;
}
//# sourceMappingURL=connection-pool.d.ts.map