@layr-labs/hourglass-performer/dist/server/performerServer.d.ts

TypeScript SDK for building Hourglass AVS performers

import * as grpc from '@grpc/grpc-js';
import { PerformerServerConfig, TaskRequest, TaskResponse, HealthCheckRequest, HealthCheckResponse, StartSyncRequest, StartSyncResponse, PerformerStatus } from '../types/performer';
import { IWorker } from '../worker/iWorker';
import { TaskProcessorConfig } from './taskProcessor';
import { HealthCheckConfig } from './healthManager';
import { MetricsConfig } from '../utils/metrics';
/**
 * PerformerServer class that implements the gRPC PerformerService
 * This mirrors the Go PonosPerformer structure
 */
export declare class PerformerServer {
    private server;
    private config;
    private worker;
    private logger;
    private taskProcessor;
    private healthManager;
    private metricsCollector;
    private diagnosticTool;
    private isRunning;
    constructor(worker: IWorker, config?: PerformerServerConfig, taskProcessorConfig?: TaskProcessorConfig, healthConfig?: HealthCheckConfig, metricsConfig?: MetricsConfig);
    /**
     * Set up the gRPC server with the PerformerService
     */
    private setupGrpcServer;
    /**
     * Start the gRPC server
     */
    start(): Promise<void>;
    /**
     * Stop the gRPC server gracefully
     */
    stop(): Promise<void>;
    /**
     * Execute a task (gRPC handler)
     */
    executeTask(call: grpc.ServerUnaryCall<TaskRequest, TaskResponse>, callback: grpc.sendUnaryData<TaskResponse>): Promise<void>;
    /**
     * Get task execution metrics
     */
    getTaskMetrics(): import("./taskContext").TaskMetrics[];
    /**
     * Clear accumulated task metrics
     */
    clearTaskMetrics(): void;
    /**
     * Add custom serialization strategy
     */
    addSerializationStrategy(strategy: any): void;
    /**
     * Health check (gRPC handler)
     */
    healthCheck(call: grpc.ServerUnaryCall<HealthCheckRequest, HealthCheckResponse>, callback: grpc.sendUnaryData<HealthCheckResponse>): Promise<void>;
    /**
     * Start sync (gRPC handler)
     */
    startSync(call: grpc.ServerUnaryCall<StartSyncRequest, StartSyncResponse>, callback: grpc.sendUnaryData<StartSyncResponse>): Promise<void>;
    /**
     * Convert application errors to gRPC errors
     */
    private createGrpcError;
    /**
     * PerformerService interface implementation
     */
    ExecuteTask(request: TaskRequest): Promise<TaskResponse>;
    HealthCheck(request: HealthCheckRequest): Promise<HealthCheckResponse>;
    StartSync(request: StartSyncRequest): Promise<StartSyncResponse>;
    /**
     * Set up graceful shutdown handlers
     */
    setupGracefulShutdown(): void;
    /**
     * Get server status
     */
    getStatus(): {
        isRunning: boolean;
        config: Required<PerformerServerConfig>;
    };
    /**
     * Get comprehensive health information
     */
    getHealthInfo(): Promise<import("./healthManager").HealthCheckResult>;
    /**
     * Get health summary
     */
    getHealthSummary(): {
        status: PerformerStatus;
        uptime: number;
        taskCount: number;
        errorCount: number;
        memoryUsageMB: number;
    };
    /**
     * Get metrics summary
     */
    getMetricsSummary(): {
        totalMetrics: number;
        counters: number;
        gauges: number;
        histograms: number;
        oldestTimestamp?: number;
        newestTimestamp?: number;
    };
    /**
     * Get diagnostic report
     */
    getDiagnosticReport(): string;
    /**
     * Add custom health check provider
     */
    addHealthProvider(provider: any): void;
    /**
     * Add custom metrics exporter
     */
    addMetricsExporter(exporter: any): void;
    /**
     * Record custom metric
     */
    recordMetric(name: string, value: number, labels?: Record<string, string>): void;
    /**
     * Get active diagnostic traces
     */
    getActiveTraces(): any[];
}
//# sourceMappingURL=performerServer.d.ts.map