@adhisang/minecraft-modding-mcp 2.0.0 → 2.1.0

package/dist/stdio-supervisor.d.ts

@@ -0,0 +1,46 @@
+type SupervisorOptions = {
+    entryFile: string;
+};
+export declare class StdioSupervisor {
+    private readonly entryFile;
+    private readonly clientReader;
+    private readonly workerReader;
+    private readonly queuedMessages;
+    private readonly pendingRequests;
+    private child;
+    private childReady;
+    private shuttingDown;
+    private restartTimer;
+    private workerStderrBuffer;
+    private clientMode;
+    private initializeRequest;
+    private initializedNotification;
+    private clientInitialized;
+    private replayingInitialization;
+    private initializeSentToWorker;
+    constructor(options: SupervisorOptions);
+    start(): Promise<void>;
+    private readonly handleClientData;
+    private readonly handleClientError;
+    private readonly handleClientClosed;
+    private readonly handleTerminateSignal;
+    private handleClientMessage;
+    private forwardToWorker;
+    private spawnWorker;
+    private readonly handleWorkerData;
+    private readonly handleWorkerStdinError;
+    private readonly handleWorkerStderr;
+    private readonly handleWorkerProcessError;
+    private readonly handleWorkerExit;
+    private handleWorkerMessage;
+    private handleWorkerReady;
+    private isInitializationResponse;
+    private flushQueue;
+    private failPendingRequestsOnWorkerExit;
+    private writeToClient;
+    private scheduleRestart;
+    private detachChild;
+    private shutdown;
+}
+export declare const STDIO_WORKER_MODE_ENV = "MCP_STDIO_WORKER_MODE";
+export {};

package/dist/stdio-supervisor.js

