@mastra/factory 0.8.0-alpha.8 → 0.8.0

package/dist/routes/config.js

@@ -1,10 +1,11 @@
 import { WEB_OAUTH_FLOW_KINDS, getAuthProviderId, listTenantCredentialsForRequest, resolveCredentialContext, tenantOrgId } from "./provider-credentials.js";
 import { Route } from "./route.js";
 import { applyStoredMemorySettings } from "../session/memory-settings-hydration.js";
+import { applyActiveModelPack } from "../session/model-pack-hydration.js";
 import { registerApiRoute } from "@mastra/core/server";
 import { DEFAULT_OM_MODEL_ID } from "@mastra/code-sdk/constants";
 import { getAvailableModePacks, resolveProviderOMDefault } from "@mastra/code-sdk/onboarding/packs";
-import { THINKING_LEVEL_VALUES, THREAD_ACTIVE_MODEL_PACK_ID_KEY, getCustomProviderId, isThinkingLevelSetting, loadSettings, saveSettings } from "@mastra/code-sdk/onboarding/settings";
+import { THINKING_LEVEL_VALUES, getCustomProviderId, isThinkingLevelSetting, loadSettings, saveSettings } from "@mastra/code-sdk/onboarding/settings";
 //#region src/routes/config.ts
 /** Widen a route-local Hono context to the plain `Context` the auth helpers take. */
 function loose(c) {
@@ -173,6 +174,13 @@ async function resolvePackContext({ c, auth, modelPacks }) {
 		message: "Model pack storage is unavailable — the app database is not configured or failed to start."
 	}, 503) };
 }
