dap-tools.schemas.ts•18.9 kB
import { z } from 'zod';
// Debug Adapter Protocol (DAP) Tool Schemas
// Based on VS Code Debug Protocol specification
export const DapStartSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('launch'),
arguments: z.object({
__type__: z.literal('LaunchRequestArguments'),
noDebug: z.boolean().optional(),
console: z.enum(['internalConsole', 'integratedTerminal', 'externalTerminal']).optional(),
internalConsoleOptions: z
.enum(['neverOpen', 'openOnSessionStart', 'openOnDebugBreak'])
.optional(),
cwd: z.string().optional(),
env: z.record(z.string()).optional(),
args: z.array(z.string()).optional(),
stopOnEntry: z.boolean().optional(),
debugServer: z.number().optional(),
// Language-specific arguments
program: z.string().optional(),
runtimeExecutable: z.string().optional(),
runtimeArgs: z.array(z.string()).optional(),
sourceMaps: z.boolean().optional(),
outFiles: z.array(z.string()).optional(),
resolveSourceMapLocations: z.array(z.string()).optional(),
skipFiles: z.array(z.string()).optional(),
preLaunchTask: z.string().optional(),
postDebugTask: z.string().optional(),
// Node.js specific
runtimeVersion: z.string().optional(),
module: z.string().optional(),
// Python specific
python: z.string().optional(),
pythonPath: z.string().optional(),
// C# specific
targetArchitecture: z.enum(['x86', 'x64']).optional(),
launchSettingsFilePath: z.string().optional(),
// Dart specific
dartPath: z.string().optional(),
flutterPath: z.string().optional(),
deviceId: z.string().optional(),
// Attach specific
attach: z.boolean().optional(),
processId: z.number().optional(),
// Transport specific
listen: z.string().optional(),
server: z.string().optional(),
}),
});
export const DapAttachSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('attach'),
arguments: z.object({
__type__: z.literal('AttachRequestArguments'),
noDebug: z.boolean().optional(),
debugServer: z.number().optional(),
processId: z.number().optional(),
processName: z.string().optional(),
// Language-specific arguments
cwd: z.string().optional(),
sourceMaps: z.boolean().optional(),
skipFiles: z.array(z.string()).optional(),
runtimeExecutable: z.string().optional(),
runtimeArgs: z.array(z.string()).optional(),
// Node.js specific
address: z.string().optional(),
port: z.number().optional(),
// Python specific
pythonPath: z.string().optional(),
// C# specific
targetArchitecture: z.enum(['x86', 'x64']).optional(),
// Dart specific
dartPath: z.string().optional(),
deviceId: z.string().optional(),
// Transport specific
listen: z.string().optional(),
server: z.string().optional(),
}),
});
export const DapSetBreakpointsSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('setBreakpoints'),
arguments: z.object({
__type__: z.literal('SetBreakpointsArguments'),
source: z
.object({
path: z.string().optional(),
name: z.string().optional(),
sourceReference: z.number().optional(),
adapterData: z.any().optional(),
})
.optional(),
breakpoints: z
.array(
z.object({
id: z.number().optional(),
line: z.number(),
column: z.number().optional().default(0),
endLine: z.number().optional(),
endColumn: z.number().optional(),
condition: z.string().optional(),
hitCondition: z.string().optional(),
logMessage: z.string().optional(),
verified: z.boolean().optional(),
message: z.string().optional(),
src: z.string().optional(),
encodedMd5: z.string().optional(),
adapterData: z.any().optional(),
})
)
.optional(),
sourceModified: z.boolean().optional(),
lines: z.array(z.number()).optional(),
// Deprecated fields
breakpoint: z
.object({
id: z.number().optional(),
line: z.number(),
column: z.number().optional().default(0),
condition: z.string().optional(),
hitCondition: z.string().optional(),
logMessage: z.string().optional(),
verified: z.boolean().optional(),
message: z.string().optional(),
})
.optional(),
}),
});
export const DapContinueSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('continue'),
arguments: z.object({
__type__: z.literal('ContinueArguments'),
threadId: z.number(),
}),
});
export const DapPauseSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('pause'),
arguments: z.object({
__type__: z.literal('PauseArguments'),
threadId: z.number(),
}),
});
export const DapStepInSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('stepIn'),
arguments: z.object({
__type__: z.literal('StepInArguments'),
threadId: z.number(),
targetId: z.string().optional(),
waitForAdditionalInformation: z.boolean().optional(),
}),
});
export const DapStepOverSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('stepOver'),
arguments: z.object({
__type__: z.literal('StepOverArguments'),
threadId: z.number(),
waitForAdditionalInformation: z.boolean().optional(),
}),
});
export const DapStepOutSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('stepOut'),
arguments: z.object({
__type__: z.literal('StepOutArguments'),
threadId: z.number(),
waitForAdditionalInformation: z.boolean().optional(),
}),
});
export const DapThreadsSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('threads'),
arguments: z.object({
__type__: z.literal('ThreadsArguments'),
}),
});
export const DapStackTraceSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('stackTrace'),
arguments: z.object({
__type__: z.literal('StackTraceArguments'),
threadId: z.number(),
startFrame: z.number().optional(),
levels: z.number().optional(),
}),
});
export const DapScopesSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('scopes'),
arguments: z.object({
__type__: z.literal('ScopesArguments'),
frameId: z.number(),
}),
});
export const DapVariablesSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('variables'),
arguments: z.object({
__type__: z.literal('VariablesArguments'),
variablesReference: z.number(),
filter: z.enum(['indexed', 'named']).optional(),
start: z.number().optional(),
count: z.number().optional(),
}),
});
export const DapEvaluateSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('evaluate'),
arguments: z.object({
__type__: z.literal('EvaluateArguments'),
expression: z.string(),
frameId: z.number().optional(),
context: z.enum(['hover', 'repl', 'watch', 'variables', 'clipboard']).optional(),
}),
});
export const DapEventsPollSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('events.poll'),
arguments: z.object({
__type__: z.literal('EventsPollArguments'),
since: z.number().optional(),
limit: z.number().optional(),
cursor: z.string().optional(),
session_id: z.string().optional(),
}),
});
export const DapTerminateSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('terminate'),
arguments: z.object({
__type__: z.literal('TerminateArguments'),
restart: z.boolean().optional(),
}),
});
export const DapDisconnectSchema = z.object({
type: z.literal('request'),
seq: z.number(),
command: z.literal('disconnect'),
arguments: z.object({
__type__: z.literal('DisconnectArguments'),
restart: z.boolean().optional(),
terminateDebuggee: z.boolean().optional(),
suspendDebuggee: z.boolean().optional(),
}),
});
// Response schemas
export const DapStartResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
command: z.literal('launch'),
request_seq: z.number(),
success: z.boolean(),
message: z.string().optional(),
body: z
.object({
sessionId: z.string().optional(),
__type__: z.literal('LaunchResponse').optional(),
})
.optional(),
});
export const DapErrorResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
command: z.string(),
request_seq: z.number(),
success: z.literal(false),
message: z.string(),
body: z
.object({
error: z.string(),
format: z.string(),
showUser: z.boolean(),
})
.optional(),
});
// Event schemas
export const DapInitializedEventSchema = z.object({
type: z.literal('event'),
seq: z.number(),
event: z.literal('initialized'),
body: z.object({
__type__: z.literal('InitializedEvent'),
}),
});
export const DapStoppedEventSchema = z.object({
type: z.literal('event'),
seq: z.number(),
event: z.literal('stopped'),
body: z.object({
__type__: z.literal('StoppedEvent'),
reason: z.string(),
description: z.string().optional(),
threadId: z.number().optional(),
text: z.string().optional(),
preserveFocusHint: z.boolean().optional(),
allThreadsStopped: z.boolean().optional(),
}),
});
export const DapContinuedEventSchema = z.object({
type: z.literal('event'),
seq: z.number(),
event: z.literal('continued'),
body: z.object({
__type__: z.literal('ContinuedEvent'),
threadId: z.number(),
allThreadsContinued: z.boolean().optional(),
}),
});
export const DapThreadEventSchema = z.object({
type: z.literal('event'),
seq: z.number(),
event: z.literal('thread'),
body: z.object({
__type__: z.literal('ThreadEvent'),
reason: z.enum(['started', 'exited']),
threadId: z.number(),
}),
});
export const DapOutputEventSchema = z.object({
type: z.literal('event'),
seq: z.number(),
event: z.literal('output'),
body: z.object({
__type__: z.literal('OutputEvent'),
category: z.enum(['console', 'stdout', 'stderr', 'telemetry']).optional(),
output: z.string(),
data: z.any().optional(),
variablesReference: z.number().optional(),
source: z
.object({
path: z.string().optional(),
name: z.string().optional(),
sourceReference: z.number().optional(),
adapterData: z.any().optional(),
})
.optional(),
line: z.number().optional(),
column: z.number().optional(),
}),
});
export const DapBreakpointEventSchema = z.object({
type: z.literal('event'),
seq: z.number(),
event: z.literal('breakpoint'),
body: z.object({
__type__: z.literal('BreakpointEvent'),
reason: z.enum(['changed', 'new', 'removed']),
breakpoint: z.object({
id: z.number(),
verified: z.boolean().optional(),
message: z.string().optional(),
source: z
.object({
path: z.string().optional(),
name: z.string().optional(),
sourceReference: z.number().optional(),
adapterData: z.any().optional(),
})
.optional(),
line: z.number().optional(),
column: z.number().optional(),
condition: z.string().optional(),
hitCondition: z.string().optional(),
logMessage: z.string().optional(),
informed: z.boolean().optional(),
}),
}),
});
export const DapStepInResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
request_seq: z.number(),
success: z.boolean(),
command: z.literal('stepIn'),
message: z.string().optional(),
});
export const DapStepOverResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
request_seq: z.number(),
success: z.boolean(),
command: z.literal('stepOver'),
message: z.string().optional(),
});
export const DapStepOutResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
request_seq: z.number(),
success: z.boolean(),
command: z.literal('stepOut'),
message: z.string().optional(),
});
export const DapThreadsResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
request_seq: z.number(),
success: z.boolean(),
command: z.literal('threads'),
message: z.string().optional(),
body: z
.object({
threads: z.array(
z.object({
id: z.number(),
name: z.string(),
})
),
})
.optional(),
});
export const DapVariablesResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
request_seq: z.number(),
success: z.boolean(),
command: z.literal('variables'),
message: z.string().optional(),
body: z
.object({
variables: z.array(
z.object({
name: z.string(),
value: z.string(),
type: z.string().optional(),
presentationHint: z
.object({
kind: z
.enum([
'property',
'method',
'class',
'data',
'event',
'baseClass',
'innerClass',
'interface',
'mostDerivedClass',
'virtual',
'dataBreakpoint',
])
.optional(),
attributes: z
.array(
z.enum([
'static',
'constant',
'readOnly',
'rawString',
'hasObjectId',
'canHaveObjectId',
'hasSideEffects',
'hasDataBreakpoint',
])
)
.optional(),
visibility: z
.enum([
'public',
'private',
'protected',
'internal',
'protectedInternal',
'privateProtected',
])
.optional(),
})
.optional(),
evaluateName: z.string().optional(),
variablesReference: z.number(),
namedVariables: z.number().optional(),
indexedVariables: z.number().optional(),
memoryReference: z.string().optional(),
})
),
})
.optional(),
});
export const VariableSchema = z.object({
name: z.string(),
value: z.string(),
type: z.string().optional(),
presentationHint: z
.object({
kind: z
.enum([
'property',
'method',
'class',
'data',
'event',
'baseClass',
'innerClass',
'interface',
'mostDerivedClass',
'virtual',
'dataBreakpoint',
])
.optional(),
attributes: z
.array(
z.enum([
'static',
'constant',
'readOnly',
'rawString',
'hasObjectId',
'canHaveObjectId',
'hasSideEffects',
'hasDataBreakpoint',
])
)
.optional(),
visibility: z
.enum([
'public',
'private',
'protected',
'internal',
'protectedInternal',
'privateProtected',
])
.optional(),
})
.optional(),
evaluateName: z.string().optional(),
variablesReference: z.number(),
namedVariables: z.number().optional(),
indexedVariables: z.number().optional(),
memoryReference: z.string().optional(),
});
export const DapSetBreakpointsResponseSchema = z.object({
type: z.literal('response'),
seq: z.number(),
request_seq: z.number(),
success: z.boolean(),
command: z.literal('setBreakpoints'),
message: z.string().optional(),
body: z
.object({
breakpoints: z
.array(
z.object({
id: z.number().optional(),
verified: z.boolean(),
message: z.string().optional(),
source: z
.object({
path: z.string(),
})
.optional(),
line: z.number(),
column: z.number().optional(),
})
)
.optional(),
})
.optional(),
});
// MCP Tool Schema
export const MCPToolSchema = z.object({
name: z.string(),
arguments: z.any(),
});
// Event Schema
export const DebugEventSchema = z.object({
event_id: z.string(),
session_id: z.string(),
timestamp: z.number(),
event_type: z.enum([
'initialized',
'stopped',
'continued',
'thread',
'output',
'breakpoint',
'terminated',
'exited',
'module',
'unknown',
]),
data: z.any(),
cursor: z.string().optional(),
});
export type DapStartRequest = z.infer<typeof DapStartSchema>;
export type DapAttachRequest = z.infer<typeof DapAttachSchema>;
export type DapSetBreakpointsRequest = z.infer<typeof DapSetBreakpointsSchema>;
export type DapContinueRequest = z.infer<typeof DapContinueSchema>;
export type DapPauseRequest = z.infer<typeof DapPauseSchema>;
export type DapStepInRequest = z.infer<typeof DapStepInSchema>;
export type DapStepOverRequest = z.infer<typeof DapStepOverSchema>;
export type DapStepOutRequest = z.infer<typeof DapStepOutSchema>;
export type DapThreadsRequest = z.infer<typeof DapThreadsSchema>;
export type DapStackTraceRequest = z.infer<typeof DapStackTraceSchema>;
export type DapScopesRequest = z.infer<typeof DapScopesSchema>;
export type DapVariablesRequest = z.infer<typeof DapVariablesSchema>;
export type DapEvaluateRequest = z.infer<typeof DapEvaluateSchema>;
export type DapEventsPollRequest = z.infer<typeof DapEventsPollSchema>;
export type DapTerminateRequest = z.infer<typeof DapTerminateSchema>;
export type DapDisconnectRequest = z.infer<typeof DapDisconnectSchema>;
export type DapStartResponse = z.infer<typeof DapStartResponseSchema>;
export type DapErrorResponse = z.infer<typeof DapErrorResponseSchema>;
export type DapStepInResponse = z.infer<typeof DapStepInResponseSchema>;
export type DapStepOverResponse = z.infer<typeof DapStepOverResponseSchema>;
export type DapStepOutResponse = z.infer<typeof DapStepOutResponseSchema>;
export type DapThreadsResponse = z.infer<typeof DapThreadsResponseSchema>;
export type DapVariablesResponse = z.infer<typeof DapVariablesResponseSchema>;
export type Variable = z.infer<typeof VariableSchema>;
export type DapSetBreakpointsResponse = z.infer<typeof DapSetBreakpointsResponseSchema>;
export type DebugEvent = z.infer<typeof DebugEventSchema>;