diff --git a/adapter/src/debugSession.ts b/adapter/src/debugSession.ts
index ea5cdbc..11b6861 100644
--- a/adapter/src/debugSession.ts
+++ b/adapter/src/debugSession.ts
@@ -5,7 +5,7 @@
 
 import {DebugProtocol} from 'vscode-debugprotocol';
 import {ProtocolServer} from './protocol';
-import {Response, Event} from './messages';
+import {ContinueResponse, Response, Event, SetBreakpointsResponse, SetFunctionBreakpointsResponse, StackTraceResponse, ScopesResponse, VariablesResponse, SetVariableResponse, SetExpressionResponse, ThreadsResponse, SourceResponse, EvaluateResponse, StepInTargetsResponse, GotoTargetsResponse, CompletionsResponse, ExceptionInfoResponse, LoadedSourcesResponse, DataBreakpointInfoResponse, SetDataBreakpointsResponse, BreakpointLocationsResponse} from './messages';
 import * as Net from 'net';
 import {URL} from 'url';
 
@@ -466,8 +466,6 @@ export class DebugSession extends ProtocolServer {
 
 	protected dispatchRequest(request: DebugProtocol.Request): void {
 
-		const response = new Response(request);
-
 		try {
 			if (request.command === 'initialize') {
 				var args = <DebugProtocol.InitializeRequestArguments> request.arguments;
@@ -479,132 +477,173 @@ export class DebugSession extends ProtocolServer {
 					this._clientColumnsStartAt1 = args.columnsStartAt1;
 				}
 
+				const response = new Response(request);
 				if (args.pathFormat !== 'path') {
 					this.sendErrorResponse(response, 2018, 'debug adapter only supports native paths', null, ErrorDestination.Telemetry);
 				} else {
-					const initializeResponse = <DebugProtocol.InitializeResponse> response;
+					const initializeResponse: DebugProtocol.InitializeResponse = response;
 					initializeResponse.body = {};
 					this.initializeRequest(initializeResponse, args);
 				}
 
 			} else if (request.command === 'launch') {
-				this.launchRequest(<DebugProtocol.LaunchResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.launchRequest(response, request.arguments, request);
 
 			} else if (request.command === 'attach') {
-				this.attachRequest(<DebugProtocol.AttachResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.attachRequest(response, request.arguments, request);
 
 			} else if (request.command === 'disconnect') {
-				this.disconnectRequest(<DebugProtocol.DisconnectResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.disconnectRequest(response, request.arguments, request);
 
 			} else if (request.command === 'terminate') {
-				this.terminateRequest(<DebugProtocol.TerminateResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.terminateRequest(response, request.arguments, request);
 
 			} else if (request.command === 'restart') {
-				this.restartRequest(<DebugProtocol.RestartResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.restartRequest(response, request.arguments, request);
 
 			} else if (request.command === 'setBreakpoints') {
-				this.setBreakPointsRequest(<DebugProtocol.SetBreakpointsResponse> response, request.arguments, request);
+				const response = new SetBreakpointsResponse(request);
+				this.setBreakPointsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'setFunctionBreakpoints') {
-				this.setFunctionBreakPointsRequest(<DebugProtocol.SetFunctionBreakpointsResponse> response, request.arguments, request);
+				const response = new SetFunctionBreakpointsResponse(request);
+				this.setFunctionBreakPointsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'setExceptionBreakpoints') {
-				this.setExceptionBreakPointsRequest(<DebugProtocol.SetExceptionBreakpointsResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.setExceptionBreakPointsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'configurationDone') {
-				this.configurationDoneRequest(<DebugProtocol.ConfigurationDoneResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.configurationDoneRequest(response, request.arguments, request);
 
 			} else if (request.command === 'continue') {
-				this.continueRequest(<DebugProtocol.ContinueResponse> response, request.arguments, request);
+				const response = new ContinueResponse(request);
+				this.continueRequest(response, request.arguments, request);
 
 			} else if (request.command === 'next') {
-				this.nextRequest(<DebugProtocol.NextResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.nextRequest(response, request.arguments, request);
 
 			} else if (request.command === 'stepIn') {
-				this.stepInRequest(<DebugProtocol.StepInResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.stepInRequest(response, request.arguments, request);
 
 			} else if (request.command === 'stepOut') {
-				this.stepOutRequest(<DebugProtocol.StepOutResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.stepOutRequest(response, request.arguments, request);
 
 			} else if (request.command === 'stepBack') {
-				this.stepBackRequest(<DebugProtocol.StepBackResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.stepBackRequest(response, request.arguments, request);
 
 			} else if (request.command === 'reverseContinue') {
-				this.reverseContinueRequest(<DebugProtocol.ReverseContinueResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.reverseContinueRequest(response, request.arguments, request);
 
 			} else if (request.command === 'restartFrame') {
-				this.restartFrameRequest(<DebugProtocol.RestartFrameResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.restartFrameRequest(response, request.arguments, request);
 
 			} else if (request.command === 'goto') {
-				this.gotoRequest(<DebugProtocol.GotoResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.gotoRequest(response, request.arguments, request);
 
 			} else if (request.command === 'pause') {
-				this.pauseRequest(<DebugProtocol.PauseResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.pauseRequest(response, request.arguments, request);
 
 			} else if (request.command === 'stackTrace') {
-				this.stackTraceRequest(<DebugProtocol.StackTraceResponse> response, request.arguments, request);
+				const response = new StackTraceResponse(request);
+				this.stackTraceRequest(response, request.arguments, request);
 
 			} else if (request.command === 'scopes') {
-				this.scopesRequest(<DebugProtocol.ScopesResponse> response, request.arguments, request);
+				const response = new ScopesResponse(request);
+				this.scopesRequest(response, request.arguments, request);
 
 			} else if (request.command === 'variables') {
-				this.variablesRequest(<DebugProtocol.VariablesResponse> response, request.arguments, request);
+				const response = new VariablesResponse(request);
+				this.variablesRequest(response, request.arguments, request);
 
 			} else if (request.command === 'setVariable') {
-				this.setVariableRequest(<DebugProtocol.SetVariableResponse> response, request.arguments, request);
+				const response = new SetVariableResponse(request);
+				this.setVariableRequest(response, request.arguments, request);
 
 			} else if (request.command === 'setExpression') {
-				this.setExpressionRequest(<DebugProtocol.SetExpressionResponse> response, request.arguments, request);
+				const response = new SetExpressionResponse(request);
+				this.setExpressionRequest(response, request.arguments, request);
 
 			} else if (request.command === 'source') {
-				this.sourceRequest(<DebugProtocol.SourceResponse> response, request.arguments, request);
+				const response = new SourceResponse(request);
+				this.sourceRequest(response, request.arguments, request);
 
 			} else if (request.command === 'threads') {
-				this.threadsRequest(<DebugProtocol.ThreadsResponse> response, request);
+				const response = new ThreadsResponse(request);
+				this.threadsRequest(response, request);
 
 			} else if (request.command === 'terminateThreads') {
-				this.terminateThreadsRequest(<DebugProtocol.TerminateThreadsResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.terminateThreadsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'evaluate') {
-				this.evaluateRequest(<DebugProtocol.EvaluateResponse> response, request.arguments, request);
+				const response = new EvaluateResponse(request);
+				this.evaluateRequest(response, request.arguments, request);
 
 			} else if (request.command === 'stepInTargets') {
-				this.stepInTargetsRequest(<DebugProtocol.StepInTargetsResponse> response, request.arguments, request);
+				const response = new StepInTargetsResponse(request);
+				this.stepInTargetsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'gotoTargets') {
-				this.gotoTargetsRequest(<DebugProtocol.GotoTargetsResponse> response, request.arguments, request);
+				const response = new GotoTargetsResponse(request);
+				this.gotoTargetsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'completions') {
-				this.completionsRequest(<DebugProtocol.CompletionsResponse> response, request.arguments, request);
+				const response = new CompletionsResponse(request);
+				this.completionsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'exceptionInfo') {
-				this.exceptionInfoRequest(<DebugProtocol.ExceptionInfoResponse> response, request.arguments, request);
+				const response = new ExceptionInfoResponse(request);
+				this.exceptionInfoRequest(response, request.arguments, request);
 
 			} else if (request.command === 'loadedSources') {
-				this.loadedSourcesRequest(<DebugProtocol.LoadedSourcesResponse> response, request.arguments, request);
+				const response = new LoadedSourcesResponse(request);
+				this.loadedSourcesRequest(response, request.arguments, request);
 
 			} else if (request.command === 'dataBreakpointInfo') {
-				this.dataBreakpointInfoRequest(<DebugProtocol.DataBreakpointInfoResponse> response, request.arguments, request);
+				const response = new DataBreakpointInfoResponse(request);
+				this.dataBreakpointInfoRequest(response, request.arguments, request);
 
 			} else if (request.command === 'setDataBreakpoints') {
-				this.setDataBreakpointsRequest(<DebugProtocol.SetDataBreakpointsResponse> response, request.arguments, request);
+				const response = new SetDataBreakpointsResponse(request);
+				this.setDataBreakpointsRequest(response, request.arguments, request);
 
 			} else if (request.command === 'readMemory') {
-				this.readMemoryRequest(<DebugProtocol.ReadMemoryResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.readMemoryRequest(response, request.arguments, request);
 
 			} else if (request.command === 'disassemble') {
-				this.disassembleRequest(<DebugProtocol.DisassembleResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.disassembleRequest(response, request.arguments, request);
 
 			} else if (request.command === 'cancel') {
-				this.cancelRequest(<DebugProtocol.CancelResponse> response, request.arguments, request);
+				const response = new Response(request);
+				this.cancelRequest(response, request.arguments, request);
 
 			} else if (request.command === 'breakpointLocations') {
-				this.breakpointLocationsRequest(<DebugProtocol.BreakpointLocationsResponse> response, request.arguments, request);
+				const response = new BreakpointLocationsResponse(request);
+				this.breakpointLocationsRequest(response, request.arguments, request);
 
 			} else {
-				this.customRequest(request.command, <DebugProtocol.Response> response, request.arguments, request);
+				const response = new Response(request);
+				this.customRequest(request.command, response, request.arguments, request);
 			}
 		} catch (e) {
+			const response = new Response(request);
 			this.sendErrorResponse(response, 1104, '{_stack}', { _exception: e.message, _stack: e.stack }, ErrorDestination.Telemetry);
 		}
 	}
diff --git a/adapter/src/messages.ts b/adapter/src/messages.ts
index 1b32644..0a6061d 100644
--- a/adapter/src/messages.ts
+++ b/adapter/src/messages.ts
@@ -34,6 +34,143 @@ export class Response extends Message implements DebugProtocol.Response {
 	}
 }
 
+export class SetBreakpointsResponse extends Response implements DebugProtocol.SetBreakpointsResponse {
+	body = {
+		breakpoints: []
+	};
+}
+
+export class SetFunctionBreakpointsResponse extends Response implements DebugProtocol.SetFunctionBreakpointsResponse {
+	body = {
+		breakpoints: []
+	};
+}
+
+export class ContinueResponse extends Response implements DebugProtocol.ContinueResponse {
+	body = {
+		allThreadsContinued: undefined
+	};
+}
+
+export class ScopesResponse extends Response implements DebugProtocol.ScopesResponse {
+	body = {
+		scopes: []
+	};
+}
+
+export class StackTraceResponse extends Response implements DebugProtocol.StackTraceResponse {
+	body = {
+		stackFrames: [],
+		totalFrames: undefined
+	};
+}
+
+export class VariablesResponse extends Response implements DebugProtocol.VariablesResponse {
+	body = {
+		variables: []
+	};
+}
+
+export class SetVariableResponse extends Response implements DebugProtocol.SetVariableResponse {
+	body: {
+		value: "";
+		type: undefined,
+		variablesReference: undefined,
+		namedVariables: undefined,
+		indexedVariables: undefined
+	};
+}
+
+export class SetExpressionResponse extends Response implements DebugProtocol.SetExpressionResponse {
+	body: {
+		value: "";
+		type: undefined,
+		presentationHint: undefined,
+		variablesReference: undefined,
+		namedVariables: undefined,
+		indexedVariables: undefined
+	};
+}
+
+export class SourceResponse extends Response implements DebugProtocol.SourceResponse {
+	body: {
+		content: "";
+		mimeType: undefined;
+	};
+}
+
+export class ThreadsResponse extends Response implements DebugProtocol.ThreadsResponse {
+	body: {
+		threads: []
+	};
+}
+
+export class EvaluateResponse extends Response implements DebugProtocol.EvaluateResponse {
+	body: {
+		result: "",
+		type: undefined,
+		presentationHint: undefined,
+		variablesReference: 0,
+		namedVariables: undefined,
+		indexedVariables: undefined,
+		memoryReference: undefined
+	};
+}
+
+export class StepInTargetsResponse extends Response implements DebugProtocol.StepInTargetsResponse {
+	body: {
+		targets: []
+	};
+}
+
+export class GotoTargetsResponse extends Response implements DebugProtocol.GotoTargetsResponse {
+	body: {
+		targets: []
+	};
+}
+
+export class CompletionsResponse extends Response implements DebugProtocol.CompletionsResponse {
+	body: {
+		targets: []
+	};
+}
+
+export class ExceptionInfoResponse extends Response implements DebugProtocol.ExceptionInfoResponse {
+	body: {
+		exceptionId: "",
+		description: undefined,
+		breakMode: 'never',
+		details: undefined
+	};
+}
+
+export class LoadedSourcesResponse extends Response implements DebugProtocol.LoadedSourcesResponse {
+	body: {
+		sources: []
+	};
+}
+
+export class DataBreakpointInfoResponse extends Response implements DebugProtocol.DataBreakpointInfoResponse {
+	body: {
+		dataId: null,
+		description: "",
+		accessTypes: undefined,
+		canPersist: undefined
+	};
+}
+
+export class BreakpointLocationsResponse extends Response implements DebugProtocol.BreakpointLocationsResponse {
+	body: {
+		breakpoints: []
+	};
+}
+
+export class SetDataBreakpointsResponse extends Response implements DebugProtocol.SetDataBreakpointsResponse {
+	body: {
+		breakpoints: []
+	};
+}
+
 export class Event extends Message implements DebugProtocol.Event {
 	event: string;