@mastra/server 1.79.0-alpha.10 → 1.79.0-alpha.12

package/dist/server/handlers/responses.cjs

@@ -1,633 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("../../rolldown-runtime-Bd6kNlEP.cjs");
-const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
-const require_route_builder = require("../../route-builder-BNZs643f.cjs");
-const require_server_handlers_error = require("./error.cjs");
-const require_utils = require("../../utils-Du-EpvDs.cjs");
-const require_server_handlers_agents = require("./agents.cjs");
-const require_responses = require("../../responses-CKNdSRkS.cjs");
-const require_server_handlers_responses_adapter = require("./responses.adapter.cjs");
-const require_server_handlers_responses_storage = require("./responses.storage.cjs");
-//#region src/server/handlers/responses.ts
-var responses_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
-	CREATE_RESPONSE_ROUTE: () => CREATE_RESPONSE_ROUTE,
-	DELETE_RESPONSE_ROUTE: () => DELETE_RESPONSE_ROUTE,
-	GET_RESPONSE_ROUTE: () => GET_RESPONSE_ROUTE
-});
-const JSON_OBJECT_RESPONSE_SCHEMA = {
-	type: "object",
-	additionalProperties: true
-};
-function jsonResponse(data, status = 200) {
-	return new Response(JSON.stringify(data), {
-		status,
-		headers: { "Content-Type": "application/json" }
-	});
-}
-function createStructuredOutput(text) {
-	if (!text) return;
-	switch (text.format.type) {
-		case "json_object": return {
-			schema: JSON_OBJECT_RESPONSE_SCHEMA,
-			jsonPromptInjection: true
-		};
-		case "json_schema": return { schema: text.format.schema };
-		default: return;
-	}
-}
-function getStreamedMessageOutputItem(response, responseId) {
-	return response.output.find((item) => item.type === "message" && item.id === responseId) ?? null;
-}
-/**
-* Resolves the memory thread that should back the current response request.
-*
-* If `previous_response_id` is present, the request continues on that stored thread.
-* Otherwise, the route only creates or reuses a thread when the caller asked to store
-* the response and the resolved agent actually has memory configured.
-*/
-async function resolveThreadExecutionContext({ agent, store, conversationId, previousResponseTurnRecord, requestContext }) {
-	if (conversationId && previousResponseTurnRecord && previousResponseTurnRecord.thread.id !== conversationId) throw new require_http_exception.HTTPException(400, { message: "conversation_id and previous_response_id must reference the same conversation thread when both are provided" });
-	if (previousResponseTurnRecord) return {
-		threadId: previousResponseTurnRecord.thread.id,
-		resourceId: previousResponseTurnRecord.thread.resourceId
-	};
-	const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, void 0);
-	const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, void 0);
-	if (!store && !conversationId && !effectiveThreadId) return null;
-	const memory = await agent.getMemory({ requestContext });
-	if (!memory) {
-		if (conversationId) throw new require_http_exception.HTTPException(400, { message: "conversation_id requires the target agent to have memory configured" });
-		return null;
-	}
-	if (conversationId) {
-		const existingThread = await memory.getThreadById({ threadId: conversationId });
-		if (!existingThread) throw new require_http_exception.HTTPException(404, { message: `Conversation ${conversationId} was not found` });
-		await require_utils.enforceThreadAccess({
-			mastra: agent.getMastraInstance(),
-			requestContext,
-			threadId: conversationId,
-			thread: existingThread,
-			effectiveResourceId
-		});
-		return {
-			threadId: existingThread.id,
-			resourceId: effectiveResourceId ?? existingThread.resourceId
-		};
-	}
-	if (!effectiveThreadId) {
-		if (!store) return null;
-		const threadId = globalThis.crypto.randomUUID();
-		const createdThread = await memory.createThread({
-			threadId,
-			resourceId: effectiveResourceId ?? threadId
-		});
-		return {
-			threadId: createdThread.id,
-			resourceId: createdThread.resourceId
-		};
-	}
-	const threadId = effectiveThreadId;
-	const existingThread = await memory.getThreadById({ threadId });
-	if (existingThread) {
-		await require_utils.enforceThreadAccess({
-			mastra: agent.getMastraInstance(),
-			requestContext,
-			threadId,
-			thread: existingThread,
-			effectiveResourceId
-		});
-		return {
-			threadId: existingThread.id,
-			resourceId: effectiveResourceId ?? existingThread.resourceId
-		};
-	}
-	if (!store) return null;
-	const resourceId = effectiveResourceId ?? threadId;
-	const createdThread = await memory.createThread({
-		threadId,
-		resourceId
-	});
-	return {
-		threadId: createdThread.id,
-		resourceId: createdThread.resourceId
-	};
-}
-function createExecutionMemory(threadContext) {
-	if (!threadContext) return;
-	return { memory: {
-		thread: threadContext.threadId,
-		resource: threadContext.resourceId
-	} };
-}
-/**
-* Resolves the registered Mastra agent that owns the response request.
-*/
-async function resolveResponseAgent({ mastra, agentId }) {
-	if (!agentId) throw new require_http_exception.HTTPException(400, { message: "Responses requests require an agent_id" });
-	if (!mastra) throw new require_http_exception.HTTPException(500, { message: "Mastra instance is required for agent-backed responses" });
-	return require_server_handlers_agents.getAgentFromSystem({
-		mastra,
-		agentId
-	});
-}
-async function resolveAgentMemoryStore({ agent, requestContext, errorMessage }) {
-	const agentMemoryStore = await require_server_handlers_responses_storage.getAgentMemoryStore({
-		agent,
-		requestContext
-	});
-	if (!agentMemoryStore) throw new require_http_exception.HTTPException(400, { message: errorMessage });
-	return agentMemoryStore;
-}
-/**
-* Executes a non-streaming Responses API request through the resolved Mastra agent.
-*/
-async function executeGenerate({ agent, resolvedModel, modelOverride, instructions, text, providerOptions, input, requestContext, abortSignal, threadContext }) {
-	const executionMemory = createExecutionMemory(threadContext);
-	const structuredOutput = createStructuredOutput(text);
-	const modelOption = modelOverride ? { model: modelOverride } : {};
-	const commonOptions = {
-		instructions,
-		requestContext,
-		abortSignal,
-		...modelOption,
-		structuredOutput,
-		providerOptions,
-		...executionMemory ?? {}
-	};
-	if (resolvedModel.specificationVersion === "v1") {
-		if (threadContext) return await agent.generateLegacy(input, {
-			instructions,
-			requestContext,
-			abortSignal,
-			...modelOption,
-			output: structuredOutput?.schema,
-			providerOptions,
-			resourceId: threadContext.resourceId,
-			threadId: threadContext.threadId
-		});
-		return await agent.generateLegacy(input, {
-			instructions,
-			requestContext,
-			abortSignal,
-			...modelOption,
-			output: structuredOutput?.schema,
-			providerOptions
-		});
-	}
-	return await agent.generate(input, commonOptions);
-}
-/**
-* Executes a streaming Responses API request through the resolved Mastra agent.
-*/
-async function executeStream({ agent, resolvedModel, modelOverride, instructions, text, providerOptions, input, requestContext, abortSignal, threadContext }) {
-	const executionMemory = createExecutionMemory(threadContext);
-	const structuredOutput = createStructuredOutput(text);
-	const modelOption = modelOverride ? { model: modelOverride } : {};
-	const commonOptions = {
-		instructions,
-		requestContext,
-		abortSignal,
-		...modelOption,
-		structuredOutput,
-		providerOptions,
-		...executionMemory ?? {}
-	};
-	if (resolvedModel.specificationVersion === "v1") {
-		if (threadContext) return await agent.streamLegacy(input, {
-			instructions,
-			requestContext,
-			abortSignal,
-			...modelOption,
-			output: structuredOutput?.schema,
-			providerOptions,
-			resourceId: threadContext.resourceId,
-			threadId: threadContext.threadId
-		});
-		return await agent.streamLegacy(input, {
-			instructions,
-			requestContext,
-			abortSignal,
-			...modelOption,
-			output: structuredOutput?.schema,
-			providerOptions
-		});
-	}
-	return await agent.stream(input, commonOptions);
-}
-async function resolveUsage(result) {
-	return await (result.totalUsage ?? result.usage ?? null);
-}
-async function resolveProviderMetadata(result) {
-	return await (result.providerMetadata ?? void 0);
-}
-async function resolveFinishReason(result) {
-	return await result.finishReason ?? void 0;
-}
-async function resolveText(result) {
-	return await result.text ?? "";
-}
-/**
-* Resolves the final response state shared by streaming and non-streaming flows.
-*/
-async function resolveCompletedResponseState(result, fallbackText) {
-	const usage = await resolveUsage(result);
-	return {
-		completedAt: Math.floor(Date.now() / 1e3),
-		status: require_server_handlers_responses_adapter.toResponseStatus(await resolveFinishReason(result)),
-		text: await resolveText(result) || fallbackText,
-		usage,
-		usageDetails: require_server_handlers_responses_adapter.toResponseUsage(usage),
-		providerOptions: await resolveProviderMetadata(result)
-	};
-}
-/**
-* Stores the completed response when the request opted into memory-backed persistence.
-*/
-async function storeCompletedResponse({ agentMemoryStore, didStore, threadContext, responseId, metadata, completedState, messages, outputItems }) {
-	if (!didStore || !threadContext) return;
-	await require_server_handlers_responses_storage.persistResponseTurnRecord({
-		memoryStore: agentMemoryStore,
-		responseId,
-		metadata: {
-			...metadata,
-			completedAt: completedState.completedAt,
-			status: completedState.status,
-			usage: completedState.usageDetails,
-			providerOptions: completedState.providerOptions,
-			messageIds: [],
-			outputItems
-		},
-		threadContext,
-		messages
-	});
-}
-/**
-* Resolves the final response object and persists the stored response turn when needed.
-*/
-async function finalizeResponse({ agentMemoryStore, didStore, threadContext, result, responseId, createdAt, model, instructions, previousResponseId, conversationId, configuredTools, responseMetadata, fallbackText, fallbackOutputItems }) {
-	const completedState = await resolveCompletedResponseState(result, fallbackText);
-	const fallbackItems = fallbackOutputItems?.(completedState);
-	const responseMessages = await require_server_handlers_responses_storage.resolveResponseTurnMessagesForStorage({
-		result,
-		responseId,
-		text: completedState.text,
-		threadContext,
-		fallbackOutputItems: threadContext ? fallbackItems : void 0
-	});
-	const response = require_server_handlers_responses_adapter.buildCompletedResponse({
-		responseId,
-		outputMessageId: responseId,
-		model,
-		createdAt,
-		completedAt: completedState.completedAt,
-		status: completedState.status,
-		text: completedState.text,
-		usage: completedState.usage,
-		instructions,
-		textConfig: responseMetadata.text,
-		previousResponseId,
-		conversationId,
-		providerOptions: completedState.providerOptions,
-		tools: configuredTools,
-		messages: responseMessages,
-		fallbackOutputItems: fallbackItems,
-		store: didStore
-	});
-	await storeCompletedResponse({
-		agentMemoryStore,
-		didStore,
-		threadContext,
-		responseId,
-		metadata: responseMetadata,
-		completedState,
-		messages: responseMessages,
-		outputItems: response.output
-	});
-	return {
-		completedState,
-		response,
-		responseMessages
-	};
-}
-/**
-* Resolves all request-scoped Mastra primitives needed to execute a Responses create
-* call: the owning agent, the memory thread context, the normalized execution input,
-* and the response-turn metadata that may be persisted later.
-*/
-async function prepareCreateResponseRequest({ body, mastra, requestContext }) {
-	const executionInput = require_server_handlers_responses_adapter.mapResponseInputToExecutionMessages(body.input);
-	let previousResponseTurnRecord = null;
-	let resolvedAgent = null;
-	if (body.previous_response_id) if (body.agent_id) {
-		resolvedAgent = await resolveResponseAgent({
-			mastra,
-			agentId: body.agent_id
-		});
-		previousResponseTurnRecord = await require_server_handlers_responses_storage.findResponseTurnRecord({
-			agent: resolvedAgent,
-			responseId: body.previous_response_id,
-			requestContext
-		});
-		if (!previousResponseTurnRecord) {
-			const owningResponseTurnRecord = await require_server_handlers_responses_storage.findResponseTurnRecordAcrossAgents({
-				mastra,
-				responseId: body.previous_response_id,
-				requestContext
-			});
-			if (owningResponseTurnRecord) if (owningResponseTurnRecord.metadata.agentId === body.agent_id) previousResponseTurnRecord = owningResponseTurnRecord;
-			else throw new require_http_exception.HTTPException(400, { message: `Stored response ${body.previous_response_id} belongs to agent ${owningResponseTurnRecord.metadata.agentId}, not ${body.agent_id}` });
-			if (!previousResponseTurnRecord) throw new require_http_exception.HTTPException(404, { message: `Stored response ${body.previous_response_id} was not found` });
-		}
-	} else {
-		if (!mastra) throw new require_http_exception.HTTPException(500, { message: "Mastra instance is required for agent-backed responses" });
-		previousResponseTurnRecord = await require_server_handlers_responses_storage.findResponseTurnRecordAcrossAgents({
-			mastra,
-			responseId: body.previous_response_id,
-			requestContext
-		});
-		if (!previousResponseTurnRecord) throw new require_http_exception.HTTPException(404, { message: `Stored response ${body.previous_response_id} was not found` });
-	}
-	const agent = resolvedAgent ?? await resolveResponseAgent({
-		mastra,
-		agentId: body.agent_id ?? previousResponseTurnRecord?.metadata.agentId
-	});
-	const resolvedModel = await agent.getModel({
-		requestContext,
-		modelConfig: body.model
-	});
-	const responseModel = body.model ?? (() => {
-		if (resolvedModel.provider && resolvedModel.modelId) return `${resolvedModel.provider.includes(".") ? resolvedModel.provider.split(".")[0] : resolvedModel.provider}/${resolvedModel.modelId}`;
-		if (resolvedModel.modelId) return resolvedModel.modelId;
-		throw new require_http_exception.HTTPException(500, { message: "Responses route could not determine the effective model for this request" });
-	})();
-	const shouldStore = body.store ?? false;
-	const agentMemoryStore = shouldStore || Boolean(body.conversation_id) || Boolean(body.previous_response_id) ? await resolveAgentMemoryStore({
-		agent,
-		requestContext,
-		errorMessage: body.previous_response_id ? "previous_response_id requires the target agent to have memory storage configured" : shouldStore ? "Stored responses require the target agent to have memory storage configured" : "conversation_id requires the target agent to have memory storage configured"
-	}) : null;
-	const configuredTools = require_server_handlers_responses_adapter.mapMastraToolsToResponseTools(await Promise.resolve(agent.listTools({ requestContext })));
-	const responseId = require_server_handlers_responses_adapter.createMessageId();
-	const createdAt = Math.floor(Date.now() / 1e3);
-	const threadContext = await resolveThreadExecutionContext({
-		agent,
-		store: shouldStore,
-		conversationId: body.conversation_id,
-		previousResponseTurnRecord,
-		requestContext
-	});
-	if (shouldStore && !threadContext) throw new require_http_exception.HTTPException(400, { message: "Stored responses require the target agent to have memory configured" });
-	const didStore = shouldStore && Boolean(threadContext);
-	return {
-		agent,
-		agentMemoryStore,
-		configuredTools,
-		createdAt,
-		didStore,
-		executionInput,
-		previousResponseTurnRecord,
-		resolvedModel,
-		responseId,
-		responseModel,
-		responseMetadata: {
-			agentId: agent.id,
-			model: responseModel,
-			createdAt,
-			instructions: body.instructions,
-			text: body.text,
-			previousResponseId: previousResponseTurnRecord?.message.id ?? body.previous_response_id,
-			tools: configuredTools,
-			store: didStore
-		},
-		threadContext
-	};
-}
-/**
-* Bridges a Mastra agent stream into OpenAI-style Responses SSE events and completes
-* the stored response-turn record when the stream finishes.
-*/
-function createResponseEventStream({ agentMemoryStore, body, configuredTools, createdAt, didStore, previousResponseTurnRecord, responseId, responseModel, responseMetadata, streamResult, threadContext }) {
-	const createdResponse = require_server_handlers_responses_adapter.buildInProgressResponse({
-		responseId,
-		model: responseModel,
-		createdAt,
-		instructions: body.instructions,
-		textConfig: body.text,
-		previousResponseId: body.previous_response_id,
-		conversationId: threadContext?.threadId ?? body.conversation_id,
-		tools: configuredTools,
-		store: didStore
-	});
-	return new ReadableStream({ async start(controller) {
-		let sequenceNumber = 1;
-		const enqueueEvent = (eventName, payload) => {
-			controller.enqueue(require_server_handlers_responses_adapter.formatSseEvent(eventName, {
-				...payload,
-				sequence_number: sequenceNumber++
-			}));
-		};
-		enqueueEvent("response.created", {
-			type: "response.created",
-			response: createdResponse
-		});
-		enqueueEvent("response.in_progress", {
-			type: "response.in_progress",
-			response: createdResponse
-		});
-		const streamEvents = require_server_handlers_responses_adapter.createResponseStreamEventTranslator(responseId);
-		const reader = (await streamResult.fullStream).getReader();
-		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				for (const event of streamEvents.consume(value)) enqueueEvent(event.event, event.payload);
-			}
-			for (const event of streamEvents.flushPendingToolResults()) enqueueEvent(event.event, event.payload);
-			const { completedState, response } = await finalizeResponse({
-				agentMemoryStore,
-				didStore,
-				threadContext,
-				result: streamResult,
-				responseId,
-				createdAt,
-				model: responseModel,
-				instructions: body.instructions,
-				previousResponseId: previousResponseTurnRecord?.message.id ?? body.previous_response_id,
-				conversationId: threadContext?.threadId ?? body.conversation_id,
-				configuredTools,
-				responseMetadata,
-				fallbackText: streamEvents.text,
-				fallbackOutputItems: (completedState) => streamEvents.getOutputItems({
-					text: completedState.text,
-					status: completedState.status
-				})
-			});
-			const completedItem = getStreamedMessageOutputItem(response, responseId);
-			if (completedItem || completedState.text) for (const event of streamEvents.completeText(completedState.text, completedItem ?? {
-				id: responseId,
-				type: "message",
-				role: "assistant",
-				status: "completed",
-				content: [require_server_handlers_responses_adapter.createOutputTextPart(completedState.text)]
-			})) enqueueEvent(event.event, event.payload);
-			enqueueEvent("response.completed", {
-				type: "response.completed",
-				response
-			});
-			controller.close();
-		} catch (error) {
-			controller.error(error);
-		} finally {
-			reader.releaseLock();
-		}
-	} });
-}
-const CREATE_RESPONSE_ROUTE = require_route_builder.createRoute({
-	method: "POST",
-	path: "/v1/responses",
-	responseType: "datastream-response",
-	bodySchema: require_responses.createResponseBodySchema,
-	responseSchema: require_responses.responseObjectSchema,
-	summary: "Create a response",
-	description: "Creates a response through a Mastra-hosted Responses API-compatible route",
-	tags: ["Responses"],
-	requiresAuth: true,
-	requiresPermission: require_utils.MastraFGAPermissions.AGENTS_EXECUTE,
-	handler: async ({ mastra, requestContext, abortSignal, ...body }) => {
-		try {
-			const { agent, agentMemoryStore, configuredTools, createdAt, didStore, executionInput, previousResponseTurnRecord, resolvedModel, responseId, responseModel, responseMetadata, threadContext } = await prepareCreateResponseRequest({
-				body,
-				mastra,
-				requestContext
-			});
-			if (!body.stream) {
-				const { response } = await finalizeResponse({
-					agentMemoryStore,
-					didStore,
-					threadContext,
-					result: await executeGenerate({
-						agent,
-						resolvedModel,
-						modelOverride: body.model,
-						instructions: body.instructions,
-						text: body.text,
-						providerOptions: body.providerOptions,
-						input: executionInput,
-						requestContext,
-						abortSignal,
-						threadContext
-					}),
-					responseId,
-					createdAt,
-					model: responseModel,
-					instructions: body.instructions,
-					previousResponseId: previousResponseTurnRecord?.message.id ?? body.previous_response_id,
-					conversationId: threadContext?.threadId ?? body.conversation_id,
-					configuredTools,
-					responseMetadata,
-					fallbackText: ""
-				});
-				return jsonResponse(response);
-			}
-			const stream = createResponseEventStream({
-				agentMemoryStore,
-				body,
-				configuredTools,
-				createdAt,
-				didStore,
-				previousResponseTurnRecord,
-				responseId,
-				responseModel,
-				responseMetadata,
-				streamResult: await executeStream({
-					agent,
-					resolvedModel,
-					modelOverride: body.model,
-					instructions: body.instructions,
-					text: body.text,
-					providerOptions: body.providerOptions,
-					input: executionInput,
-					requestContext,
-					abortSignal,
-					threadContext
-				}),
-				threadContext
-			});
-			return new Response(stream, { headers: {
-				"Content-Type": "text/event-stream; charset=utf-8",
-				"Cache-Control": "no-cache",
-				Connection: "keep-alive",
-				"X-Accel-Buffering": "no"
-			} });
-		} catch (error) {
-			return require_server_handlers_error.handleError(error, "Error creating response");
-		}
-	}
-});
-const GET_RESPONSE_ROUTE = require_route_builder.createRoute({
-	method: "GET",
-	path: "/v1/responses/:responseId",
-	responseType: "json",
-	pathParamSchema: require_responses.responseIdPathParams,
-	responseSchema: require_responses.responseObjectSchema,
-	summary: "Retrieve a stored response",
-	description: "Returns a previously stored response object",
-	tags: ["Responses"],
-	requiresAuth: true,
-	requiresPermission: require_utils.MastraFGAPermissions.AGENTS_READ,
-	handler: async ({ mastra, requestContext, responseId }) => {
-		try {
-			const responseTurnRecord = await require_server_handlers_responses_storage.findResponseTurnRecordAcrossAgents({
-				mastra,
-				responseId,
-				requestContext
-			});
-			if (!responseTurnRecord) throw new require_http_exception.HTTPException(404, { message: `Stored response ${responseId} was not found` });
-			return require_server_handlers_responses_adapter.mapResponseTurnRecordToResponse(responseTurnRecord);
-		} catch (error) {
-			return require_server_handlers_error.handleError(error, "Error retrieving response");
-		}
-	}
-});
-const DELETE_RESPONSE_ROUTE = require_route_builder.createRoute({
-	method: "DELETE",
-	path: "/v1/responses/:responseId",
-	responseType: "json",
-	pathParamSchema: require_responses.responseIdPathParams,
-	responseSchema: require_responses.deleteResponseSchema,
-	summary: "Delete a stored response",
-	description: "Deletes a stored response so it can no longer be retrieved or chained",
-	tags: ["Responses"],
-	requiresAuth: true,
-	requiresPermission: require_utils.MastraFGAPermissions.AGENTS_DELETE,
-	handler: async ({ mastra, requestContext, responseId }) => {
-		try {
-			const responseTurnRecord = await require_server_handlers_responses_storage.findResponseTurnRecordAcrossAgents({
-				mastra,
-				responseId,
-				requestContext
-			});
-			if (!responseTurnRecord) throw new require_http_exception.HTTPException(404, { message: `Stored response ${responseId} was not found` });
-			await require_server_handlers_responses_storage.deleteResponseTurnRecord({ responseTurnRecord });
-			return {
-				id: responseId,
-				object: "response",
-				deleted: true
-			};
-		} catch (error) {
-			return require_server_handlers_error.handleError(error, "Error deleting response");
-		}
-	}
-});
-//#endregion
-exports.CREATE_RESPONSE_ROUTE = CREATE_RESPONSE_ROUTE;
-exports.DELETE_RESPONSE_ROUTE = DELETE_RESPONSE_ROUTE;
-exports.GET_RESPONSE_ROUTE = GET_RESPONSE_ROUTE;
-Object.defineProperty(exports, "responses_exports", {
-	enumerable: true,
-	get: function() {
-		return responses_exports;
-	}
-});
-
-//# sourceMappingURL=responses.cjs.map
+require("../../rolldown-runtime-BwC_XMyb.cjs");
+const require_responses = require("../../responses-CCRijwDF.cjs");
+exports.CREATE_RESPONSE_ROUTE = require_responses.CREATE_RESPONSE_ROUTE;
+exports.DELETE_RESPONSE_ROUTE = require_responses.DELETE_RESPONSE_ROUTE;
+exports.GET_RESPONSE_ROUTE = require_responses.GET_RESPONSE_ROUTE;