@happyvertical/smrt-chat 0.53.4 → 0.53.5

package/dist/sveltekit.js

@@ -1,5 +1,7 @@
 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";
+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) {
@@ -60,6 +62,29 @@ 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.");
@@ -209,8 +234,17 @@ function matchRoute(segments) {
 	};
 	return null;
 }
-function mountAssistantRoutes(options) {
-	if (!options?.ai) throw new Error("mountAssistantRoutes: `ai` is required (an AI client or a factory).");
+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;
@@ -228,6 +262,7 @@ function mountAssistantRoutes(options) {
 		} 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;
@@ -239,10 +274,22 @@ function mountAssistantRoutes(options) {
 		if (path === void 0) return null;
 		return path.split("/").filter((segment) => segment.length > 0);
 	};
-	const chatFor = async (principal) => {
+	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: principal.tenantId,
-			...options.db ? { db: options.db } : {}
+			tenantId: context.principal.tenantId,
+			...db ? { db } : {}
 		});
 		await chat.initialize();
 		return chat;
@@ -276,10 +323,10 @@ function mountAssistantRoutes(options) {
 	};
 	const resolveAI = async (context, model) => {
 		try {
-			const ai = typeof options.ai === "function" ? await options.ai({
+			const ai = typeof aiSource === "function" ? await aiSource({
 				...context,
 				...model ? { model } : {}
-			}) : options.ai;
+			}) : aiSource;
 			if (!ai || typeof ai.chat !== "function") throw new Error("The AI factory returned no client.");
 			return ai;
 		} catch (error) {
@@ -287,6 +334,24 @@ function mountAssistantRoutes(options) {
 			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,
@@ -301,18 +366,33 @@ function mountAssistantRoutes(options) {
 			return current && current.participantProfileId === principal.profileId && current.isActive() ? current : null;
 		});
 	};
-	const turnSetup = async (context, chat, session, thread, body) => {
-		const { principal } = context;
+	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 [extraTools, tools, systemPrompt] = await Promise.all([
+		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.tools, context),
-			resolveValue(options.systemPrompt, context)
+			resolveValue(options.systemPrompt, context),
+			dbFor(context)
 		]);
-		if (options.authorInvocation) {
+		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),
@@ -322,10 +402,6 @@ function mountAssistantRoutes(options) {
 			});
 		}
 		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,
@@ -340,10 +416,10 @@ function mountAssistantRoutes(options) {
 					tenantId: principal.tenantId,
 					allowedTools
 				},
-				...options.db ? { db: options.db } : {},
+				...db ? { db } : {},
 				...systemPrompt ? { systemPrompt } : {},
 				extraTools: [...extraTools ?? []],
-				tools: [...tools ?? []],
+				tools: [...tools],
 				clientTools,
 				continuations,
 				continuationKey: String(thread.id),
@@ -383,8 +459,103 @@ function mountAssistantRoutes(options) {
 		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.principal);
+		const chat = await chatFor(context);
 		const session = await findSession(chat, context.principal);
 		if (!session?.chatRoomId) return json({ items: [] });
 		return json({ items: (await chat.listRoomThreads({
@@ -398,7 +569,7 @@ function mountAssistantRoutes(options) {
 		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 chat = await chatFor(context);
 		const allowedTools = await allowedToolsFor(context);
 		const { session } = await chat.createAgentSession({
 			tenantId: principal.tenantId,
@@ -417,7 +588,7 @@ function mountAssistantRoutes(options) {
 	};
 	const loadMessages = async (context, threadId) => {
 		const { principal } = context;
-		const chat = await chatFor(principal);
+		const chat = await chatFor(context);
 		const session = await findSession(chat, principal);
 		await requireOwnThread(chat, principal, session, threadId);
 		return json({ items: (await chat.getThreadMessages({
@@ -508,7 +679,7 @@ function mountAssistantRoutes(options) {
 		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 chat = await chatFor(context);
 		const session = await findSession(chat, principal);
 		const thread = await requireOwnThread(chat, principal, session, threadId);
 		if (!session?.chatRoomId) throw notFound();
@@ -533,7 +704,8 @@ function mountAssistantRoutes(options) {
 				...record.url ? { url: record.url } : {}
 			}));
 		}
-		const setup = await turnSetup(context, chat, session, thread, body);
+		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 {
@@ -574,17 +746,17 @@ function mountAssistantRoutes(options) {
 					});
 				}
 			}
-			const events = runAssistantTurn({
-				...setup.turn,
-				history: history.slice(-historyLimit),
-				userMessage: content,
-				originMessageId: userWire.id,
-				onState: recordTurnState(chat, principal, threadId)
-			});
-			return stream(detached({
+			const transcript = history.slice(-historyLimit);
+			return await respondWithTurn(context, chat, session, thread, prepared, setup, {
 				type: "message",
 				message: userWire
-			}, events), setup.abort);
+			}, (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;
@@ -610,19 +782,20 @@ function mountAssistantRoutes(options) {
 		});
 		resolveModel(body.model);
 		const { principal } = context;
-		const chat = await chatFor(principal);
+		const chat = await chatFor(context);
 		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,
+		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(chat, principal, threadId)
-		})), setup.abort);
+			onState: recordTurnState(turnChat, principal, threadId)
+		}));
 	};
 	const uploadAttachment = async (context) => {
 		const storage = options.attachments;
@@ -658,8 +831,9 @@ function mountAssistantRoutes(options) {
 		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: {
-			...options.db ? { db: options.db } : {},
+			...db ? { db } : {},
 			principal: {
 				runAsUserId: principal.userId,
 				tenantId: principal.tenantId,
@@ -726,7 +900,38 @@ function mountAssistantRoutes(options) {
 		handle
 	};
 }
-function detached(first, events) {
+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;
@@ -735,31 +940,34 @@ function detached(first, events) {
 		notify = null;
 		resume?.();
 	};
-	(async () => {
+	const settled = (async () => {
 		try {
-			for await (const event of events) {
+			await produce((event) => {
 				buffer.push(event);
 				wake();
-			}
+			});
 		} catch {} finally {
 			finished = true;
 			wake();
 		}
 	})();
-	return (async function* () {
-		for (;;) {
-			if (buffer.length > 0) {
-				yield buffer.shift();
-				continue;
+	return {
+		events: (async function* () {
+			for (;;) {
+				if (buffer.length > 0) {
+					yield buffer.shift();
+					continue;
+				}
+				if (finished) return;
+				await new Promise((resolve) => {
+					notify = resolve;
+				});
 			}
-			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, mountAssistantRoutes, resolveAssistantPrincipalFromLocals, toAssistantMessageWire, toAssistantThreadWire };
+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