@happyvertical/smrt-chat 0.53.2 → 0.53.4

package/dist/sveltekit.js

@@ -0,0 +1,765 @@
+import { i as clientRequestMessageId, n as ChatService, t as ChatClientRequestConflictError } from "./chunks/ChatService-Dl5tsK_F.js";
+import { D as runAssistantTurn, E as createSessionContinuationStore, j as MAX_CLIENT_TOOL_RESULT_CHARS, w as createAssistantTurnResponse, z as sanitizeClientToolDeclarations } from "./chunks/chat-stream-DigP1_dw.js";
+//#region src/sveltekit.ts
+var AssistantRouteError = class extends Error {
+	constructor(status, code, message) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "AssistantRouteError";
+	}
+	status;
+	code;
+};
+var DEFAULT_ASSISTANT_AGENT_ID = "smrt-assistant";
+var ASSISTANT_DOCK_SESSION_KEY = "assistant-dock";
+var DEFAULT_ASSISTANT_MAX_BODY_BYTES = 1024 * 1024;
+var DEFAULT_ASSISTANT_MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var MAX_TITLE_LENGTH = 200;
+var MAX_ATTACHMENTS_PER_MESSAGE = 10;
+var MAX_ID_LENGTH = 128;
+var CLIENT_REQUEST_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+var DEFAULT_ASSISTANT_ABANDONED_TURN_MS = 900 * 1e3;
+var GENERIC_ERROR = "The assistant request failed.";
+function resolveAssistantPrincipalFromLocals(locals) {
+	const record = locals ?? {};
+	const user = record.user;
+	const userId = nonEmpty(user?.id);
+	if (!user || !userId) return null;
+	const profileId = nonEmpty(user.profileId);
+	if (!profileId) throw new AssistantRouteError(403, "profile_required", "Your account has no profile, so it cannot use the assistant.");
+	const tenantId = nonEmpty(record.tenantId);
+	if (!tenantId) throw new AssistantRouteError(403, "tenant_required", "Select an organization to use the assistant.");
+	return {
+		userId,
+		profileId,
+		tenantId
+	};
+}
+function nonEmpty(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function json(body, status = 200, headers) {
+	const out = new Headers(headers);
+	out.set("content-type", "application/json; charset=utf-8");
+	out.set("cache-control", "no-store");
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: out
+	});
+}
+function errorResponse(error) {
+	return json({
+		error: error.message,
+		code: error.code
+	}, error.status);
+}
+var notFound = () => new AssistantRouteError(404, "not_found", "Conversation not found.");
+var badRequest = (message, code = "invalid_request") => new AssistantRouteError(400, code, message);
+async function resolveValue(value, context) {
+	if (typeof value === "function") return value(context);
+	return value;
+}
+async function readBounded(request, max) {
+	const declared = Number(request.headers.get("content-length"));
+	const tooLarge = () => new AssistantRouteError(413, "payload_too_large", "The request is too large.");
+	if (Number.isFinite(declared) && declared > max) throw tooLarge();
+	if (!request.body) return /* @__PURE__ */ new Uint8Array();
+	const reader = request.body.getReader();
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+		if (total > max) {
+			await reader.cancel().catch(() => void 0);
+			throw tooLarge();
+		}
+		chunks.push(value);
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+async function readJsonObject(request, max) {
+	const type = request.headers.get("content-type") ?? "";
+	if (!/^application\/json\b/i.test(type)) throw new AssistantRouteError(415, "unsupported_media_type", "Send JSON.");
+	const bytes = await readBounded(request, max);
+	let parsed;
+	try {
+		parsed = JSON.parse(new TextDecoder().decode(bytes));
+	} catch {
+		throw badRequest("The request body is not valid JSON.");
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw badRequest("The request body must be a JSON object.");
+	return parsed;
+}
+function requireId(value, label) {
+	if (typeof value !== "string" || value.length === 0 || value.length > MAX_ID_LENGTH) throw badRequest(`${label} is missing or invalid.`);
+	return value;
+}
+function originAllowed(request, url, trusted) {
+	const allowed = /* @__PURE__ */ new Set([url.origin, ...trusted]);
+	const origin = request.headers.get("origin");
+	if (origin) return allowed.has(origin);
+	const site = request.headers.get("sec-fetch-site")?.toLowerCase();
+	if (site) return site === "same-origin";
+	const referer = request.headers.get("referer");
+	if (referer) try {
+		return allowed.has(new URL(referer).origin);
+	} catch {
+		return false;
+	}
+	return false;
+}
+function toIso(value) {
+	if (value == null || value === "") return null;
+	const date = value instanceof Date ? value : new Date(String(value));
+	return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function parseObject(value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) return value;
+	if (typeof value !== "string" || value.length === 0) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function parseArray(value) {
+	if (Array.isArray(value)) return value;
+	if (typeof value !== "string" || value.length === 0) return [];
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed : [];
+	} catch {
+		return [];
+	}
+}
+function toAssistantThreadWire(thread) {
+	return {
+		id: String(thread.id),
+		title: thread.title ?? "",
+		isResolved: Boolean(thread.isResolved),
+		messageCount: Number(thread.messageCount) || 0,
+		lastMessageAt: toIso(thread.lastMessageAt)
+	};
+}
+function toAssistantMessageWire(message) {
+	const metadata = parseObject(message.metadata);
+	const toolCallData = parseObject(message.toolCallData);
+	const attachments = parseArray(message.attachments).map((entry) => {
+		const a = entry;
+		const id = nonEmpty(a?.id);
+		const name = nonEmpty(a?.filename) ?? nonEmpty(a?.name);
+		if (!id || !name) return null;
+		return {
+			id,
+			name,
+			contentType: nonEmpty(a?.contentType) ?? "application/octet-stream",
+			size: Number(a?.size) || 0,
+			...nonEmpty(a?.url) ? { url: a?.url } : {}
+		};
+	}).filter((a) => a !== null);
+	const clientRequestId = nonEmpty(metadata?.clientRequestId);
+	return {
+		id: String(message.id),
+		threadId: message.threadId ?? "",
+		content: message.content ?? "",
+		role: message.role,
+		createdAt: toIso(message.created_at) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+		...attachments.length > 0 ? { attachments } : {},
+		...toolCallData ? { toolCallData } : {},
+		...clientRequestId ? { clientRequestId } : {}
+	};
+}
+function isAuthorizationFailure(error) {
+	const message = error instanceof Error ? error.message : "";
+	return /authorization denied|not found|not active/i.test(message);
+}
+var ROUTE_METHODS = {
+	threads: ["GET", "POST"],
+	"thread-messages": ["GET", "POST"],
+	"thread-resume": ["POST"],
+	attachments: ["POST"],
+	actions: ["POST"]
+};
+function matchRoute(segments) {
+	const [a, b, c, ...rest] = segments;
+	if (rest.length > 0) return null;
+	if (a === "threads" && b === void 0) return { route: "threads" };
+	if (a === "threads" && b && c === "messages") return {
+		route: "thread-messages",
+		threadId: b
+	};
+	if (a === "threads" && b && c === "resume") return {
+		route: "thread-resume",
+		threadId: b
+	};
+	if (a === "attachments" && b === void 0) return { route: "attachments" };
+	if (a === "actions" && (b === "preview" || b === "apply") && !c) return {
+		route: "actions",
+		phase: b
+	};
+	return null;
+}
+function mountAssistantRoutes(options) {
+	if (!options?.ai) throw new Error("mountAssistantRoutes: `ai` is required (an AI client or a factory).");
+	const agentId = options.agentId ?? "smrt-assistant";
+	const paramName = options.paramName ?? "path";
+	const maxBody = options.maxBodyBytes ?? 1048576;
+	const maxContent = options.maxContentLength ?? 12e3;
+	const historyLimit = Math.max(0, options.historyLimit ?? 20);
+	const checkOrigin = options.checkOrigin ?? true;
+	const trustedOrigins = options.trustedOrigins ?? [];
+	const resolvePrincipal = options.resolvePrincipal ?? ((event) => resolveAssistantPrincipalFromLocals(event.locals));
+	const logError = options.onError ?? ((error) => {
+		console.error("[smrt-chat] assistant route failed:", error);
+	});
+	const safeLog = (error) => {
+		try {
+			logError(error);
+		} catch {}
+	};
+	const abandonedTurnMs = options.abandonedTurnMs ?? 9e5;
+	const segmentsOf = (event) => {
+		const param = event.params?.[paramName];
+		let path = typeof param === "string" ? param : void 0;
+		if (path === void 0 && options.basePath) {
+			const base = options.basePath.replace(/\/+$/, "");
+			const pathname = event.url.pathname;
+			if (pathname === base || pathname.startsWith(`${base}/`)) path = pathname.slice(base.length);
+		}
+		if (path === void 0) return null;
+		return path.split("/").filter((segment) => segment.length > 0);
+	};
+	const chatFor = async (principal) => {
+		const chat = await ChatService.create({
+			tenantId: principal.tenantId,
+			...options.db ? { db: options.db } : {}
+		});
+		await chat.initialize();
+		return chat;
+	};
+	const findSession = async (chat, principal) => {
+		return (await chat.findActiveAgentSessions({
+			tenantId: principal.tenantId,
+			agentId,
+			participantProfileId: principal.profileId
+		})).find((session) => session.getSessionKey() === "assistant-dock" && session.participantProfileId === principal.profileId && session.tenantId === principal.tenantId && Boolean(session.chatRoomId)) ?? null;
+	};
+	const requireOwnThread = async (chat, principal, session, threadId) => {
+		if (!session?.chatRoomId) throw notFound();
+		const thread = await chat.getThread({
+			threadId,
+			tenantId: principal.tenantId
+		});
+		if (!thread || thread.roomId !== session.chatRoomId || thread.tenantId !== principal.tenantId) throw notFound();
+		return thread;
+	};
+	const allowedToolsFor = async (context) => {
+		const list = await resolveValue(options.allowedTools, context);
+		return Array.isArray(list) ? list.filter((tool) => typeof tool === "string" && tool.length > 0) : [];
+	};
+	const resolveModel = (requested) => {
+		if (requested === void 0 || requested === null || requested === "") return options.defaultModel;
+		if (typeof requested !== "string" || requested.length > MAX_ID_LENGTH) throw badRequest("The model is invalid.", "model_not_allowed");
+		if (!options.models || options.models.length === 0) return options.defaultModel;
+		if (!options.models.some((model) => model.id === requested)) throw badRequest("That model is not available.", "model_not_allowed");
+		return requested;
+	};
+	const resolveAI = async (context, model) => {
+		try {
+			const ai = typeof options.ai === "function" ? await options.ai({
+				...context,
+				...model ? { model } : {}
+			}) : options.ai;
+			if (!ai || typeof ai.chat !== "function") throw new Error("The AI factory returned no client.");
+			return ai;
+		} catch (error) {
+			safeLog(error);
+			throw new AssistantRouteError(503, "assistant_unavailable", "The assistant is unavailable right now. Please try again later.");
+		}
+	};
+	const continuationStoreFor = (context, chat, session) => {
+		if (options.continuations) return options.continuations({
+			...context,
+			session
+		});
+		const { principal } = context;
+		return createSessionContinuationStore(async () => {
+			const current = await chat.getAgentSession({
+				agentSessionId: String(session.id),
+				tenantId: principal.tenantId
+			});
+			return current && current.participantProfileId === principal.profileId && current.isActive() ? current : null;
+		});
+	};
+	const turnSetup = async (context, chat, session, thread, body) => {
+		const { principal } = context;
+		const model = resolveModel(body.model);
+		const allowedTools = await allowedToolsFor(context);
+		const clientTools = sanitizeClientToolDeclarations(body.clientTools, options.clientToolAllowList ?? []);
+		const ai = await resolveAI(context, model);
+		const [extraTools, tools, systemPrompt] = await Promise.all([
+			resolveValue(options.extraTools, context),
+			resolveValue(options.tools, context),
+			resolveValue(options.systemPrompt, context)
+		]);
+		if (options.authorInvocation) {
+			const current = session.getAllowedTools();
+			if (current.length !== allowedTools.length || current.some((tool, index) => tool !== allowedTools[index])) await chat.updateAgentSessionConfig({
+				agentSessionId: String(session.id),
+				actorProfileId: principal.profileId,
+				tenantId: principal.tenantId,
+				allowedTools
+			});
+		}
+		const continuations = continuationStoreFor(context, chat, session);
+		const abort = new AbortController();
+		const requestSignal = context.event.request.signal;
+		if (requestSignal.aborted) abort.abort();
+		else requestSignal.addEventListener("abort", () => abort.abort(), { once: true });
+		return {
+			abort,
+			ai,
+			model,
+			clientTools,
+			continuations,
+			continuationKey: String(thread.id),
+			turn: {
+				ai,
+				principal: {
+					runAsUserId: principal.userId,
+					tenantId: principal.tenantId,
+					allowedTools
+				},
+				...options.db ? { db: options.db } : {},
+				...systemPrompt ? { systemPrompt } : {},
+				extraTools: [...extraTools ?? []],
+				tools: [...tools ?? []],
+				clientTools,
+				continuations,
+				continuationKey: String(thread.id),
+				...model ? { model } : {},
+				...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
+				...options.maxTurnTokens !== void 0 ? { maxTurnTokens: options.maxTurnTokens } : {},
+				...options.maxTurnMs !== void 0 ? { maxTurnMs: options.maxTurnMs } : {},
+				...options.maxTokens !== void 0 ? { maxTokens: options.maxTokens } : {},
+				...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+				...principal.permissions ? { permissions: principal.permissions } : {},
+				...options.audit ? { audit: options.audit } : {},
+				...options.postgresRls !== void 0 ? { postgresRls: options.postgresRls } : {},
+				onBehalfOfUserId: principal.userId,
+				signal: abort.signal,
+				...options.onUsage ? { onUsage: (usage) => {
+					try {
+						options.onUsage?.(usage, context);
+					} catch (error) {
+						safeLog(error);
+					}
+				} } : {},
+				...options.describeTool ? { describeTool: options.describeTool } : {},
+				onError: safeLog,
+				serializeMessage: (message) => toAssistantMessageWire(message),
+				author: {
+					chatService: chat,
+					agentSessionId: String(session.id),
+					tenantId: principal.tenantId,
+					threadId: String(thread.id),
+					...options.authorInvocation ? { authorInvocation: options.authorInvocation } : {}
+				}
+			}
+		};
+	};
+	const stream = (events, abort) => createAssistantTurnResponse(events, {
+		...options.heartbeatMs !== void 0 ? { heartbeatMs: options.heartbeatMs } : {},
+		onError: safeLog,
+		onCancel: () => abort.abort()
+	});
+	const listThreads = async (context) => {
+		const chat = await chatFor(context.principal);
+		const session = await findSession(chat, context.principal);
+		if (!session?.chatRoomId) return json({ items: [] });
+		return json({ items: (await chat.listRoomThreads({
+			roomId: session.chatRoomId,
+			actorProfileId: context.principal.profileId,
+			tenantId: context.principal.tenantId
+		})).map(toAssistantThreadWire) });
+	};
+	const createThread = async (context) => {
+		const body = await readJsonObject(context.event.request, maxBody);
+		const title = typeof body.title === "string" ? body.title.trim() : "";
+		if (!title || title.length > MAX_TITLE_LENGTH) throw badRequest(`A title of 1 to ${MAX_TITLE_LENGTH} characters is required.`);
+		const { principal } = context;
+		const chat = await chatFor(principal);
+		const allowedTools = await allowedToolsFor(context);
+		const { session } = await chat.createAgentSession({
+			tenantId: principal.tenantId,
+			agentId,
+			actorProfileId: principal.profileId,
+			allowedTools,
+			sessionKey: ASSISTANT_DOCK_SESSION_KEY
+		});
+		if (!session.chatRoomId) throw new Error("Assistant session has no room");
+		return json({ thread: toAssistantThreadWire(await chat.startThread({
+			tenantId: principal.tenantId,
+			roomId: session.chatRoomId,
+			actorProfileId: principal.profileId,
+			title
+		})) }, 201);
+	};
+	const loadMessages = async (context, threadId) => {
+		const { principal } = context;
+		const chat = await chatFor(principal);
+		const session = await findSession(chat, principal);
+		await requireOwnThread(chat, principal, session, threadId);
+		return json({ items: (await chat.getThreadMessages({
+			threadId,
+			actorProfileId: principal.profileId,
+			tenantId: principal.tenantId,
+			limit: 200
+		})).map(toAssistantMessageWire) });
+	};
+	const reservationAnswer = async (context, chat, session, threadId, messageId) => {
+		const { principal } = context;
+		const stored = await chat.getThreadMessageReplies({
+			threadId,
+			messageId,
+			actorProfileId: principal.profileId,
+			tenantId: principal.tenantId
+		});
+		const anchor = stored?.message;
+		if (!stored || anchor?.role !== "user" || anchor.senderProfileId !== principal.profileId) return null;
+		const userMessage = toAssistantMessageWire(anchor);
+		const after = stored.replies.map(toAssistantMessageWire);
+		const assistantMessage = [...after].reverse().find((message) => message.role === "assistant");
+		const answer = (outcome) => {
+			return json({
+				duplicate: true,
+				inProgress: outcome === "in_progress",
+				outcome,
+				userMessage,
+				...assistantMessage ? { assistantMessage } : {},
+				messages: after
+			}, 200);
+		};
+		const turnFailed = () => new AssistantRouteError(409, "turn_failed", "The assistant could not answer this message. Send it again.");
+		const metadata = parseObject(anchor.metadata) ?? {};
+		const recorded = metadata.turnOutcome;
+		if (assistantMessage) return answer("completed");
+		if (recorded === "failed") throw turnFailed();
+		if (recorded === "cancelled") return answer("cancelled");
+		if (recorded === "completed") return answer("completed");
+		if (recorded === "suspended") {
+			const continuationId = nonEmpty(metadata.turnContinuationId);
+			if (!continuationId) throw turnFailed();
+			const store = continuationStoreFor(context, chat, session);
+			if (!(store.has ? await store.has(threadId, continuationId) : Date.now() - new Date(String(metadata.turnSettledAt)).getTime() <= 9e5)) throw turnFailed();
+			return answer("in_progress");
+		}
+		const since = recorded === "running" ? metadata.turnSettledAt : anchor.created_at;
+		const age = Date.now() - new Date(String(since)).getTime();
+		if (Number.isFinite(age) && age > abandonedTurnMs) throw turnFailed();
+		return answer("in_progress");
+	};
+	const settleOutcome = (chat, principal, threadId, messageId) => async (outcome, settings = {}) => {
+		try {
+			await chat.recordClientRequestOutcome({
+				tenantId: principal.tenantId,
+				threadId,
+				messageId,
+				actorProfileId: principal.profileId,
+				outcome,
+				resumedFrom: null
+			});
+		} catch (error) {
+			if (!settings.quiet) safeLog(error);
+		}
+	};
+	const recordTurnState = (chat, principal, threadId) => async (state) => {
+		if (!state.originMessageId) return true;
+		return chat.recordClientRequestOutcome({
+			tenantId: principal.tenantId,
+			threadId,
+			messageId: state.originMessageId,
+			actorProfileId: principal.profileId,
+			outcome: state.state,
+			resumedFrom: state.resumedFrom,
+			continuationId: state.continuationId ?? null
+		});
+	};
+	const sendMessage = async (context, threadId) => {
+		const body = await readJsonObject(context.event.request, maxBody);
+		const content = typeof body.content === "string" ? body.content.trim() : "";
+		if (!content) throw badRequest("The message is empty.", "empty_message");
+		if (content.length > maxContent) throw new AssistantRouteError(413, "message_too_long", `Messages are limited to ${maxContent} characters.`);
+		const clientRequestId = body.clientRequestId;
+		if (typeof clientRequestId !== "string" || !CLIENT_REQUEST_ID.test(clientRequestId)) throw badRequest("clientRequestId is missing or invalid.");
+		const references = body.attachments;
+		if (references !== void 0 && references !== null && (!Array.isArray(references) || references.length > MAX_ATTACHMENTS_PER_MESSAGE)) throw badRequest("attachments must be a short list.");
+		const hasAttachments = Array.isArray(references) && references.length > 0;
+		if (hasAttachments && !options.attachments) throw badRequest("This assistant does not accept attachments.", "attachments_unsupported");
+		resolveModel(body.model);
+		const { principal } = context;
+		const chat = await chatFor(principal);
+		const session = await findSession(chat, principal);
+		const thread = await requireOwnThread(chat, principal, session, threadId);
+		if (!session?.chatRoomId) throw notFound();
+		const reservationId = clientRequestMessageId({
+			tenantId: principal.tenantId,
+			roomId: session.chatRoomId,
+			threadId,
+			actorProfileId: principal.profileId,
+			clientRequestId
+		});
+		const known = await reservationAnswer(context, chat, session, threadId, reservationId);
+		if (known) return known;
+		let attachments = null;
+		if (hasAttachments && options.attachments) {
+			const verified = await options.attachments.verify(references, context);
+			if (!verified || verified.length !== references.length) throw badRequest("An attachment could not be found.", "attachment_not_found");
+			attachments = verified.map((record) => ({
+				id: record.id,
+				filename: record.name,
+				contentType: record.contentType,
+				size: record.size,
+				...record.url ? { url: record.url } : {}
+			}));
+		}
+		const setup = await turnSetup(context, chat, session, thread, body);
+		const recordFailure = settleOutcome(chat, principal, threadId, reservationId);
+		let userMessage;
+		try {
+			userMessage = await chat.sendMessage({
+				tenantId: principal.tenantId,
+				roomId: session.chatRoomId,
+				threadId,
+				actorProfileId: principal.profileId,
+				agentSessionId: String(session.id),
+				content,
+				clientRequestId,
+				attachments
+			});
+		} catch (error) {
+			if (error instanceof ChatClientRequestConflictError) {
+				const answer = await reservationAnswer(context, chat, session, threadId, reservationId);
+				if (answer) return answer;
+			} else await recordFailure("failed", { quiet: true });
+			throw error;
+		}
+		const userWire = toAssistantMessageWire(userMessage);
+		try {
+			const history = [];
+			if (historyLimit > 0) {
+				const earlier = await chat.getThreadMessages({
+					threadId,
+					actorProfileId: principal.profileId,
+					tenantId: principal.tenantId,
+					limit: historyLimit + 1
+				});
+				for (const message of earlier) {
+					if (String(message.id) === userWire.id) continue;
+					if (message.role !== "user" && message.role !== "assistant") continue;
+					if (!message.content) continue;
+					history.push({
+						role: message.role,
+						content: message.content
+					});
+				}
+			}
+			const events = runAssistantTurn({
+				...setup.turn,
+				history: history.slice(-historyLimit),
+				userMessage: content,
+				originMessageId: userWire.id,
+				onState: recordTurnState(chat, principal, threadId)
+			});
+			return stream(detached({
+				type: "message",
+				message: userWire
+			}, events), setup.abort);
+		} catch (error) {
+			await recordFailure("failed");
+			throw error;
+		}
+	};
+	const resumeTurn = async (context, threadId) => {
+		const body = await readJsonObject(context.event.request, maxBody);
+		const continuationId = requireId(body.continuationId, "continuationId");
+		if (!Array.isArray(body.results) || body.results.length > 64) throw badRequest("results must be a list of tool results.");
+		const results = body.results.map((raw) => {
+			const entry = raw;
+			if (!entry || typeof entry !== "object") throw badRequest("Each result must be an object.");
+			const id = requireId(entry.id, "result id");
+			if (typeof entry.ok !== "boolean") throw badRequest("Each result needs an ok flag.");
+			const result = typeof entry.result === "string" ? entry.result.slice(0, MAX_CLIENT_TOOL_RESULT_CHARS) : void 0;
+			const error = typeof entry.error === "string" ? entry.error.slice(0, 500) : void 0;
+			return {
+				id,
+				ok: entry.ok,
+				...result !== void 0 ? { result } : {},
+				...error !== void 0 ? { error } : {}
+			};
+		});
+		resolveModel(body.model);
+		const { principal } = context;
+		const chat = await chatFor(principal);
+		const session = await findSession(chat, principal);
+		const thread = await requireOwnThread(chat, principal, session, threadId);
+		if (!session) throw notFound();
+		const setup = await turnSetup(context, chat, session, thread, body);
+		return stream(detached(null, runAssistantTurn({
+			...setup.turn,
+			resume: {
+				continuationId,
+				results
+			},
+			onState: recordTurnState(chat, principal, threadId)
+		})), setup.abort);
+	};
+	const uploadAttachment = async (context) => {
+		const storage = options.attachments;
+		if (!storage) throw new AssistantRouteError(404, "attachments_unsupported", "This assistant does not accept attachments.");
+		const request = context.event.request;
+		const type = request.headers.get("content-type") ?? "";
+		if (!/^multipart\/form-data\b/i.test(type)) throw new AssistantRouteError(415, "unsupported_media_type", "Upload a file as multipart/form-data.");
+		const maxBytes = storage.maxBytes ?? 10485760;
+		const bytes = await readBounded(request, maxBytes + 64 * 1024);
+		let form;
+		try {
+			form = await new Response(bytes, { headers: { "content-type": type } }).formData();
+		} catch {
+			throw badRequest("The upload could not be read.");
+		}
+		const file = form.get("file");
+		if (!file || typeof file === "string") throw badRequest("Attach the upload as the `file` field.");
+		if (file.size > maxBytes) throw new AssistantRouteError(413, "payload_too_large", "The file is too large.");
+		const record = await storage.upload(file, context);
+		return json({ attachment: {
+			id: record.id,
+			name: record.name,
+			contentType: record.contentType,
+			size: record.size,
+			...record.url ? { url: record.url } : {}
+		} }, 201);
+	};
+	const runAction = async (context, phase) => {
+		if (!options.actions) throw new AssistantRouteError(404, "actions_unsupported", "This assistant has no actions.");
+		const body = await readJsonObject(context.event.request, maxBody);
+		if (body.phase !== phase) throw badRequest(`Expected a ${phase} request.`);
+		const adapter = await resolveValue(options.actions.adapter, context);
+		if (!adapter) throw new Error("No data-surface action adapter resolved.");
+		const { principal } = context;
+		const allowedTools = await allowedToolsFor(context);
+		const actionContext = { principal: {
+			...options.db ? { db: options.db } : {},
+			principal: {
+				runAsUserId: principal.userId,
+				tenantId: principal.tenantId,
+				allowedTools
+			},
+			onBehalfOfUserId: principal.userId,
+			...principal.permissions ? { permissions: principal.permissions } : {},
+			...options.audit ? { audit: options.audit } : {},
+			...options.postgresRls !== void 0 ? { postgresRls: options.postgresRls } : {}
+		} };
+		const request = body;
+		try {
+			return json({ result: phase === "preview" ? await adapter.preview(request, actionContext) : await adapter.apply(request, actionContext) });
+		} catch (error) {
+			safeLog(error);
+			return json({
+				error: phase === "apply" ? "The change may or may not have been applied. Check again." : GENERIC_ERROR,
+				code: phase === "apply" ? "outcome_unknown" : "internal_error"
+			}, 500);
+		}
+	};
+	const handle = async (event) => {
+		try {
+			const segments = segmentsOf(event);
+			const match = segments ? matchRoute(segments) : null;
+			if (!match) throw new AssistantRouteError(404, "not_found", "Not found.");
+			const method = event.request.method.toUpperCase();
+			const allowed = ROUTE_METHODS[match.route];
+			if (!allowed.includes(method)) return json({
+				error: "Method not allowed.",
+				code: "method_not_allowed"
+			}, 405, { allow: allowed.join(", ") });
+			if (method !== "GET" && checkOrigin && !originAllowed(event.request, event.url, trustedOrigins)) throw new AssistantRouteError(403, "invalid_origin", "Invalid request origin.");
+			const principal = await resolvePrincipal(event);
+			if (!principal) throw new AssistantRouteError(401, "unauthenticated", "Sign in to use the assistant.");
+			if (!nonEmpty(principal.userId) || !nonEmpty(principal.profileId) || !nonEmpty(principal.tenantId)) throw new AssistantRouteError(403, "principal_incomplete", "Your session cannot use the assistant.");
+			const context = {
+				event,
+				principal
+			};
+			switch (match.route) {
+				case "threads": return method === "GET" ? await listThreads(context) : await createThread(context);
+				case "thread-messages": {
+					const threadId = requireId(match.threadId, "thread id");
+					return method === "GET" ? await loadMessages(context, threadId) : await sendMessage(context, threadId);
+				}
+				case "thread-resume": return await resumeTurn(context, requireId(match.threadId, "thread id"));
+				case "attachments": return await uploadAttachment(context);
+				case "actions": return await runAction(context, match.phase);
+			}
+		} catch (error) {
+			if (error instanceof AssistantRouteError) return errorResponse(error);
+			if (isAuthorizationFailure(error)) return errorResponse(notFound());
+			safeLog(error);
+			return json({
+				error: GENERIC_ERROR,
+				code: "internal_error"
+			}, 500);
+		}
+	};
+	return {
+		GET: handle,
+		POST: handle,
+		handle
+	};
+}
+function detached(first, events) {
+	const buffer = first ? [first] : [];
+	let finished = false;
+	let notify = null;
+	const wake = () => {
+		const resume = notify;
+		notify = null;
+		resume?.();
+	};
+	(async () => {
+		try {
+			for await (const event of events) {
+				buffer.push(event);
+				wake();
+			}
+		} catch {} finally {
+			finished = true;
+			wake();
+		}
+	})();
+	return (async function* () {
+		for (;;) {
+			if (buffer.length > 0) {
+				yield buffer.shift();
+				continue;
+			}
+			if (finished) return;
+			await new Promise((resolve) => {
+				notify = resolve;
+			});
+		}
+	})();
+}
+//#endregion
+export { ASSISTANT_DOCK_SESSION_KEY, AssistantRouteError, DEFAULT_ASSISTANT_ABANDONED_TURN_MS, DEFAULT_ASSISTANT_AGENT_ID, DEFAULT_ASSISTANT_MAX_ATTACHMENT_BYTES, DEFAULT_ASSISTANT_MAX_BODY_BYTES, mountAssistantRoutes, resolveAssistantPrincipalFromLocals, toAssistantMessageWire, toAssistantThreadWire };
+
+//# sourceMappingURL=sveltekit.js.map