@iqai/mcp-near-agent/dist/services/event-processor.d.ts

Mcp server for Near

import { EventEmitter } from "node:events";
import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
import type { Account } from "near-api-js";
import type { AgentEvent } from "../types.js";
import type { EventSubscription } from "./subscription-manager.js";
export interface ProcessingResult {
    success: boolean;
    response?: string;
    error?: string;
    requestId: string;
    subscription: EventSubscription;
    event: AgentEvent;
    processingTime: number;
}
export interface EventContext {
    subscription: EventSubscription;
    event: AgentEvent;
    account: Account;
}
export interface EventProcessorEvents {
    "event:processed": [result: ProcessingResult];
    "event:processing-error": [result: ProcessingResult];
    "event:mcp-request": [context: EventContext];
    "event:mcp-response": [context: EventContext, response: any];
    "event:blockchain-response": [context: EventContext, txHash: string];
    "queue:added": [requestId: string, context: EventContext];
    "queue:removed": [requestId: string];
    "stats:updated": [stats: ProcessingStats];
}
export interface ProcessingStats {
    totalProcessed: number;
    successful: number;
    failed: number;
    averageProcessingTime: number;
    successRate: number;
    currentQueueSize: number;
}
export declare class EventProcessor extends EventEmitter<EventProcessorEvents> {
    private static readonly DEFAULT_MAX_TOKENS;
    private static readonly DEFAULT_TIMEOUT;
    private account;
    private server;
    private processingQueue;
    private processingStats;
    constructor(account?: Account, server?: Server);
    /**
     * Set the NEAR account for blockchain interactions
     */
    setAccount(account: Account): void;
    /**
     * Set the MCP server for creating messages
     */
    setServer(server: Server): void;
    /**
     * Process an event by requesting sampling from MCP client and sending response to blockchain
     */
    processEvent(context: EventContext): Promise<ProcessingResult>;
    /**
     * Request sampling from MCP client using server.createMessage
     */
    private requestMCPSampling;
    /**
     * Format event data for MCP sampling
     */
    private formatEventForSampling;
    /**
     * Send response back to the NEAR blockchain
     */
    private sendBlockchainResponse;
    /**
     * Update processing statistics
     */
    private updateStats;
    /**
     * Get current processing queue status
     */
    getQueueStatus(): {
        queueSize: number;
        processingItems: {
            requestId: string;
            eventType: string;
            contractId: string;
            timestamp: number;
        }[];
    };
    /**
     * Get processing statistics
     */
    getStats(): ProcessingStats;
    /**
     * Check if a request is currently being processed
     */
    isProcessing(requestId: string): boolean;
    /**
     * Get all currently processing request IDs
     */
    getProcessingRequestIds(): string[];
    /**
     * Cancel processing for a specific request (if still in queue)
     */
    cancelProcessing(requestId: string): boolean;
    /**
     * Reset statistics
     */
    resetStats(): void;
    /**
     * Cleanup resources
     */
    cleanup(): void;
    on<K extends keyof EventProcessorEvents>(event: K, listener: (...args: EventProcessorEvents[K]) => void): this;
    emit<K extends keyof EventProcessorEvents>(event: K, ...args: EventProcessorEvents[K]): boolean;
    off<K extends keyof EventProcessorEvents>(event: K, listener: (...args: EventProcessorEvents[K]) => void): this;
    once<K extends keyof EventProcessorEvents>(event: K, listener: (...args: EventProcessorEvents[K]) => void): this;
}