minimax-mcp-tools/dist/core/task-manager.d.ts

Async MCP server with Minimax API integration for image generation and text-to-speech

import { MinimaxError } from '../utils/error-handler.js';
interface TaskResult {
    success: boolean;
    result?: any;
    error?: MinimaxError;
    completedAt: number;
}
interface TaskSubmissionResult {
    taskId: string;
    promise: Promise<any>;
}
interface BarrierResult {
    completed: number;
    results: (TaskResult & {
        taskId: string;
    })[];
}
interface TaskStatus {
    status: 'running' | 'completed' | 'not_found';
    taskId: string;
    success?: boolean;
    result?: any;
    error?: MinimaxError;
    completedAt?: number;
}
interface AllTasksStatus {
    running: Array<{
        taskId: string;
        status: 'running';
    }>;
    completed: Array<{
        taskId: string;
        status: 'completed';
    } & TaskResult>;
    total: number;
}
interface TaskStats {
    activeTasks: number;
    completedTasks: number;
    totalProcessed: number;
}
interface TaskMetrics {
    requests: number;
    successes: number;
    errors: number;
}
interface RateLimitedTaskManagerOptions {
    backoffFactor?: number;
    recoveryFactor?: number;
}
export declare class TaskManager {
    protected tasks: Map<string, Promise<any>>;
    protected completedTasks: Map<string, TaskResult>;
    protected taskCounter: number;
    constructor();
    protected generateTaskId(): string;
    submit(fn: () => Promise<any>, taskId?: string | null): Promise<TaskSubmissionResult>;
    barrier(): Promise<BarrierResult>;
    getTaskStatus(taskId: string): TaskStatus;
    getAllTasksStatus(): AllTasksStatus;
    clearCompletedTasks(): number;
    getStats(): TaskStats;
}
export declare class RateLimitedTaskManager extends TaskManager {
    private rateLimiters;
    private metrics;
    private taskCounters;
    constructor(options?: RateLimitedTaskManagerOptions);
    submitImageTask(fn: () => Promise<any>, taskId?: string | null): Promise<TaskSubmissionResult>;
    submitTTSTask(fn: () => Promise<any>, taskId?: string | null): Promise<TaskSubmissionResult>;
    private submitRateLimitedTask;
    getRateLimiterStatus(): {
        image: import("./rate-limiter.js").AdaptiveStatus;
        tts: import("./rate-limiter.js").AdaptiveStatus;
    };
    getMetrics(): {
        rateLimiters: {
            image: import("./rate-limiter.js").AdaptiveStatus;
            tts: import("./rate-limiter.js").AdaptiveStatus;
        };
        image: TaskMetrics;
        tts: TaskMetrics;
    };
    resetMetrics(): void;
}
export {};
//# sourceMappingURL=task-manager.d.ts.map