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

package/dist/responses-4FwMNxoJ.js

@@ -0,0 +1,628 @@
+import { r as __exportAll } from "./rolldown-runtime-D3Hj5m0v.js";
+import { t as HTTPException } from "./http-exception-CyfxZB6W.js";
+import { n as createRoute } from "./route-builder-CjkWxv4E.js";
+import { handleError } from "./server/handlers/error.js";
+import { a as getEffectiveThreadId, g as MastraFGAPermissions, i as getEffectiveResourceId, n as enforceThreadAccess } from "./utils-BBJlS81s.js";
+import { W as getAgentFromSystem } from "./agents-DRQ3ScbX.js";
+import { a as deleteResponseSchema, i as createResponseBodySchema, o as responseIdPathParams, u as responseObjectSchema } from "./responses-DJNJgCTg.js";
+import { buildCompletedResponse, buildInProgressResponse, createMessageId, createOutputTextPart, createResponseStreamEventTranslator, formatSseEvent, mapMastraToolsToResponseTools, mapResponseInputToExecutionMessages, mapResponseTurnRecordToResponse, toResponseStatus, toResponseUsage } from "./server/handlers/responses.adapter.js";
+import { deleteResponseTurnRecord, findResponseTurnRecord, findResponseTurnRecordAcrossAgents, getAgentMemoryStore, persistResponseTurnRecord, resolveResponseTurnMessagesForStorage } from "./server/handlers/responses.storage.js";
+//#region src/server/handlers/responses.ts
+var responses_exports = /* @__PURE__ */ __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 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 = getEffectiveThreadId(requestContext, void 0);
+	const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+	if (!store && !conversationId && !effectiveThreadId) return null;
+	const memory = await agent.getMemory({ requestContext });
+	if (!memory) {
+		if (conversationId) throw new 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 HTTPException(404, { message: `Conversation ${conversationId} was not found` });
+		await 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 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 HTTPException(400, { message: "Responses requests require an agent_id" });
+	if (!mastra) throw new HTTPException(500, { message: "Mastra instance is required for agent-backed responses" });
+	return getAgentFromSystem({
+		mastra,
+		agentId
+	});
+}
+async function resolveAgentMemoryStore({ agent, requestContext, errorMessage }) {
+	const agentMemoryStore = await getAgentMemoryStore({
+		agent,
+		requestContext
+	});
+	if (!agentMemoryStore) throw new 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: toResponseStatus(await resolveFinishReason(result)),
+		text: await resolveText(result) || fallbackText,
+		usage,
+		usageDetails: 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 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 resolveResponseTurnMessagesForStorage({
+		result,
+		responseId,
+		text: completedState.text,
+		threadContext,
+		fallbackOutputItems: threadContext ? fallbackItems : void 0
+	});
+	const response = 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 = 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 findResponseTurnRecord({
+				agent: resolvedAgent,
+				responseId: body.previous_response_id,
+				requestContext
+			});
+			if (!previousResponseTurnRecord) {
+				const owningResponseTurnRecord = await findResponseTurnRecordAcrossAgents({
+					mastra,
+					responseId: body.previous_response_id,
+					requestContext
+				});
+				if (owningResponseTurnRecord) {
+					if (owningResponseTurnRecord.metadata.agentId === body.agent_id) previousResponseTurnRecord = owningResponseTurnRecord;
+					else throw new HTTPException(400, { message: `Stored response ${body.previous_response_id} belongs to agent ${owningResponseTurnRecord.metadata.agentId}, not ${body.agent_id}` });
+				}
+				if (!previousResponseTurnRecord) throw new HTTPException(404, { message: `Stored response ${body.previous_response_id} was not found` });
+			}
+		} else {
+			if (!mastra) throw new HTTPException(500, { message: "Mastra instance is required for agent-backed responses" });
+			previousResponseTurnRecord = await findResponseTurnRecordAcrossAgents({
+				mastra,
+				responseId: body.previous_response_id,
+				requestContext
+			});
+			if (!previousResponseTurnRecord) throw new 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 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 = mapMastraToolsToResponseTools(await Promise.resolve(agent.listTools({ requestContext })));
+	const responseId = 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 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 = 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(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 = 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: [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 = createRoute({
+	method: "POST",
+	path: "/v1/responses",
+	responseType: "datastream-response",
+	bodySchema: createResponseBodySchema,
+	responseSchema: responseObjectSchema,
+	summary: "Create a response",
+	description: "Creates a response through a Mastra-hosted Responses API-compatible route",
+	tags: ["Responses"],
+	requiresAuth: true,
+	requiresPermission: 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 handleError(error, "Error creating response");
+		}
+	}
+});
+const GET_RESPONSE_ROUTE = createRoute({
+	method: "GET",
+	path: "/v1/responses/:responseId",
+	responseType: "json",
+	pathParamSchema: responseIdPathParams,
+	responseSchema: responseObjectSchema,
+	summary: "Retrieve a stored response",
+	description: "Returns a previously stored response object",
+	tags: ["Responses"],
+	requiresAuth: true,
+	requiresPermission: MastraFGAPermissions.AGENTS_READ,
+	handler: async ({ mastra, requestContext, responseId }) => {
+		try {
+			const responseTurnRecord = await findResponseTurnRecordAcrossAgents({
+				mastra,
+				responseId,
+				requestContext
+			});
+			if (!responseTurnRecord) throw new HTTPException(404, { message: `Stored response ${responseId} was not found` });
+			return mapResponseTurnRecordToResponse(responseTurnRecord);
+		} catch (error) {
+			return handleError(error, "Error retrieving response");
+		}
+	}
+});
+const DELETE_RESPONSE_ROUTE = createRoute({
+	method: "DELETE",
+	path: "/v1/responses/:responseId",
+	responseType: "json",
+	pathParamSchema: responseIdPathParams,
+	responseSchema: 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: MastraFGAPermissions.AGENTS_DELETE,
+	handler: async ({ mastra, requestContext, responseId }) => {
+		try {
+			const responseTurnRecord = await findResponseTurnRecordAcrossAgents({
+				mastra,
+				responseId,
+				requestContext
+			});
+			if (!responseTurnRecord) throw new HTTPException(404, { message: `Stored response ${responseId} was not found` });
+			await deleteResponseTurnRecord({ responseTurnRecord });
+			return {
+				id: responseId,
+				object: "response",
+				deleted: true
+			};
+		} catch (error) {
+			return handleError(error, "Error deleting response");
+		}
+	}
+});
+//#endregion
+export { responses_exports as i, DELETE_RESPONSE_ROUTE as n, GET_RESPONSE_ROUTE as r, CREATE_RESPONSE_ROUTE as t };
+
+//# sourceMappingURL=responses-4FwMNxoJ.js.map