@happyvertical/smrt-chat 0.53.3 → 0.53.5

package/dist/sveltekit.js

@@ -0,0 +1,973 @@
+import { i as clientRequestMessageId, n as ChatService, t as ChatClientRequestConflictError } from "./chunks/ChatService-Dl5tsK_F.js";
+import { D as runAssistantTurn, E as createSessionContinuationStore, P as buildManifestToolCatalog, j as MAX_CLIENT_TOOL_RESULT_CHARS, v as ASSISTANT_TURN_GENERIC_ERROR, w as createAssistantTurnResponse, z as sanitizeClientToolDeclarations } from "./chunks/chat-stream-DJQO6uHe.js";
+import { getCurrentSessionPermissionContext, getRequestScopedDatabase } from "@happyvertical/smrt-users";
+import { getConfig, loadConfig, resolveConfiguredAIProvider, toAIClientOptions } from "@happyvertical/smrt-config";
+//#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;
+}
+var configLoad;
+async function configuredAssistantAI() {
+	if (getConfig() === null) {
+		configLoad ??= loadConfig().catch((error) => {
+			configLoad = void 0;
+			throw error;
+		});
+		await configLoad;
+	}
+	const options = toAIClientOptions(resolveConfiguredAIProvider());
+	const { getAI } = await import("@happyvertical/ai");
+	return getAI(options);
+}
+function unprovidedToolNames(requested, offered, registeredOnly) {
+	const provided = new Set(offered.map((tool) => tool.slug));
+	const missing = requested.filter((name) => !provided.has(name));
+	if (!registeredOnly || missing.length === 0) return missing;
+	const collections = new Set(buildManifestToolCatalog({ all: true }).map((tool) => tool.collection));
+	return missing.filter((name) => {
+		const dot = name.lastIndexOf(".");
+		return dot > 0 && collections.has(name.slice(0, dot));
+	});
+}
+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 ("ai" in options && options.ai == null) throw new Error("mountAssistantRoutes: `ai` was passed but is empty. Pass an AI client or a factory, or omit `ai` to use the smrt.config `ai` block.");
+	const aiSource = options.ai ?? configuredAssistantAI;
+	if (options.tools === void 0 && !options.actions && Array.isArray(options.allowedTools) && typeof options.extraTools !== "function") {
+		const extra = new Set((options.extraTools ?? []).map((tool) => tool.slug));
+		const requested = options.allowedTools.filter((name) => typeof name === "string" && name.length > 0 && !extra.has(name));
+		if (requested.length > 0) {
+			const unknown = unprovidedToolNames(requested, buildManifestToolCatalog({ allowedTools: requested }), true);
+			if (unknown.length > 0) throw new Error(`mountAssistantRoutes: allowedTools names ${unknown.join(", ")}, which no manifest operation or extraTools entry provides.`);
+		}
+	}
+	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 turnStartTimeoutMs = options.turnStartTimeoutMs ?? 6e4;
+	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 runtime = options.runtime;
+	const dbOption = options.db !== void 0 || !runtime ? options.db : () => runtime.databaseConfig();
+	const requestDbs = /* @__PURE__ */ new WeakMap();
+	const dbFor = (context) => {
+		let db = requestDbs.get(context);
+		if (!db) {
+			db = resolveValue(dbOption, context);
+			requestDbs.set(context, db);
+		}
+		return db;
+	};
+	const chatFor = async (context) => {
+		const db = await dbFor(context);
+		const chat = await ChatService.create({
+			tenantId: context.principal.tenantId,
+			...db ? { 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 aiSource === "function" ? await aiSource({
+				...context,
+				...model ? { model } : {}
+			}) : aiSource;
+			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 manifestToolsFor = async (context, allowedTools, extraTools, db) => {
+		if (options.tools !== void 0) return await resolveValue(options.tools, context) ?? [];
+		const extra = new Set(extraTools.map((tool) => tool.slug));
+		const requested = allowedTools.filter((name) => !extra.has(name));
+		if (requested.length === 0) return [];
+		const tools = buildManifestToolCatalog({
+			...db ? { db } : {},
+			allowedTools: requested
+		});
+		if (!options.actions) {
+			const unknown = unprovidedToolNames(requested, tools, false);
+			if (unknown.length > 0) {
+				safeLog(/* @__PURE__ */ new Error(`mountAssistantRoutes: allowedTools names ${unknown.join(", ")}, which no manifest operation or extraTools entry provides.`));
+				throw new AssistantRouteError(503, "assistant_unavailable", "The assistant is unavailable right now. Please try again later.");
+			}
+		}
+		return tools;
+	};
+	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 prepareTurn = async (context, body) => {
+		const model = resolveModel(body.model);
+		const allowedTools = await allowedToolsFor(context);
+		const clientTools = sanitizeClientToolDeclarations(body.clientTools, options.clientToolAllowList ?? []);
+		const ai = await resolveAI(context, model);
+		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,
+			allowedTools,
+			clientTools
+		};
+	};
+	const turnSetup = async (context, chat, session, thread, prepared, mirror = true) => {
+		const { principal } = context;
+		const { abort, ai, model, allowedTools, clientTools } = prepared;
+		const [extraTools, systemPrompt, db] = await Promise.all([
+			resolveValue(options.extraTools, context),
+			resolveValue(options.systemPrompt, context),
+			dbFor(context)
+		]);
+		const tools = await manifestToolsFor(context, allowedTools, extraTools ?? [], db);
+		if (options.authorInvocation && mirror) {
+			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);
+		return {
+			abort,
+			ai,
+			model,
+			clientTools,
+			continuations,
+			continuationKey: String(thread.id),
+			turn: {
+				ai,
+				principal: {
+					runAsUserId: principal.userId,
+					tenantId: principal.tenantId,
+					allowedTools
+				},
+				...db ? { 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 respondWithTurn = async (context, chat, session, thread, prepared, setup, first, start, durableSend) => {
+		const transaction = requestTransaction();
+		if (!transaction) return stream(detached(first, pump(start(chat, setup))).events, prepared.abort);
+		const isActive = transaction.isActive;
+		if (!runtime || typeof isActive !== "function") {
+			const turn = detached(first, pump(start(chat, setup)));
+			await turn.settled;
+			return stream(turn.events, prepared.abort);
+		}
+		const { principal } = context;
+		const bound = {
+			id: principal.userId,
+			tenantId: principal.tenantId,
+			scopes: Object.freeze([...principal.permissions ?? getCurrentSessionPermissionContext()?.permissions ?? []])
+		};
+		const settleFailed = async (messageId, onlyIfStored = false) => {
+			try {
+				await runtime.runAsPrincipal(bound, async () => {
+					const settleChat = await chatFor({
+						event: context.event,
+						principal
+					});
+					if (onlyIfStored) {
+						if (!(await settleChat.getThreadMessageReplies({
+							threadId: String(thread.id),
+							messageId,
+							actorProfileId: principal.profileId,
+							tenantId: principal.tenantId
+						}))?.message) return;
+					}
+					await settleOutcome(settleChat, principal, String(thread.id), messageId)("failed");
+				});
+			} catch (settleError) {
+				safeLog(settleError);
+			}
+		};
+		const settleLateSend = async (requestActive, messageId) => {
+			try {
+				if (await requestEnded(requestActive, abandonedTurnMs)) await settleFailed(messageId, true);
+				else safeLog(/* @__PURE__ */ new Error("mountAssistantRoutes: the request transaction never ended; its send was not settled."));
+			} catch (error) {
+				safeLog(error);
+			}
+		};
+		const ownLifetime = async (emit) => {
+			const held = [];
+			let sendConfirmed = false;
+			const requestActive = () => isActive.call(transaction);
+			try {
+				if (!await requestEnded(requestActive, turnStartTimeoutMs)) {
+					if (durableSend) settleLateSend(requestActive, durableSend);
+					throw new Error("mountAssistantRoutes: the request transaction did not end; the turn did not run.");
+				}
+				await runtime.runAsPrincipal(bound, async (granted) => {
+					const turnContext = {
+						event: context.event,
+						principal: {
+							...principal,
+							permissions: effectiveScopes(granted, bound.scopes)
+						}
+					};
+					const turnChat = await chatFor(turnContext);
+					if (durableSend) {
+						if (!(await turnChat.getThreadMessageReplies({
+							threadId: String(thread.id),
+							messageId: durableSend,
+							actorProfileId: principal.profileId,
+							tenantId: principal.tenantId
+						}))?.message) throw new Error("mountAssistantRoutes: the send was not stored; the turn did not run.");
+						sendConfirmed = true;
+					}
+					const turnSetupInLifetime = await turnSetup(turnContext, turnChat, session, thread, prepared, false);
+					for await (const event of start(turnChat, turnSetupInLifetime)) if (held.length > 0 || HELD_UNTIL_COMMIT.has(event.type)) held.push(event);
+					else emit(event);
+				});
+				for (const event of held) emit(event);
+			} catch (error) {
+				safeLog(error);
+				if (durableSend && sendConfirmed) await settleFailed(durableSend);
+				emit({
+					type: "error",
+					error: ASSISTANT_TURN_GENERIC_ERROR,
+					code: "internal_error"
+				});
+				emit({
+					type: "status",
+					status: {
+						state: "error",
+						label: ASSISTANT_TURN_GENERIC_ERROR
+					}
+				});
+			}
+		};
+		return stream(detached(first, ownLifetime).events, prepared.abort);
+	};
+	const listThreads = async (context) => {
+		const chat = await chatFor(context);
+		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(context);
+		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(context);
+		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(context);
+		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 prepared = await prepareTurn(context, body);
+		const setup = await turnSetup(context, chat, session, thread, prepared);
+		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 transcript = history.slice(-historyLimit);
+			return await respondWithTurn(context, chat, session, thread, prepared, setup, {
+				type: "message",
+				message: userWire
+			}, (turnChat, turnSetupFor) => runAssistantTurn({
+				...turnSetupFor.turn,
+				history: transcript,
+				userMessage: content,
+				originMessageId: userWire.id,
+				onState: recordTurnState(turnChat, principal, threadId)
+			}), userWire.id);
+		} 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(context);
+		const session = await findSession(chat, principal);
+		const thread = await requireOwnThread(chat, principal, session, threadId);
+		if (!session) throw notFound();
+		const prepared = await prepareTurn(context, body);
+		const setup = await turnSetup(context, chat, session, thread, prepared);
+		return respondWithTurn(context, chat, session, thread, prepared, setup, null, (turnChat, turnSetupFor) => runAssistantTurn({
+			...turnSetupFor.turn,
+			resume: {
+				continuationId,
+				results
+			},
+			onState: recordTurnState(turnChat, principal, threadId)
+		}));
+	};
+	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 db = await dbFor(context);
+		const actionContext = { principal: {
+			...db ? { 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
+	};
+}
+var HELD_UNTIL_COMMIT = /* @__PURE__ */ new Set([
+	"client_tool_calls",
+	"done",
+	"error"
+]);
+var DEFAULT_ASSISTANT_TURN_START_TIMEOUT_MS = 6e4;
+function requestTransaction() {
+	if (getCurrentSessionPermissionContext()?.postgresRls !== true) return null;
+	return getRequestScopedDatabase() ?? null;
+}
+function effectiveScopes(granted, cap) {
+	const scopes = granted?.scopes;
+	if (!Array.isArray(scopes) || !scopes.every((scope) => typeof scope === "string")) throw new Error("mountAssistantRoutes: runtime.runAsPrincipal bound no effective scopes.");
+	const allowed = cap ? new Set(cap) : void 0;
+	return scopes.filter((scope) => !allowed || allowed.has(scope));
+}
+async function requestEnded(isActive, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	let delay = 2;
+	while (isActive()) {
+		if (Date.now() >= deadline) return false;
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		delay = Math.min(delay * 2, 50);
+	}
+	return true;
+}
+function pump(events) {
+	return async (emit) => {
+		for await (const event of events) emit(event);
+	};
+}
+function detached(first, produce) {
+	const buffer = first ? [first] : [];
+	let finished = false;
+	let notify = null;
+	const wake = () => {
+		const resume = notify;
+		notify = null;
+		resume?.();
+	};
+	const settled = (async () => {
+		try {
+			await produce((event) => {
+				buffer.push(event);
+				wake();
+			});
+		} catch {} finally {
+			finished = true;
+			wake();
+		}
+	})();
+	return {
+		events: (async function* () {
+			for (;;) {
+				if (buffer.length > 0) {
+					yield buffer.shift();
+					continue;
+				}
+				if (finished) return;
+				await new Promise((resolve) => {
+					notify = resolve;
+				});
+			}
+		})(),
+		settled
+	};
+}
+//#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, DEFAULT_ASSISTANT_TURN_START_TIMEOUT_MS, mountAssistantRoutes, resolveAssistantPrincipalFromLocals, toAssistantMessageWire, toAssistantThreadWire };
+
+//# sourceMappingURL=sveltekit.js.map