@@ -0,0 +1,349 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { encodeJsonRpcMessage, JsonRpcFrameReader } from "./json-rpc-framing.js";
+import { log } from "./logger.js";
+const DEFAULT_CLIENT_MODE = "line";
+const WORKER_MODE_ENV = "MCP_STDIO_WORKER_MODE";
+const WORKER_READY_MARKER = "__MCP_STDIO_WORKER_READY__";
+const SUPERVISOR_DEBUG_ENABLED = process.env.MCP_SUPERVISOR_DEBUG === "1";
+function isRequest(message) {
+    return "method" in message && "id" in message;
+}
+function isNotification(message) {
+    return "method" in message && !("id" in message);
+}
+function isResponse(message) {
+    return !("method" in message) && "id" in message;
+}
+function getTrackedRequestId(message) {
+    return typeof message.id === "string" || typeof message.id === "number"
+        ? message.id
+        : undefined;
+}
+function requestKey(id) {
+    return `${typeof id}:${String(id)}`;
+}
+function buildWorkerRestartError(id) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code: -32603,
+            message: "MCP worker restarted while handling the request. Retry the request."
+        }
+    };
+}
+function debugSupervisor(event, details) {
+    if (!SUPERVISOR_DEBUG_ENABLED) {
+        return;
+    }
+    log("info", `supervisor.debug.${event}`, details);
+}
+export class StdioSupervisor {
+    entryFile;
+    clientReader = new JsonRpcFrameReader();
+    workerReader = new JsonRpcFrameReader();
+    queuedMessages = [];
+    pendingRequests = new Map();
+    child;
+    childReady = false;
+    shuttingDown = false;
+    restartTimer;
+    workerStderrBuffer = "";
+    clientMode = DEFAULT_CLIENT_MODE;
+    initializeRequest;
+    initializedNotification;
+    clientInitialized = false;
+    replayingInitialization = false;
+    initializeSentToWorker = false;
+    constructor(options) {
+        this.entryFile = options.entryFile;
+    }
+    async start() {
+        process.stdin.on("data", this.handleClientData);
+        process.stdin.on("error", this.handleClientError);
+        process.stdin.on("end", this.handleClientClosed);
+        process.stdin.on("close", this.handleClientClosed);
+        process.stdin.resume();
+        process.on("SIGINT", this.handleTerminateSignal);
+        process.on("SIGTERM", this.handleTerminateSignal);
+        this.spawnWorker();
+    }
+    handleClientData = (chunk) => {
+        this.clientReader.processChunk(chunk, {
+            onFrame: ({ message, mode }) => {
+                this.clientMode = mode;
+                this.handleClientMessage(message);
+            },
+            onError: (error) => {
+                log("warn", "supervisor.client_parse_error", { message: error.message });
+            }
+        });
+    };
+    handleClientError = (error) => {
+        log("warn", "supervisor.client_stream_error", { message: error.message });
+    };
+    handleClientClosed = () => {
+        void this.shutdown();
+    };
+    handleTerminateSignal = () => {
+        void this.shutdown();
+    };
+    handleClientMessage(message) {
+        debugSupervisor("client_message", {
+            hasMethod: "method" in message,
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined,
+            childReady: this.childReady
+        });
+        if (isRequest(message) && message.method === "initialize") {
+            this.initializeRequest = message;
+            this.clientInitialized = false;
+        }
+        else if (isNotification(message) && message.method === "notifications/initialized") {
+            this.initializedNotification = message;
+        }
+        if (!this.childReady) {
+            this.queuedMessages.push(message);
+            return;
+        }
+        this.forwardToWorker(message);
+    }
+    forwardToWorker(message) {
+        const child = this.child;
+        if (!child || child.stdin.destroyed) {
+            this.queuedMessages.push(message);
+            if (!this.shuttingDown) {
+                this.scheduleRestart();
+            }
+            return;
+        }
+        if (isRequest(message)) {
+            const id = getTrackedRequestId(message);
+            if (id !== undefined) {
+                this.pendingRequests.set(requestKey(id), {
+                    id,
+                    method: message.method
+                });
+            }
+            if (message.method === "initialize") {
+                this.initializeSentToWorker = true;
+            }
+        }
+        debugSupervisor("forward_to_worker", {
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined
+        });
+        child.stdin.write(encodeJsonRpcMessage(message, "content-length"));
+    }
+    spawnWorker() {
+        if (this.shuttingDown) {
+            return;
+        }
+        const child = spawn(process.execPath, [...process.execArgv, this.entryFile], {
+            env: {
+                ...process.env,
+                [WORKER_MODE_ENV]: "1"
+            },
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        this.child = child;
+        this.childReady = false;
+        this.initializeSentToWorker = false;
+        this.workerReader.clear();
+        this.workerStderrBuffer = "";
+        child.stdout.on("data", this.handleWorkerData);
+        child.stderr.on("data", this.handleWorkerStderr);
+        child.stdin.on("error", this.handleWorkerStdinError);
+        child.once("error", this.handleWorkerProcessError);
+        child.once("exit", this.handleWorkerExit);
+        log("info", "supervisor.worker_spawn", { pid: child.pid });
+    }
+    handleWorkerData = (chunk) => {
+        this.workerReader.processChunk(chunk, {
+            onFrame: ({ message }) => {
+                this.handleWorkerMessage(message);
+            },
+            onError: (error) => {
+                log("warn", "supervisor.worker_parse_error", { message: error.message });
+            }
+        });
+    };
+    handleWorkerStdinError = (error) => {
+        if (error.code === "EPIPE") {
+            return;
+        }
+        log("warn", "supervisor.worker_stdin_error", { message: error.message });
+    };
+    handleWorkerStderr = (chunk) => {
+        this.workerStderrBuffer += chunk.toString();
+        const lines = this.workerStderrBuffer.split(/\r?\n/);
+        this.workerStderrBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line === WORKER_READY_MARKER) {
+                this.handleWorkerReady();
+                continue;
+            }
+            process.stderr.write(`${line}\n`);
+        }
+    };
+    handleWorkerProcessError = (error) => {
+        log("error", "supervisor.worker_process_error", { message: error.message });
+    };
+    handleWorkerExit = (code, signal) => {
+        const childPid = this.child?.pid;
+        this.detachChild();
+        if (this.shuttingDown) {
+            return;
+        }
+        log("warn", "supervisor.worker_exit", {
+            pid: childPid,
+            code,
+            signal,
+            pendingRequests: this.pendingRequests.size
+        });
+        this.failPendingRequestsOnWorkerExit();
+        this.scheduleRestart();
+    };
+    handleWorkerMessage(message) {
+        debugSupervisor("worker_message", {
+            hasMethod: "method" in message,
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined,
+            replayingInitialization: this.replayingInitialization
+        });
+        if (this.isInitializationResponse(message)) {
+            const id = getTrackedRequestId(message);
+            if (id !== undefined) {
+                this.pendingRequests.delete(requestKey(id));
+            }
+            if (this.replayingInitialization) {
+                this.replayingInitialization = false;
+                if (this.initializedNotification) {
+                    this.forwardToWorker(this.initializedNotification);
+                }
+                this.childReady = true;
+                this.flushQueue();
+                return;
+            }
+            this.clientInitialized = true;
+            this.childReady = true;
+            this.writeToClient(message);
+            this.flushQueue();
+            return;
+        }
+        if (isResponse(message)) {
+            const id = getTrackedRequestId(message);
+            if (id !== undefined) {
+                this.pendingRequests.delete(requestKey(id));
+            }
+        }
+        this.writeToClient(message);
+    }
+    handleWorkerReady() {
+        debugSupervisor("worker_ready", {
+            hasInitializeRequest: this.initializeRequest !== undefined,
+            clientInitialized: this.clientInitialized
+        });
+        if (!this.initializeRequest) {
+            this.childReady = true;
+            this.flushQueue();
+            return;
+        }
+        this.replayingInitialization = this.clientInitialized;
+        this.forwardToWorker(this.initializeRequest);
+    }
+    isInitializationResponse(message) {
+        const id = isResponse(message) ? getTrackedRequestId(message) : undefined;
+        const initializeId = this.initializeRequest
+            ? getTrackedRequestId(this.initializeRequest)
+            : undefined;
+        return (id !== undefined &&
+            initializeId !== undefined &&
+            requestKey(id) === requestKey(initializeId));
+    }
+    flushQueue() {
+        if (!this.childReady || this.queuedMessages.length === 0) {
+            return;
+        }
+        const pending = this.queuedMessages.splice(0, this.queuedMessages.length);
+        for (const message of pending) {
+            if (this.initializeSentToWorker &&
+                isRequest(message) &&
+                message.method === "initialize" &&
+                this.initializeRequest !== undefined &&
+                getTrackedRequestId(message) === getTrackedRequestId(this.initializeRequest)) {
+                continue;
+            }
+            this.forwardToWorker(message);
+        }
+    }
+    failPendingRequestsOnWorkerExit() {
+        const preservedInitializeKey = this.initializeRequest && !this.clientInitialized
+            ? requestKey(this.initializeRequest.id)
+            : undefined;
+        for (const [key, pending] of [...this.pendingRequests.entries()]) {
+            if (key === preservedInitializeKey) {
+                continue;
+            }
+            this.pendingRequests.delete(key);
+            this.writeToClient(buildWorkerRestartError(pending.id));
+        }
+    }
+    writeToClient(message) {
+        debugSupervisor("write_to_client", {
+            hasMethod: "method" in message,
+            method: "method" in message ? message.method : undefined,
+            id: "id" in message ? message.id : undefined,
+            clientMode: this.clientMode
+        });
+        const frame = encodeJsonRpcMessage(message, this.clientMode);
+        process.stdout.write(frame);
+    }
+    scheduleRestart() {
+        if (this.restartTimer || this.shuttingDown) {
+            return;
+        }
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = undefined;
+            this.spawnWorker();
+        }, 100);
+    }
+    detachChild() {
+        const child = this.child;
+        if (!child) {
+            this.childReady = false;
+            return;
+        }
+        child.stdout.off("data", this.handleWorkerData);
+        child.stderr.off("data", this.handleWorkerStderr);
+        child.stdin.off("error", this.handleWorkerStdinError);
+        child.off("error", this.handleWorkerProcessError);
+        child.off("exit", this.handleWorkerExit);
+        this.child = undefined;
+        this.childReady = false;
+    }
+    async shutdown() {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        if (this.restartTimer) {
+            clearTimeout(this.restartTimer);
+            this.restartTimer = undefined;
+        }
+        process.stdin.off("data", this.handleClientData);
+        process.stdin.off("error", this.handleClientError);
+        process.stdin.off("end", this.handleClientClosed);
+        process.stdin.off("close", this.handleClientClosed);
+        process.off("SIGINT", this.handleTerminateSignal);
+        process.off("SIGTERM", this.handleTerminateSignal);
+        const child = this.child;
+        this.detachChild();
+        if (child && child.exitCode === null) {
+            child.kill("SIGTERM");
+        }
+    }
+}
+export const STDIO_WORKER_MODE_ENV = WORKER_MODE_ENV;
+//# sourceMappingURL=stdio-supervisor.js.map

