@bloopai/debugger-mcp/dist/tools/index.d.ts

An MCP server that provides interactive debugging capabilities to AI coding agents

import { McpAsyncEvent, McpAsyncEventType } from '../types/mcp_protocol_extensions';
import { StartDebugSessionArgs, SetBreakpointArgs, EvaluateExpressionArgs, GetVariablesArgs, GetCallStackArgs, ContinueArgs, StepOverArgs, TerminateSessionArgs, ListSessionsArgs, ListAdapterConfigsArgs, GetPendingAsyncEventsArgs, GetSessionDetailsArgs, StepInArgs, StepOutArgs } from '../types/toolArgs';
import { HandleGetSessionDetailsResult, HandleStepInResult, HandleStepOutResult, HandleStepOverResult, HandleTerminateSessionResult, HandleContinueResult } from '../types/toolResults';
export interface AdapterConfigDetail {
    command: string;
    args: string[];
    env: Record<string, string>;
    cwd: string;
}
export interface SessionProvider {
    getSessionManager(): SessionManager;
    getDebugSession(sessionId: string): DebugSession | undefined;
    getDAPSessionHandler(sessionId: string): DAPSessionHandler | undefined;
    createDebugSession(dapHandler: DAPSessionHandler, targetType: string, targetPath: string, logger: LoggerInterface): DebugSession;
    storeDebugSession(mcpSessionId: string, session: DebugSession, startTime: Date, targetType: string, targetPath: string): void;
    removeDebugSession(sessionId: string): void;
    getLogger(): LoggerInterface;
    getAllSessionInfo(): ModelSessionInfo[];
    drainAsyncEventQueue(): McpAsyncEvent[];
    findAndConsumeSessionEvent(sessionId: string, eventType: McpAsyncEventType, removeIfFound?: boolean): McpAsyncEvent | undefined;
    getEventsForSession(sessionId: string): McpAsyncEvent[];
    queueAsyncEvent(sessionId: string, eventType: McpAsyncEventType, data: unknown): void;
}
import { SessionManager, DebugSession, DAPSessionHandler, LoggerInterface, AdapterConfig } from '@bloopai/ergonomic-debugger-client';
import { SessionInfo as ModelSessionInfo, BreakpointResult as ModelBreakpointResult, EvaluationResult as ModelEvaluationResult, ModelStackFrame, Variable as ModelVariable } from '../types';
import { DebugProtocol } from '@vscode/debugprotocol';
export declare const DAP_DEFAULT_EVENT_TIMEOUT_MS = 15000;
export declare function handleGetPendingAsyncEvents(sessionProvider: SessionProvider, _args: GetPendingAsyncEventsArgs): Promise<{
    events: McpAsyncEvent[];
}>;
export declare class LaunchArgumentsBuilder {
    private launchArgs;
    constructor(mcpArgs: StartDebugSessionArgs);
    withProgram(program: string): this;
    withRequestType(request: 'launch' | 'attach'): this;
    withDebugType(type: string): this;
    withName(name: string): this;
    withLaunchArguments(args: string[]): this;
    withStopOnEntry(stop: boolean): this;
    withCwd(cwd: string): this;
    withEnv(env: Record<string, string | null | undefined>): this;
    withConsoleType(consoleType: 'internalConsole' | 'integratedTerminal' | 'externalTerminal'): this;
    withNoDebug(noDebug: boolean): this;
    withAdapterOption(key: string, value: unknown): this;
    build(): DebugProtocol.LaunchRequestArguments;
}
/**
 * Tool handler for starting a debug session
 */
export declare function handleStartDebugSession(sessionProvider: SessionProvider, args: StartDebugSessionArgs): Promise<{
    sessionId: string;
    sessionInfo: ModelSessionInfo;
    stoppedEvent?: DebugProtocol.StoppedEvent['body'];
}>;
/**
 * Tool handler for setting a breakpoint
 */
export declare function handleSetBreakpoint(sessionProvider: SessionProvider, args: SetBreakpointArgs): Promise<ModelBreakpointResult>;
/**
 * Tool handler for evaluating an expression
 */
export declare function handleEvaluateExpression(sessionProvider: SessionProvider, args: EvaluateExpressionArgs): Promise<ModelEvaluationResult>;
/**
 * Tool handler for getting variables
 */
export declare function handleGetVariables(sessionProvider: SessionProvider, args: GetVariablesArgs): Promise<ModelVariable[]>;
/**
 * Tool handler for getting the call stack
 */
export declare function handleGetCallStack(sessionProvider: SessionProvider, args: GetCallStackArgs): Promise<ModelStackFrame[]>;
/**
 * Tool handler for continuing execution
 */
export declare function handleContinue(sessionProvider: SessionProvider, args: ContinueArgs): Promise<HandleContinueResult>;
/**
 * Tool handler for stepping over
 */
export declare function handleStepOver(sessionProvider: SessionProvider, args: StepOverArgs): Promise<HandleStepOverResult>;
/**
 * Tool handler for terminating a debug session
 */
export declare function handleTerminateSession(sessionProvider: SessionProvider, args: TerminateSessionArgs): Promise<HandleTerminateSessionResult>;
/**
 * Tool handler for listing all active debug sessions
 */
export declare function handleListSessions(sessionProvider: SessionProvider, _args: ListSessionsArgs): Promise<{
    sessions: ModelSessionInfo[];
}>;
/**
 * Tool handler for listing all registered debug adapter configurations.
 */
/**
 * Tool handler for getting detailed information about a specific debug session
 */
export declare function handleGetSessionDetails(sessionProvider: SessionProvider, args: GetSessionDetailsArgs): Promise<HandleGetSessionDetailsResult>;
export declare function handleStepIn(sessionProvider: SessionProvider, args: StepInArgs): Promise<HandleStepInResult>;
export declare function handleStepOut(sessionProvider: SessionProvider, args: StepOutArgs): Promise<HandleStepOutResult>;
export declare function handleListAdapters(sessionProvider: SessionProvider, _args: ListAdapterConfigsArgs): Promise<{
    adapters: {
        type: string;
        config: Partial<AdapterConfig>;
    }[];
}>;