@case-framework/survey-assistant 0.1.0

package/dist/memory-thread-repository-CJkkVE2-.mjs

@@ -0,0 +1,718 @@
+import { D as createSurveyAssistantThreadInputSchema, Ot as serializeSurveyAssistantError, j as updateSurveyAssistantThreadInputSchema, n as SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE } from "./protocol-DV0ka9WT.mjs";
+import { t as SurveyAssistantCapabilityMismatchError } from "./capabilities-B6tvE7fK.mjs";
+import { o as TurnChangeCollector } from "./engine-sPvuixWg.mjs";
+import "./constants-CFUWrRtl.mjs";
+import { n as parseSurveyAssistantSnapshot, t as buildSurveyAssistantRequestContext } from "./request-context-jcmXT_Q2.mjs";
+import { c as SurveyAssistantRequestError, l as readSurveyAssistantRequestJson, u as validateSurveyAssistantMessages } from "./request-guardrails-C59IWnH8.mjs";
+import { createUIMessageStreamResponse } from "ai";
+import { handleChatStream } from "@mastra/ai-sdk";
+import { toAISdkMessages } from "@mastra/ai-sdk/ui";
+//#region src/server/turn-stream.ts
+const createTurnFinalChunk = (turnFinal) => ({
+	type: SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE,
+	id: turnFinal.turnId,
+	data: turnFinal
+});
+const createSurveyAssistantTurnStream = ({ changeCollector, onSettled, onUnexpectedError = () => "The survey assistant stream ended unexpectedly.", signal, stream }) => {
+	const reader = stream.getReader();
+	let settled = false;
+	const settle = () => {
+		if (settled) return;
+		settled = true;
+		onSettled?.();
+	};
+	return new ReadableStream({
+		async start(controller) {
+			let emittedTurnFinal = false;
+			let sawFinish = false;
+			let finishReason;
+			const emitTurnFinal = (status) => {
+				if (emittedTurnFinal) return;
+				emittedTurnFinal = true;
+				controller.enqueue(createTurnFinalChunk(changeCollector.finalize(status)));
+			};
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (value.type === SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE) {
+						emitTurnFinal("failed");
+						controller.enqueue({
+							type: "error",
+							errorText: "The survey assistant returned an invalid duplicate turn final."
+						});
+						await reader.cancel("duplicate turn final");
+						break;
+					}
+					if (value.type === "error") {
+						emitTurnFinal("failed");
+						controller.enqueue(value);
+						continue;
+					}
+					if (value.type === "abort") {
+						emitTurnFinal("aborted");
+						controller.enqueue(value);
+						continue;
+					}
+					if (value.type === "finish") {
+						sawFinish = true;
+						finishReason = value.finishReason;
+					}
+					controller.enqueue(value);
+				}
+				if (!emittedTurnFinal) emitTurnFinal(signal?.aborted ? "aborted" : sawFinish && (finishReason === void 0 || finishReason === "stop") ? "completed" : "failed");
+				controller.close();
+			} catch (error) {
+				try {
+					emitTurnFinal(signal?.aborted ? "aborted" : "failed");
+					if (!signal?.aborted) controller.enqueue({
+						type: "error",
+						errorText: onUnexpectedError(error)
+					});
+					controller.close();
+				} catch {}
+			} finally {
+				reader.releaseLock();
+				settle();
+			}
+		},
+		async cancel(reason) {
+			changeCollector.finalize("aborted");
+			settle();
+			await reader.cancel(reason);
+		}
+	});
+};
+//#endregion
+//#region src/server/thread-documents.ts
+const parseFileDataUrl = (url) => {
+	const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/.exec(url);
+	return match ? {
+		mediaType: match[1],
+		data: match[2]
+	} : null;
+};
+const getBase64Bytes = (data) => {
+	const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+	return Math.max(0, Math.floor(data.length * 3 / 4) - padding);
+};
+const registerSurveyAssistantThreadAttachments = async ({ messages, repository, resourceId, threadId }) => {
+	const registered = [];
+	const currentMessage = getCurrentUserMessage(messages);
+	for (const message of currentMessage ? [currentMessage] : []) for (const part of message.parts) {
+		if (part.type !== "file" || typeof part.url !== "string") continue;
+		const parsed = parseFileDataUrl(part.url);
+		if (!parsed) continue;
+		registered.push(await repository.put({
+			resourceId,
+			threadId,
+			name: part.filename?.trim() || "Attached document",
+			mediaType: parsed.mediaType,
+			data: parsed.data,
+			bytes: getBase64Bytes(parsed.data)
+		}));
+	}
+	return registered;
+};
+const hasMatchingCurrentFile = (message, document) => message.parts.some((part) => part.type === "file" && part.filename === document.name && part.mediaType === document.mediaType);
+const getCurrentUserMessage = (messages) => {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role === "user") return message;
+	}
+};
+const removeHistoricalSurveyAssistantAttachments = (messages) => {
+	const current = getCurrentUserMessage(messages);
+	return messages.map((message) => {
+		if (message === current) return message;
+		const parts = message.parts.filter((part) => part.type !== "file");
+		return parts.length === message.parts.length ? message : {
+			...message,
+			parts
+		};
+	});
+};
+const getSurveyAssistantReplayableDocuments = (documents, messages) => {
+	const current = getCurrentUserMessage(messages);
+	return current ? documents.filter((document) => !hasMatchingCurrentFile(current, document)) : [];
+};
+const loadSurveyAssistantThreadAttachments = async ({ documents, messages, repository, resourceId, threadId }) => {
+	return loadSurveyAssistantDocuments({
+		documents: getSurveyAssistantReplayableDocuments(documents, messages),
+		repository,
+		resourceId,
+		threadId
+	});
+};
+const loadSurveyAssistantDocuments = async ({ documents, repository, resourceId, threadId }) => {
+	const attachments = [];
+	for (const document of documents) {
+		const content = await repository.read({
+			resourceId,
+			threadId,
+			documentId: document.id
+		});
+		if (!content) continue;
+		attachments.push({
+			filename: content.name,
+			mediaType: content.mediaType,
+			data: content.data,
+			contentHash: content.contentHash
+		});
+	}
+	return attachments;
+};
+//#endregion
+//#region src/server/handler.ts
+const DEFAULT_MAX_STEPS = 48;
+const DEFAULT_MAX_CONCURRENT_REQUESTS = 4;
+const MAX_USER_ERROR_MESSAGE_LENGTH = 700;
+const MAX_ERROR_CAUSE_DEPTH = 5;
+var SurveyAssistantAuthorizationError = class extends Error {
+	status;
+	constructor(message = "The survey assistant request is not authorized.", status = 403) {
+		super(message);
+		this.name = "SurveyAssistantAuthorizationError";
+		this.status = status;
+	}
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const optionalRequestedId = (value) => {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	return normalized.length > 0 && normalized.length <= 240 ? normalized : void 0;
+};
+const validateAuthorizedIdentity = (identity) => {
+	if (!identity || identity.authority !== "authenticated-host" && identity.authority !== "experimental-client-request" || typeof identity.resourceId !== "string" || identity.resourceId.trim().length === 0 || identity.resourceId.length > 240 || typeof identity.threadId !== "string" || identity.threadId.trim().length === 0 || identity.threadId.length > 240) throw new SurveyAssistantAuthorizationError("The host returned an invalid survey assistant identity.", 500);
+	return {
+		authority: identity.authority,
+		resourceId: identity.resourceId.trim(),
+		threadId: identity.threadId.trim()
+	};
+};
+const validateModelSelection = (selection) => {
+	if (!selection) return null;
+	const id = optionalRequestedId(selection.id);
+	const model = optionalRequestedId(selection.model);
+	return id && model ? {
+		id,
+		model
+	} : null;
+};
+const readNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const recordTurnStreamPart = (metrics, part) => {
+	if (!isRecord(part)) return;
+	if (part.type === "tool-call") metrics.toolCalls += 1;
+	if (part.type !== "finish") return;
+	const payload = isRecord(part.payload) ? part.payload : void 0;
+	const output = isRecord(payload?.output) ? payload.output : void 0;
+	const usage = isRecord(output?.usage) ? output.usage : void 0;
+	if (!usage) return;
+	metrics.inputTokens = readNumber(usage.inputTokens);
+	metrics.outputTokens = readNumber(usage.outputTokens);
+	metrics.totalTokens = readNumber(usage.totalTokens);
+	metrics.reasoningTokens = readNumber(usage.reasoningTokens);
+	metrics.cachedInputTokens = readNumber(usage.cachedInputTokens);
+};
+const unwrapStreamError = (error) => {
+	if (isRecord(error) && error.error !== void 0) return error.error;
+	return error;
+};
+const describeErrorLevel = (value) => {
+	if (value instanceof Error) {
+		const properties = Object.fromEntries(Object.getOwnPropertyNames(value).filter((key) => key !== "stack").map((key) => [key, value[key]]));
+		return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack,
+			...properties
+		};
+	}
+	if (isRecord(value)) return {
+		constructorName: value.constructor?.name,
+		...Object.fromEntries(Object.getOwnPropertyNames(value).map((key) => [key, value[key]]))
+	};
+	return { value };
+};
+const describeSurveyAssistantStreamError = (error) => {
+	const levels = [];
+	let current = unwrapStreamError(error);
+	for (let depth = 0; depth < MAX_ERROR_CAUSE_DEPTH && current !== void 0 && current !== null; depth += 1) {
+		const level = describeErrorLevel(current);
+		levels.push(level);
+		current = level.cause;
+	}
+	return levels.length === 1 ? levels[0] : { levels };
+};
+const clampUserErrorMessage = (message) => {
+	const normalized = message.replace(/\s+/g, " ").trim();
+	return normalized.length <= MAX_USER_ERROR_MESSAGE_LENGTH ? normalized : `${normalized.slice(0, MAX_USER_ERROR_MESSAGE_LENGTH - 1)}…`;
+};
+const getProviderModelName = (message) => message.match(/\bmodel\s+[`'"]([^`'"]+)[`'"]/i)?.[1]?.trim();
+const classifyStreamError = (message, statusCode) => {
+	if (statusCode === 401 || statusCode === 403) return "authorization_failed";
+	if (statusCode === 429) return "rate_limited";
+	if (/\bmodel\b[\s\S]{0,160}\b(?:limited preview|not available)\b/i.test(message) || /\blimited preview\b[\s\S]{0,160}\bmodel\b/i.test(message)) return "model_unavailable";
+	if (/\b(?:rate limit|too many requests|request limit)\b/i.test(message)) return "rate_limited";
+	if (/\b(?:invalid api key|incorrect api key|authentication|unauthorized|forbidden)\b/i.test(message)) return "authorization_failed";
+	if (/\b(?:attachment|document|file)\b[\s\S]{0,120}\b(?:missing|unavailable|not found|failed)\b/i.test(message)) return "attachment_unavailable";
+	return "request_failed";
+};
+const formatKnownProviderError = (message) => {
+	const normalized = clampUserErrorMessage(message);
+	if (/\bmodel\b[\s\S]{0,160}\b(?:limited preview|not available)\b/i.test(normalized) || /\blimited preview\b[\s\S]{0,160}\bmodel\b/i.test(normalized)) {
+		const modelName = getProviderModelName(normalized);
+		return `The configured model${modelName ? ` \`${modelName}\`` : ""} is not available on this account.`;
+	}
+	if (/\b(?:rate limit|too many requests|request limit)\b/i.test(normalized)) return "The AI provider is temporarily limiting requests.";
+	if (/\b(?:invalid api key|incorrect api key|authentication|unauthorized|forbidden)\b/i.test(normalized)) return "The AI provider rejected the assistant credentials.";
+	return normalized;
+};
+const parseProviderResponseBodyMessage = (responseBody) => {
+	if (typeof responseBody !== "string" || responseBody.trim().length === 0) return void 0;
+	try {
+		const parsed = JSON.parse(responseBody);
+		if (isRecord(parsed) && isRecord(parsed.error) && typeof parsed.error.message === "string") return parsed.error.message;
+	} catch {
+		return responseBody;
+	}
+	return responseBody;
+};
+const extractUserErrorMessageFromLevel = (level) => {
+	if (isRecord(level.data) && isRecord(level.data.error) && typeof level.data.error.message === "string") return level.data.error.message;
+	return parseProviderResponseBodyMessage(level.responseBody) ?? (typeof level.message === "string" ? level.message : void 0);
+};
+const formatSurveyAssistantStreamError = (error) => {
+	const describedError = describeSurveyAssistantStreamError(error);
+	const levels = Array.isArray(describedError.levels) ? describedError.levels : [describedError];
+	const messageLevel = levels.find((level) => isRecord(level) && Boolean(extractUserErrorMessageFromLevel(level)));
+	const statusLevel = levels.find((level) => isRecord(level) && level.statusCode !== void 0);
+	const statusCode = Number(statusLevel?.statusCode);
+	const detail = messageLevel ? extractUserErrorMessageFromLevel(messageLevel) : void 0;
+	const formattedDetail = detail ? formatKnownProviderError(detail) : void 0;
+	return serializeSurveyAssistantError({
+		code: classifyStreamError(formattedDetail ?? "", Number.isFinite(statusCode) ? statusCode : void 0),
+		...formattedDetail ? { detail: formattedDetail } : {}
+	});
+};
+const requestErrorResponse = (error, fallback) => {
+	const requestError = error instanceof SurveyAssistantRequestError ? error : new SurveyAssistantRequestError(fallback);
+	return Response.json({
+		code: "request_failed",
+		error: requestError.message
+	}, { status: requestError.status });
+};
+const createSurveyAssistantChatHandler = (options) => {
+	const maxConcurrentRequests = Number.isInteger(options.maxConcurrentRequests) && (options.maxConcurrentRequests ?? 0) > 0 ? options.maxConcurrentRequests : DEFAULT_MAX_CONCURRENT_REQUESTS;
+	const maxSteps = Number.isInteger(options.maxSteps) && (options.maxSteps ?? 0) > 0 ? options.maxSteps : DEFAULT_MAX_STEPS;
+	let activeRequestCount = 0;
+	const acquireRequestSlot = () => {
+		if (activeRequestCount >= maxConcurrentRequests) return null;
+		activeRequestCount += 1;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			activeRequestCount = Math.max(0, activeRequestCount - 1);
+		};
+	};
+	return async (request) => {
+		if (options.isEnabled && !await options.isEnabled(request)) return Response.json({
+			code: "authorization_failed",
+			error: "Survey assistant is disabled."
+		}, { status: 404 });
+		let rawParams;
+		try {
+			rawParams = await readSurveyAssistantRequestJson(request);
+		} catch (error) {
+			return requestErrorResponse(error, "The survey assistant request could not be read.");
+		}
+		const params = isRecord(rawParams) ? rawParams : {};
+		let identity;
+		try {
+			identity = validateAuthorizedIdentity(await options.authorize({
+				request,
+				requestedResourceId: optionalRequestedId(params.resourceId),
+				requestedThreadId: optionalRequestedId(params.threadId ?? params.id),
+				requestedSurveyId: optionalRequestedId(params.surveyId)
+			}));
+		} catch (error) {
+			const authorizationError = error instanceof SurveyAssistantAuthorizationError ? error : new SurveyAssistantAuthorizationError();
+			return Response.json({
+				code: "authorization_failed",
+				error: authorizationError.message
+			}, { status: authorizationError.status });
+		}
+		let messages;
+		try {
+			messages = validateSurveyAssistantMessages(params.messages);
+		} catch (error) {
+			return requestErrorResponse(error, "The survey assistant messages are invalid.");
+		}
+		let modelSelection;
+		if (options.resolveModel) {
+			const requestedModelId = optionalRequestedId(params.modelId);
+			if (params.modelId !== void 0 && !requestedModelId) return Response.json({
+				code: "model_unavailable",
+				error: "Invalid survey assistant model selection."
+			}, { status: 400 });
+			try {
+				modelSelection = validateModelSelection(await options.resolveModel({
+					identity,
+					request,
+					requestedModelId
+				})) ?? void 0;
+			} catch (error) {
+				options.onStreamError?.(error, {
+					resourceId: identity.resourceId,
+					threadId: identity.threadId
+				});
+				return Response.json({
+					code: "model_unavailable",
+					error: "The survey assistant model catalog is unavailable."
+				}, { status: 503 });
+			}
+			if (!modelSelection) return Response.json({
+				code: "model_unavailable",
+				error: "The selected survey assistant model is not available."
+			}, { status: 400 });
+		}
+		let snapshot;
+		try {
+			snapshot = parseSurveyAssistantSnapshot(params.snapshot);
+		} catch {
+			return Response.json({
+				code: "request_failed",
+				error: "Invalid survey assistant snapshot."
+			}, { status: 400 });
+		}
+		const readinessError = await options.getReadinessError?.(request);
+		if (readinessError) return Response.json({
+			code: "request_failed",
+			error: readinessError
+		}, { status: 503 });
+		const releaseRequestSlot = acquireRequestSlot();
+		if (!releaseRequestSlot) return Response.json({
+			code: "rate_limited",
+			error: "The survey assistant is handling too many requests. Try again shortly."
+		}, { status: 429 });
+		const changeCollector = new TurnChangeCollector();
+		let requestContext;
+		try {
+			let attachmentAccess;
+			let modelAttachments = [];
+			if (options.threadDocuments) {
+				const repository = options.threadDocuments;
+				const registered = await registerSurveyAssistantThreadAttachments({
+					messages,
+					repository,
+					resourceId: identity.resourceId,
+					threadId: identity.threadId
+				});
+				const manifest = await repository.list({
+					resourceId: identity.resourceId,
+					threadId: identity.threadId
+				});
+				modelAttachments = await loadSurveyAssistantDocuments({
+					documents: registered,
+					repository,
+					resourceId: identity.resourceId,
+					threadId: identity.threadId
+				});
+				messages = removeHistoricalSurveyAssistantAttachments(messages);
+				const registeredIds = new Set(registered.map((document) => document.id));
+				const replayableDocuments = getSurveyAssistantReplayableDocuments(manifest.filter((document) => !registeredIds.has(document.id)), messages);
+				const documents = [...registered, ...replayableDocuments];
+				if (documents.length > 0) attachmentAccess = {
+					documents,
+					currentDocumentIds: registered.map((document) => document.id),
+					selectedAttachments: [],
+					load: (documentIds) => loadSurveyAssistantDocuments({
+						documents: documents.filter((document) => documentIds.includes(document.id)),
+						repository,
+						resourceId: identity.resourceId,
+						threadId: identity.threadId
+					})
+				};
+			}
+			requestContext = buildSurveyAssistantRequestContext({
+				changeCollector,
+				identity,
+				snapshot,
+				snapshotSource: snapshot ? "full" : "missing",
+				trustedCapabilities: options.trustedCapabilities,
+				attachmentAccess,
+				modelAttachments,
+				modelSelection
+			});
+		} catch (error) {
+			releaseRequestSlot();
+			if (error instanceof SurveyAssistantRequestError) return requestErrorResponse(error, "The thread attachments could not be prepared.");
+			if (error instanceof SurveyAssistantCapabilityMismatchError) return Response.json({
+				error: error.message,
+				code: error.code
+			}, { status: 409 });
+			options.onStreamError?.(error, {
+				resourceId: identity.resourceId,
+				threadId: identity.threadId
+			});
+			return Response.json({
+				code: "attachment_unavailable",
+				error: "The survey assistant could not prepare the thread's reference documents."
+			}, { status: 503 });
+		}
+		const metrics = {
+			snapshotBytes: snapshot ? new TextEncoder().encode(JSON.stringify(snapshot)).byteLength : 0,
+			toolCalls: 0
+		};
+		const streamErrorContext = {
+			resourceId: identity.resourceId,
+			threadId: identity.threadId
+		};
+		const handleStreamError = (error) => {
+			options.onStreamError?.(error, streamErrorContext);
+			return options.formatStreamError?.(error, streamErrorContext) ?? formatSurveyAssistantStreamError(error);
+		};
+		let stream;
+		try {
+			stream = await handleChatStream({
+				mastra: typeof options.mastra === "function" ? await options.mastra() : options.mastra,
+				agentId: options.agentId ?? "survey-assistant-agent",
+				version: "v6",
+				params: {
+					messages,
+					...params.trigger ? { trigger: params.trigger } : {},
+					requestContext,
+					runId: changeCollector.turnId,
+					abortSignal: request.signal,
+					onAbort: () => {
+						changeCollector.finalize("aborted");
+					},
+					onError: () => {
+						changeCollector.finalize("failed");
+					},
+					memory: {
+						thread: identity.threadId,
+						resource: identity.resourceId
+					}
+				},
+				defaultOptions: {
+					activeTools: [...options.activeTools],
+					maxSteps,
+					...options.providerOptions ? { providerOptions: options.providerOptions } : {}
+				},
+				sendReasoning: options.sendReasoning ?? true,
+				messageMetadata: ({ part }) => {
+					recordTurnStreamPart(metrics, part);
+				},
+				onError: (error) => {
+					changeCollector.finalize("failed");
+					return handleStreamError(error);
+				}
+			});
+		} catch (error) {
+			changeCollector.finalize(request.signal.aborted ? "aborted" : "failed");
+			releaseRequestSlot();
+			return Response.json({ error: handleStreamError(error) }, { status: 503 });
+		}
+		return createUIMessageStreamResponse({ stream: createSurveyAssistantTurnStream({
+			stream,
+			changeCollector,
+			signal: request.signal,
+			onUnexpectedError: handleStreamError,
+			onSettled: () => {
+				releaseRequestSlot();
+				options.onTurnMetrics?.({
+					metrics,
+					provider: options.providerName,
+					turnId: changeCollector.turnId
+				});
+			}
+		}) });
+	};
+};
+//#endregion
+//#region src/server/thread-handlers.ts
+const DEFAULT_TITLE = "New chat";
+const MANUAL_TITLE_METADATA_KEY = "surveyAssistant.manualTitle";
+const AUTOMATIC_TITLE_METADATA_KEY = "surveyAssistant.automaticTitle";
+const getMetadataString = (metadata, key) => {
+	const value = metadata?.[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+};
+const getRawTitle = (thread) => thread.title?.trim() || DEFAULT_TITLE;
+const getAutomaticTitle = (thread, manualTitle) => {
+	const rawTitle = thread.title?.trim();
+	if (rawTitle && rawTitle !== manualTitle) return rawTitle;
+	return getMetadataString(thread.metadata, AUTOMATIC_TITLE_METADATA_KEY) ?? DEFAULT_TITLE;
+};
+const asThread = (thread) => {
+	const manualTitle = getMetadataString(thread.metadata, MANUAL_TITLE_METADATA_KEY);
+	return {
+		id: thread.id,
+		title: manualTitle ?? getRawTitle(thread),
+		titleMode: manualTitle ? "manual" : "automatic",
+		createdAt: thread.createdAt.toISOString(),
+		updatedAt: thread.updatedAt.toISOString()
+	};
+};
+const json = (body, status = 200) => Response.json(body, { status });
+const errorResponse = (error) => {
+	const message = error instanceof Error ? error.message : "The chat request could not be completed.";
+	const status = typeof error === "object" && error !== null && "status" in error && typeof error.status === "number" ? error.status : 400;
+	return json({
+		code: status === 401 || status === 403 ? "authorization_failed" : "request_failed",
+		error: message
+	}, status);
+};
+const ownsThread = (thread, identity) => thread.resourceId === identity.resourceId && Object.entries(identity.metadata).every(([key, value]) => thread.metadata?.[key] === value);
+const getOwnedThread = async (repository, identity, threadId) => {
+	const thread = await repository.get(threadId);
+	return thread && ownsThread(thread, identity) ? thread : null;
+};
+const createSurveyAssistantThreadHandlers = ({ authorize, repository }) => {
+	const list = async (request) => {
+		try {
+			const identity = await authorize(request);
+			return json({ threads: (await repository.list(identity.resourceId, identity.metadata)).filter((thread) => ownsThread(thread, identity) && typeof thread.metadata?.archivedAt !== "string").map(asThread) });
+		} catch (error) {
+			return errorResponse(error);
+		}
+	};
+	const create = async (request) => {
+		try {
+			const [identity, input] = await Promise.all([authorize(request), request.json().catch(() => ({}))]);
+			const parsed = createSurveyAssistantThreadInputSchema.parse(input);
+			const metadata = { ...identity.metadata };
+			if (parsed.title) {
+				metadata[MANUAL_TITLE_METADATA_KEY] = parsed.title;
+				metadata[AUTOMATIC_TITLE_METADATA_KEY] = DEFAULT_TITLE;
+			}
+			return json({ thread: asThread(await repository.create({
+				resourceId: identity.resourceId,
+				title: parsed.title ?? DEFAULT_TITLE,
+				metadata
+			})) }, 201);
+		} catch (error) {
+			return errorResponse(error);
+		}
+	};
+	const read = async (request, threadId) => {
+		try {
+			const identity = await authorize(request);
+			const thread = await getOwnedThread(repository, identity, threadId);
+			if (!thread || typeof thread.metadata?.archivedAt === "string") return json({ error: "Chat not found." }, 404);
+			return json({
+				thread: asThread(thread),
+				messages: await repository.readMessages(threadId, identity.resourceId)
+			});
+		} catch (error) {
+			return errorResponse(error);
+		}
+	};
+	const update = async (request, threadId) => {
+		try {
+			const [identity, input] = await Promise.all([authorize(request), request.json()]);
+			const thread = await getOwnedThread(repository, identity, threadId);
+			if (!thread || typeof thread.metadata?.archivedAt === "string") return json({ error: "Chat not found." }, 404);
+			const parsed = updateSurveyAssistantThreadInputSchema.parse(input);
+			const metadata = { ...thread.metadata ?? identity.metadata };
+			let title;
+			if (parsed.mode === "automatic") {
+				const manualTitle = getMetadataString(metadata, MANUAL_TITLE_METADATA_KEY);
+				title = parsed.title ?? (manualTitle ? getAutomaticTitle(thread, manualTitle) : getRawTitle(thread));
+				metadata[MANUAL_TITLE_METADATA_KEY] = null;
+				metadata[AUTOMATIC_TITLE_METADATA_KEY] = null;
+			} else {
+				const previousManualTitle = getMetadataString(metadata, MANUAL_TITLE_METADATA_KEY);
+				const automaticTitle = previousManualTitle ? getAutomaticTitle(thread, previousManualTitle) : getRawTitle(thread);
+				title = parsed.title;
+				metadata[MANUAL_TITLE_METADATA_KEY] = title;
+				metadata[AUTOMATIC_TITLE_METADATA_KEY] = automaticTitle;
+			}
+			return json({ thread: asThread(await repository.update({
+				id: thread.id,
+				title,
+				metadata
+			})) });
+		} catch (error) {
+			return errorResponse(error);
+		}
+	};
+	const deleteThread = async (request, threadId) => {
+		try {
+			const thread = await getOwnedThread(repository, await authorize(request), threadId);
+			if (!thread) return json({ error: "Chat not found." }, 404);
+			await repository.delete(thread.id);
+			return new Response(null, { status: 204 });
+		} catch (error) {
+			return errorResponse(error);
+		}
+	};
+	return {
+		create,
+		delete: deleteThread,
+		list,
+		read,
+		update
+	};
+};
+//#endregion
+//#region src/server/memory-thread-repository.ts
+const createMastraMemoryThreadRepository = ({ getMemory, threadDocuments }) => ({
+	async create({ metadata, resourceId, title }) {
+		return (await getMemory()).createThread({
+			metadata,
+			resourceId,
+			title,
+			saveThread: true
+		});
+	},
+	async get(threadId) {
+		return (await getMemory()).getThreadById({ threadId });
+	},
+	async list(resourceId, metadata) {
+		return (await (await getMemory()).listThreads({
+			filter: {
+				metadata,
+				resourceId
+			},
+			orderBy: {
+				field: "updatedAt",
+				direction: "DESC"
+			},
+			perPage: false
+		})).threads;
+	},
+	async readMessages(threadId, resourceId) {
+		return toAISdkMessages((await (await getMemory()).recall({
+			threadId,
+			resourceId,
+			perPage: false,
+			orderBy: {
+				field: "createdAt",
+				direction: "ASC"
+			}
+		})).messages, { version: "v6" });
+	},
+	async delete(threadId) {
+		const memory = await getMemory();
+		const thread = await memory.getThreadById({ threadId });
+		if (thread && threadDocuments) await threadDocuments.deleteThread({
+			resourceId: thread.resourceId,
+			threadId
+		});
+		await memory.deleteThread(threadId);
+	},
+	async update({ id, metadata, title }) {
+		return (await getMemory()).updateThread({
+			id,
+			metadata,
+			title
+		});
+	}
+});
+//#endregion
+export { describeSurveyAssistantStreamError as a, loadSurveyAssistantDocuments as c, removeHistoricalSurveyAssistantAttachments as d, createSurveyAssistantTurnStream as f, createSurveyAssistantChatHandler as i, loadSurveyAssistantThreadAttachments as l, createSurveyAssistantThreadHandlers as n, formatSurveyAssistantStreamError as o, SurveyAssistantAuthorizationError as r, getSurveyAssistantReplayableDocuments as s, createMastraMemoryThreadRepository as t, registerSurveyAssistantThreadAttachments as u };
+
+//# sourceMappingURL=memory-thread-repository-CJkkVE2-.mjs.map