package/dist/storage/files-repo.d.ts

@@ -33,12 +33,6 @@ export interface SearchFileCandidateResult {
 export interface SearchFilesWithContentResult extends SearchFilesResult {
     content: string;
 }
-export interface FileContentPrefixRow {
-    artifactId: string;
-    filePath: string;
-    contentPrefix: string;
-    truncated: boolean;
-}
 export interface ListFileRowsOptions {
     limit: number;
     cursor?: string;
@@ -56,7 +50,7 @@ export declare class FilesRepo {
     private readonly searchPathStmt;
     private readonly searchFtsStmt;
     private readonly getByPathsStmtCache;
-    private readonly getPrefixByPathsStmtCache;
+    private readonly classLookupStmtCache;
     constructor(db: SqliteDatabase);
     clearFilesForArtifact(artifactId: string): void;
     insertFilesForArtifact(artifactId: string, files: IndexedFile[]): void;
@@ -66,7 +60,6 @@ export declare class FilesRepo {
     listFiles(artifactId: string, options: ListFilesOptions): PagedResult<string>;
     listFileRows(artifactId: string, options: ListFileRowsOptions): PagedResult<FileRow>;
     getFileContentsByPaths(artifactId: string, filePaths: string[]): FileRow[];
-    getFileContentPrefixesByPaths(artifactId: string, filePaths: string[], maxChars: number): FileContentPrefixRow[];
     searchFileCandidates(artifactId: string, options: SearchFilesOptions): PagedResult<SearchFileCandidateResult> & {
         scannedRows: number;
         dbRoundtrips: number;
@@ -78,10 +71,11 @@ export declare class FilesRepo {
     countTextCandidates(artifactId: string, query: string): number;
     countPathCandidates(artifactId: string, query: string): number;
     findFirstFilePathByName(artifactId: string, fileName: string): string | undefined;
+    private getClassLookupStmt;
+    findBestClassLookupPath(artifactId: string, exactFilePaths: string[], qualifiedClassName: string, simpleName: string, expectedPrefix: string): string | undefined;
     searchFiles(artifactId: string, options: SearchFilesOptions): PagedResult<SearchFilesResult>;
     totalContentBytes(): number;
     contentBytesForArtifact(artifactId: string): number;
     private getFileContentsByPathsStmt;
-    private getFileContentPrefixesByPathsStmt;
 }
 export {};

package/dist/storage/files-repo.js

@@ -114,7 +114,7 @@ export class FilesRepo {
     searchPathStmt;
     searchFtsStmt;
     getByPathsStmtCache = new Map();
-    getPrefixByPathsStmtCache = new Map();
+    classLookupStmtCache = new Map();
     constructor(db) {
         this.db = db;
         this.deleteStmt = this.db.prepare(`
@@ -250,27 +250,6 @@ export class FilesRepo {
         ]));
         return uniquePaths.map((path) => byPath.get(path)).filter((row) => row != null);
     }
-    getFileContentPrefixesByPaths(artifactId, filePaths, maxChars) {
-        if (filePaths.length === 0) {
-            return [];
-        }
-        const normalizedMaxChars = Math.max(1, Math.trunc(maxChars));
-        const uniquePaths = [...new Set(filePaths)];
-        const stmt = this.getFileContentPrefixesByPathsStmt(uniquePaths.length, normalizedMaxChars);
-        const rows = stmt.all(normalizedMaxChars, artifactId, ...uniquePaths);
-        const byPath = new Map(rows.map((row) => [
-            row.file_path,
-            {
-                artifactId: row.artifact_id,
-                filePath: row.file_path,
-                contentPrefix: row.content_prefix,
-                truncated: row.content_length > row.content_prefix.length
-            }
-        ]));
-        return uniquePaths
-            .map((path) => byPath.get(path))
-            .filter((row) => row != null);
-    }
     searchFileCandidates(artifactId, options) {
         const normalized = options.query.trim();
         if (!normalized) {
@@ -438,6 +417,65 @@ export class FilesRepo {
             .get(artifactId, normalized, `%/${normalized}`);
         return row?.file_path;
     }
+    getClassLookupStmt(exactPathCount) {
+        const cached = this.classLookupStmtCache.get(exactPathCount);
+        if (cached) {
+            return cached;
+        }
+        const exactPlaceholders = Array.from({ length: exactPathCount }, () => "?").join(", ");
+        const statement = this.db.prepare(`
+      WITH ranked_candidates AS (
+        SELECT file_path, 0 AS rank
+        FROM files
+        WHERE artifact_id = ?
+          AND file_path IN (${exactPlaceholders})
+
+        UNION ALL
+
+        SELECT file_path,
+          CASE
+            WHEN qualified_name = ? THEN 1
+            WHEN symbol_name = ? THEN 2
+            ELSE 3
+          END AS rank
+        FROM symbols
+        WHERE artifact_id = ?
+          AND symbol_kind = 'class'
+          AND (
+            qualified_name = ?
+            OR symbol_name = ?
+            OR qualified_name LIKE ?
+          )
+          AND (? = '' OR instr(file_path, ?) = 1)
+
+        UNION ALL
+
+        SELECT file_path, 4 AS rank
+        FROM files
+        WHERE artifact_id = ?
+          AND (file_path = ? OR file_path LIKE ? ESCAPE '\\')
+          AND (? = '' OR instr(file_path, ?) = 1)
+      )
+      SELECT file_path
+      FROM ranked_candidates
+      ORDER BY rank ASC, file_path ASC
+      LIMIT 1
+    `);
+        this.classLookupStmtCache.set(exactPathCount, statement);
+        return statement;
+    }
+    findBestClassLookupPath(artifactId, exactFilePaths, qualifiedClassName, simpleName, expectedPrefix) {
+        const normalizedExactFilePaths = [...new Set(exactFilePaths.map((entry) => entry.trim()).filter(Boolean))];
+        const normalizedClassName = qualifiedClassName.trim();
+        const normalizedSimpleName = simpleName.trim();
+        if (normalizedExactFilePaths.length === 0 || !normalizedClassName || !normalizedSimpleName) {
+            return undefined;
+        }
+        const stmt = this.getClassLookupStmt(normalizedExactFilePaths.length);
+        const fileName = `${normalizedSimpleName}.java`;
+        const row = stmt.get(artifactId, ...normalizedExactFilePaths, normalizedClassName, normalizedSimpleName, artifactId, normalizedClassName, normalizedSimpleName, `%.${normalizedSimpleName}`, expectedPrefix, expectedPrefix, artifactId, fileName, `%/${fileName}`, expectedPrefix, expectedPrefix);
+        return row?.file_path;
+    }
     searchFiles(artifactId, options) {
         const page = this.searchFilesWithContent(artifactId, options);
         return {
@@ -468,10 +506,15 @@ export class FilesRepo {
         const normalizedCount = Math.max(1, Math.trunc(pathCount));
         const cached = this.getByPathsStmtCache.get(normalizedCount);
         if (cached) {
+            this.getByPathsStmtCache.delete(normalizedCount);
+            this.getByPathsStmtCache.set(normalizedCount, cached);
             return cached;
         }
         if (this.getByPathsStmtCache.size >= 64) {
-            this.getByPathsStmtCache.clear();
+            const oldestKey = this.getByPathsStmtCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.getByPathsStmtCache.delete(oldestKey);
+            }
         }
         const placeholders = Array.from({ length: normalizedCount }, () => "?").join(", ");
         const stmt = this.db.prepare(`
@@ -482,25 +525,5 @@ export class FilesRepo {
         this.getByPathsStmtCache.set(normalizedCount, stmt);
         return stmt;
     }
-    getFileContentPrefixesByPathsStmt(pathCount, maxChars) {
-        const normalizedCount = Math.max(1, Math.trunc(pathCount));
-        const normalizedMaxChars = Math.max(1, Math.trunc(maxChars));
-        const cacheKey = `${normalizedCount}:${normalizedMaxChars}`;
-        const cached = this.getPrefixByPathsStmtCache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        if (this.getPrefixByPathsStmtCache.size >= 128) {
-            this.getPrefixByPathsStmtCache.clear();
-        }
-        const placeholders = Array.from({ length: normalizedCount }, () => "?").join(", ");
-        const stmt = this.db.prepare(`
-      SELECT artifact_id, file_path, substr(content, 1, ?) AS content_prefix, length(content) AS content_length
-      FROM files
-      WHERE artifact_id = ? AND file_path IN (${placeholders})
-    `);
-        this.getPrefixByPathsStmtCache.set(cacheKey, stmt);
-        return stmt;
-    }
 }
 //# sourceMappingURL=files-repo.js.map

package/dist/symbols/symbol-extractor.js

@@ -1,11 +1,12 @@
 const CLASS_DECLARATION = /^(?:\s*@[\w.]+\s+)*(?:\s*(?:public|private|protected|abstract|final|sealed|non-sealed|static)\s+)*\s*(class|interface|enum|record)\s+([A-Za-z_$][\w$]*)/;
 const METHOD_DECLARATION = /^(?:\s*@[\w.]+\s+)*[^{;]*?\b([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?:\{|;)/;
 const FIELD_DECLARATION = /^(?:\s*@[\w.]+\s+)*[^\s][\w<>\[\],.?]+\s+([A-Za-z_$][\w$]*)\s*(?:=|;|,)/;
+const NOISE_TOKENS = new Set(["if", "for", "while", "switch", "catch", "return", "new", "throw"]);
 function normalizeLine(line) {
     return line.replace(/\s+/g, " ").trim();
 }
 function isNoiseToken(token) {
-    return new Set(["if", "for", "while", "switch", "catch", "return", "new", "throw"]).has(token);
+    return NOISE_TOKENS.has(token);
 }
 function lineIndexToLine(lineNo) {
     return lineNo + 1;
@@ -13,6 +14,7 @@ function lineIndexToLine(lineNo) {
 export function extractSymbolsFromSource(filePath, content) {
     const lines = content.split(/\r?\n/);
     const symbols = [];
+    const qualifiedName = filePath.replace(/\.java$/, "").replaceAll("/", ".");
     for (let index = 0; index < lines.length; index += 1) {
         const rawLine = lines[index] ?? "";
         const line = normalizeLine(rawLine);
@@ -27,7 +29,7 @@ export function extractSymbolsFromSource(filePath, content) {
                 symbols.push({
                     symbolKind,
                     symbolName,
-                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    qualifiedName,
                     line: lineIndexToLine(index)
                 });
             }
@@ -40,7 +42,7 @@ export function extractSymbolsFromSource(filePath, content) {
                 symbols.push({
                     symbolKind: "method",
                     symbolName,
-                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    qualifiedName,
                     line: lineIndexToLine(index)
                 });
             }
@@ -53,7 +55,7 @@ export function extractSymbolsFromSource(filePath, content) {
                 symbols.push({
                     symbolKind: "field",
                     symbolName,
-                    qualifiedName: filePath.replace(/\.java$/, "").replaceAll("/", "."),
+                    qualifiedName,
                     line: lineIndexToLine(index)
                 });
             }

package/dist/tool-execution-gate.d.ts

@@ -0,0 +1,15 @@
+type GateOptions = {
+    maxConcurrent: number;
+    maxQueue: number;
+};
+export declare class ToolExecutionGate {
+    private readonly maxConcurrent;
+    private readonly maxQueue;
+    private activeCount;
+    private readonly queue;
+    constructor(options?: Partial<GateOptions>);
+    run<T>(tool: string, task: () => Promise<T>): Promise<T>;
+    private execute;
+    private drain;
+}
+export {};