+async function authorizePackSession({ c, auth, sessions, packContext, resourceId, scope }) {
+	if (!auth.enabled()) return null;
+	if (!sessions) return c.json({ error: "session_authorization_unavailable" }, 503);
+	const sourceSession = await sessions.getBySessionId(resourceId);
+	if (!sourceSession || sourceSession.orgId !== packContext.orgId || sourceSession.userId !== packContext.userId || !scope || sourceSession.sandboxWorkdir !== scope) return c.json({ error: `No session for resourceId "${resourceId}"` }, 404);
+	return null;
+}
 /** DB row → the `ModePack` shape the packs list and activation flow consume. */
 function recordToModePack(record) {
 	return {
@@ -185,8 +193,8 @@ function recordToModePack(record) {
 /**
 * List available model packs (built-in, gated by provider access, plus saved
 * custom packs from the request's pack context). Drops the synthetic
-* "New Custom" placeholder — the web client has its own create flow. `active`
-* is set from the given session's thread when a resourceId is supplied.
+* "New Custom" placeholder because the web client has its own create flow.
+* `active` marks the user's default pack for new interactive chats.
 */
 async function listModelPacks({ controller, authStorage, tenantCredentials, packContext, activePackId }) {
 	return [...getAvailableModePacks(await buildProviderAccess({
@@ -199,50 +207,11 @@ async function listModelPacks({ controller, authStorage, tenantCredentials, pack
 		active: activePackId != null && p.id === activePackId
 	}));
 }
-/** Resolve the active pack id for a session by reading its current thread. */
-async function resolveActivePackId(session) {
-	if (!session) return null;
-	const threadId = session.thread.getId();
-	if (!threadId) return null;
-	const value = (await session.thread.list()).find((t) => t.id === threadId)?.metadata?.[THREAD_ACTIVE_MODEL_PACK_ID_KEY];
+async function resolveSessionModelPackId(session) {
+	if (!session?.thread.getId()) return null;
+	const value = await session.thread.getSetting({ key: "activeModelPackId" });
 	return typeof value === "string" ? value : null;
 }
-/**
-* Apply a pack to a session: seed each mode's default model, switch the current
-* mode's model, set per-subagent models, and tag the thread with the active
-* pack id. Mirrors the TUI `applyPack` orchestration.
-*/
-async function applyPackToSession({ controller, session, pack }) {
-	const modes = controller.listModes?.() ?? [];
-	const packModels = pack.models;
-	for (const mode of modes) {
-		const modelId = packModels[mode.id];
-		if (modelId) {
-			mode.defaultModelId = modelId;
-			await session.thread.setSetting({
-				key: `modeModelId_${mode.id}`,
-				value: modelId
-			});
-		}
-	}
-	const currentModeModel = packModels[session.mode.get()];
-	if (currentModeModel) await session.model.switch({ modelId: currentModeModel });
-	for (const [agentType, modeId] of Object.entries({
-		explore: "fast",
-		plan: "plan",
-		execute: "build"
-	})) {
-		const saModelId = packModels[modeId];
-		if (saModelId) await session.subagents.model.set({
-			modelId: saModelId,
-			agentType
-		});
-	}
-	await session.thread.setSetting({
-		key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
-		value: pack.id
-	});
-}
 function readOMConfig(session) {
 	const observeAttachments = (session.state.get() ?? {}).observeAttachments;
 	return {
@@ -295,6 +264,7 @@ async function persistMemorySettings(context, patch, fillIfUnset) {
 }
 /**
 * The web config routes as Mastra `apiRoutes`:
+*   - `GET    /web/config/features`               — list server-enabled product features
 *   - `GET    /web/config/providers`              — list providers + key source
 *   - `PUT    /web/config/providers/:provider/key` — set/update a provider's API key
 *   - `DELETE /web/config/providers/:provider/key` — remove a stored API key
@@ -316,6 +286,11 @@ var ConfigRoutes = class extends Route {
 		const onCredentialsChanged = options.onCredentialsChanged ?? (() => {});
 		const onCustomProvidersChanged = options.onCustomProvidersChanged ?? (() => {});
 		return [
+			registerApiRoute("/web/config/features", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => c.json({ knowledge: options.features?.knowledge ?? false })
+			}),
 			registerApiRoute("/web/config/providers", {
 				method: "GET",
 				requiresAuth: false,
@@ -589,7 +564,22 @@ var ConfigRoutes = class extends Route {
 					const resourceId = c.req.query("resourceId");
 					const scope = c.req.query("scope") || void 0;
 					try {
-						const activePackId = await resolveActivePackId(resourceId ? await controller.getSessionByResource?.(resourceId, scope) : void 0);
+						const activePackId = (await packContext.storage.getActive({
+							orgId: packContext.orgId,
+							userId: packContext.userId
+						}))?.packId ?? null;
+						if (resourceId) {
+							const unauthorized = await authorizePackSession({
+								c: loose(c),
+								auth,
+								sessions: options.sourceControlSessions,
+								packContext,
+								resourceId,
+								scope
+							});
+							if (unauthorized) return unauthorized;
+						}
+						const sessionPackId = await resolveSessionModelPackId(resourceId ? await controller.getSessionByResource?.(resourceId, scope) : void 0);
 						const tenantCredentials = await listTenantCredentialsForRequest({
 							c: loose(c),
 							auth,
@@ -603,7 +593,8 @@ var ConfigRoutes = class extends Route {
 								packContext,
 								activePackId
 							}),
-							activePackId
+							activePackId,
+							sessionPackId
 						});
 					} catch (error) {
 						return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
@@ -655,6 +646,30 @@ var ConfigRoutes = class extends Route {
 					}
 				}
 			}),
+			registerApiRoute("/web/config/model-packs/active", {
+				method: "DELETE",
+				requiresAuth: false,
+				handler: async (c) => {
+					const packContext = await resolvePackContext({
+						c: loose(c),
+						auth,
+						modelPacks: options.modelPacks
+					});
+					if ("response" in packContext) return packContext.response;
+					try {
+						await packContext.storage.clearActive({
+							orgId: packContext.orgId,
+							userId: packContext.userId
+						});
+						return c.json({
+							ok: true,
+							activePackId: null
+						});
+					} catch (error) {
+						return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+					}
+				}
+			}),
 			registerApiRoute("/web/config/model-packs/:id", {
 				method: "DELETE",
 				requiresAuth: false,
@@ -694,12 +709,25 @@ var ConfigRoutes = class extends Route {
 					} catch {
 						return c.json({ error: "Invalid JSON body" }, 400);
 					}
-					const resourceId = typeof body.resourceId === "string" ? body.resourceId : "";
+					const target = body.target ?? "default";
+					if (target !== "default" && target !== "session") return c.json({ error: "target must be \"default\" or \"session\"" }, 400);
+					const resourceId = typeof body.resourceId === "string" && body.resourceId ? body.resourceId : void 0;
 					const scope = typeof body.scope === "string" && body.scope ? body.scope : void 0;
-					if (!resourceId) return c.json({ error: "Missing required field: resourceId" }, 400);
+					if (target === "session" && !resourceId) return c.json({ error: "Missing required field for session activation: resourceId" }, 400);
 					try {
-						const session = await controller.getSessionByResource?.(resourceId, scope);
-						if (!session) return c.json({ error: `No session for resourceId "${resourceId}"` }, 404);
+						if (target === "session" && resourceId) {
+							const unauthorized = await authorizePackSession({
+								c: loose(c),
+								auth,
+								sessions: options.sourceControlSessions,
+								packContext,
+								resourceId,
+								scope
+							});
+							if (unauthorized) return unauthorized;
+						}
+						const session = target === "session" && resourceId ? await controller.getSessionByResource?.(resourceId, scope) : void 0;
+						if (target === "session" && !session) return c.json({ error: `No session for resourceId "${resourceId}"` }, 404);
 						const tenantCredentials = await listTenantCredentialsForRequest({
 							c: loose(c),
 							auth,
@@ -712,14 +740,27 @@ var ConfigRoutes = class extends Route {
 							packContext
 						})).find((p) => p.id === id);
 						if (!pack) return c.json({ error: `Unknown pack "${id}"` }, 404);
-						await applyPackToSession({
-							controller,
-							session,
-							pack
+						if (target === "default") {
+							await packContext.storage.setActive({
+								orgId: packContext.orgId,
+								userId: packContext.userId,
+								packId: pack.id,
+								models: pack.models
+							});
+							return c.json({
+								ok: true,
+								target,
+								activePackId: pack.id
+							});
+						}
+						if (session) await applyActiveModelPack(session, {
+							packId: pack.id,
+							models: pack.models
 						});
 						return c.json({
 							ok: true,
-							activePackId: pack.id
+							target,
+							sessionPackId: pack.id
 						});
 					} catch (error) {
 						return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);