@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

package/dist/onboarding/settings.js

@@ -0,0 +1,1060 @@
+import { getAppDataDir } from "../utils/project.js";
+import { AuthStorage, PROVIDER_DEFAULT_MODELS } from "../auth/storage.js";
+import { OPENAI_PREFIX, normalizeAnthropicModelId, remapOpenAIModelForCodexOAuth, stripMastraGatewayPrefix } from "../providers/model-ids.js";
+import { THINKING_LEVEL_VALUES, isThinkingLevelSetting, resolveDefaultThinkingLevel as resolveDefaultThinkingLevel$1 } from "../thinking.js";
+import { buildCodexStagehandFetch, createCodexMiddleware } from "../providers/openai-codex.js";
+import { DEFAULT_STT_PROVIDER, resolveSTTModel } from "../voice/stt-registry.js";
+import { pruneUnknownModePackFallbacks, pruneUnknownPackAccountPreferences } from "./packs.js";
+import { dirname, join } from "path";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+//#region src/onboarding/settings.ts
+/**
+* Persistent global settings stored in the app data directory as settings.json.
+* This file persists onboarding state AND user preferences (model choices, yolo, etc.)
+* so they carry across threads and restarts.
+*/
+var ExperimentalAgentSettingsError = class extends Error {
+	value;
+	constructor(value, settingsPath) {
+		super(`Invalid "experimentalAgent" setting${settingsPath ? ` in ${settingsPath}` : ""}: ${JSON.stringify(value)}. Remove the "experimentalAgent" key or set it to "durable", "evented", or null.`);
+		this.name = "ExperimentalAgentSettingsError";
+		this.value = value;
+	}
+};
+/** Gateway provider key used in AuthStorage. */
+const MASTRA_GATEWAY_PROVIDER = "mastra-gateway";
+/** Default gateway URL. */
+const MASTRA_GATEWAY_DEFAULT_URL = "https://gateway-api.mastra.ai";
+/** @deprecated Renamed to {@link MASTRA_GATEWAY_PROVIDER}. */
+const MEMORY_GATEWAY_PROVIDER = MASTRA_GATEWAY_PROVIDER;
+/** @deprecated Renamed to {@link MASTRA_GATEWAY_DEFAULT_URL}. */
+const MEMORY_GATEWAY_DEFAULT_URL = MASTRA_GATEWAY_DEFAULT_URL;
+/** Named viewport sizes offered by `/browser set viewport`. */
+const VIEWPORT_PRESETS = {
+	desktop: {
+		width: 1280,
+		height: 720
+	},
+	"desktop-hd": {
+		width: 1920,
+		height: 1080
+	},
+	laptop: {
+		width: 1440,
+		height: 900
+	},
+	tablet: {
+		width: 768,
+		height: 1024
+	},
+	mobile: {
+		width: 390,
+		height: 844
+	}
+};
+/**
+* Largest viewport dimension accepted. Guards against typos that would launch a
+* browser far larger than any display.
+*/
+const MAX_VIEWPORT_DIMENSION = 1e4;
+function isValidDimension(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= MAX_VIEWPORT_DIMENSION;
+}
+/**
+* Parse a `WIDTHxHEIGHT` string (e.g. `1280x720`), a preset name, or `window`.
+* Returns undefined when the input is not a usable viewport.
+*/
+function parseViewportInput(input) {
+	const value = input.trim().toLowerCase();
+	if (!value) return void 0;
+	if (value === "window") return "window";
+	if (value in VIEWPORT_PRESETS) return { ...VIEWPORT_PRESETS[value] };
+	const match = /^(\d+)\s*[x×]\s*(\d+)$/.exec(value);
+	if (!match) return void 0;
+	const width = Number(match[1]);
+	const height = Number(match[2]);
+	if (!isValidDimension(width) || !isValidDimension(height)) return void 0;
+	return {
+		width,
+		height
+	};
+}
+/** Auth key prefix for observability tokens stored per-resource in auth.json */
+const OBSERVABILITY_AUTH_PREFIX = "observability:";
+const GITHUB_POLL_INTERVAL_DEFAULT_MS = 3e5;
+const GITHUB_POLL_INTERVAL_MIN_MS = 1e4;
+const GITHUB_POLL_INTERVAL_MAX_MS = 2147483647;
+const STORAGE_DEFAULTS = {
+	backend: "libsql",
+	libsql: {},
+	pg: {}
+};
+/** Default STT engine: on-device macOS recognizer where available, else cloud. */
+function defaultVoiceEngine() {
+	return process.platform === "darwin" ? "macos-native" : "cloud";
+}
+const DEFAULTS = {
+	onboarding: {
+		completedAt: null,
+		skippedAt: null,
+		version: 0,
+		modePackId: null,
+		omPackId: null
+	},
+	models: {
+		activeModelPackId: null,
+		modePackOverrides: {},
+		packFallbacks: {},
+		packAccountPreferences: {},
+		modeDefaults: {},
+		modeThinkingDefaults: {},
+		activeOmPackId: null,
+		omModelOverride: null,
+		observerModelOverride: null,
+		observerModelSelection: null,
+		reflectorModelOverride: null,
+		reflectorModelSelection: null,
+		omObservationThreshold: null,
+		omReflectionThreshold: null,
+		omCavemanObservations: null,
+		omObserveAttachments: null,
+		subagentModels: {},
+		goalJudgeModel: null,
+		goalMaxTurns: null
+	},
+	preferences: {
+		yolo: null,
+		theme: "auto",
+		thinkingLevel: "off",
+		subagentsEnabled: false,
+		previewLines: 2,
+		webSearchProvider: "auto"
+	},
+	storage: { ...STORAGE_DEFAULTS },
+	customModelPacks: [],
+	customProviders: [],
+	modelUseCounts: {},
+	updateDismissedVersion: null,
+	memoryGateway: {},
+	lsp: false,
+	browser: {
+		enabled: false,
+		provider: "stagehand",
+		headless: false,
+		viewport: { ...VIEWPORT_PRESETS.desktop },
+		stagehand: { env: "LOCAL" }
+	},
+	shellPassthrough: { mode: "default" },
+	voice: {
+		enabled: false,
+		engine: defaultVoiceEngine(),
+		provider: DEFAULT_STT_PROVIDER
+	},
+	experimentalAgent: null,
+	backgroundTools: { enabled: false },
+	signals: {
+		unixSocketPubSub: false,
+		experimentalGithubSignals: false,
+		experimentalCrossAgentSignals: false,
+		experimentalScheduleTools: false,
+		githubPollIntervalMs: GITHUB_POLL_INTERVAL_DEFAULT_MS
+	},
+	mcp: {
+		claudeCodeGlobal: false,
+		codexGlobal: false
+	},
+	observability: {
+		resources: {},
+		localTracing: false
+	}
+};
+const WEB_SEARCH_PROVIDER_VALUES = [
+	"auto",
+	"tavily",
+	"parallel"
+];
+const PREVIEW_LINES_MAX = 8;
+const loadedSignalSettings = /* @__PURE__ */ new WeakMap();
+function cloneSignalSettings(signals) {
+	return { ...signals };
+}
+function rememberLoadedSettings(settings) {
+	loadedSignalSettings.set(settings, cloneSignalSettings(settings.signals));
+	return settings;
+}
+function signalSettingsEqual(left, right) {
+	return left.unixSocketPubSub === right.unixSocketPubSub && left.experimentalGithubSignals === right.experimentalGithubSignals && left.experimentalCrossAgentSignals === right.experimentalCrossAgentSignals && left.experimentalScheduleTools === right.experimentalScheduleTools && left.githubPollIntervalMs === right.githubPollIntervalMs;
+}
+function parseWebSearchProvider(value) {
+	return typeof value === "string" && WEB_SEARCH_PROVIDER_VALUES.includes(value) ? value : DEFAULTS.preferences.webSearchProvider;
+}
+function parseThinkingLevel(value) {
+	return isThinkingLevelSetting(value) ? value : DEFAULTS.preferences.thinkingLevel;
+}
+function parseModeThinkingDefaults(value) {
+	if (!value || typeof value !== "object") return {};
+	const result = {};
+	for (const [mode, level] of Object.entries(value)) if (isThinkingLevelSetting(level)) result[mode] = level;
+	return result;
+}
+function parseModePackOverrides(value) {
+	if (!value || typeof value !== "object") return {};
+	const result = {};
+	for (const [packId, overrides] of Object.entries(value)) {
+		if (!overrides || typeof overrides !== "object") continue;
+		const parsedOverrides = Object.fromEntries(Object.entries(overrides).filter((entry) => typeof entry[1] === "string" && entry[1].length > 0));
+		if (Object.keys(parsedOverrides).length > 0) result[packId] = parsedOverrides;
+	}
+	return result;
+}
+function parsePackFallbacks(value) {
+	if (!value || typeof value !== "object") return {};
+	const result = {};
+	for (const [packId, fallbackId] of Object.entries(value)) if (typeof fallbackId === "string" && fallbackId.length > 0) result[packId] = fallbackId;
+	return result;
+}
+/** Shape-parse + drop entries whose source or target pack no longer exists. */
+function loadPackFallbacks(value, customModelPacks) {
+	return pruneUnknownModePackFallbacks(parsePackFallbacks(value), customModelPacks);
+}
+function parsePackAccountPreferences(value) {
+	if (!value || typeof value !== "object") return {};
+	const result = {};
+	for (const [packId, modelPreferences] of Object.entries(value)) {
+		if (!modelPreferences || typeof modelPreferences !== "object") continue;
+		const parsed = Object.fromEntries(Object.entries(modelPreferences).filter((entry) => entry[0].length > 0 && typeof entry[1] === "string" && entry[1].length > 0));
+		if (Object.keys(parsed).length > 0) result[packId] = parsed;
+	}
+	return result;
+}
+function loadPackAccountPreferences(value, customModelPacks, modePackOverrides) {
+	return pruneUnknownPackAccountPreferences(parsePackAccountPreferences(value), customModelPacks, modePackOverrides);
+}
+/** Move persisted routing choices when re-authentication changes an account instance id. */
+function migrateAccountPreferences(settings, previousAccountId, nextAccountId) {
+	if (previousAccountId === nextAccountId) return;
+	for (const modelPreferences of Object.values(settings.models.packAccountPreferences ?? {})) for (const [modelId, accountInstanceId] of Object.entries(modelPreferences)) if (accountInstanceId === previousAccountId) modelPreferences[modelId] = nextAccountId;
+}
+/** Remove persisted routing choices that point at deleted OAuth account instances. */
+function pruneRemovedAccountPreferences(settings, removedAccountIds) {
+	const removed = new Set(removedAccountIds);
+	if (removed.size === 0) return;
+	const next = {};
+	for (const [packId, modelPreferences] of Object.entries(settings.models.packAccountPreferences ?? {})) {
+		const retained = Object.fromEntries(Object.entries(modelPreferences).filter(([, accountInstanceId]) => !removed.has(accountInstanceId)));
+		if (Object.keys(retained).length > 0) next[packId] = retained;
+	}
+	settings.models.packAccountPreferences = next;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+/**
+* Resolves the preview line limit. `previewLines` wins when valid; otherwise the legacy
+* `quietModeMaxToolPreviewLines` key (still written by older Mastra Code versions) is used.
+*/
+function parsePreviewLines(raw) {
+	const value = isFiniteNumber(raw.previewLines) ? raw.previewLines : isFiniteNumber(raw.quietModeMaxToolPreviewLines) ? raw.quietModeMaxToolPreviewLines : DEFAULTS.preferences.previewLines;
+	return Math.min(PREVIEW_LINES_MAX, Math.max(0, Math.floor(value)));
+}
+function parsePreferences(rawPreferences) {
+	const raw = rawPreferences && typeof rawPreferences === "object" ? rawPreferences : {};
+	return {
+		...DEFAULTS.preferences,
+		...raw,
+		thinkingLevel: parseThinkingLevel(raw.thinkingLevel),
+		subagentsEnabled: typeof raw.subagentsEnabled === "boolean" ? raw.subagentsEnabled : DEFAULTS.preferences.subagentsEnabled,
+		previewLines: parsePreviewLines(raw),
+		webSearchProvider: parseWebSearchProvider(raw.webSearchProvider)
+	};
+}
+function parseGithubPollIntervalMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULTS.signals.githubPollIntervalMs;
+	const intervalMs = Math.floor(value);
+	if (intervalMs < 1e4) return DEFAULTS.signals.githubPollIntervalMs;
+	return Math.min(intervalMs, GITHUB_POLL_INTERVAL_MAX_MS);
+}
+function parseExperimentalAgentSetting(value, settingsPath) {
+	if (value === void 0 || value === null) return null;
+	if (value === "durable" || value === "evented") return value;
+	throw new ExperimentalAgentSettingsError(value, settingsPath);
+}
+function loadExperimentalAgentSetting(value, settingsPath) {
+	try {
+		return { selection: parseExperimentalAgentSetting(value, settingsPath) };
+	} catch (error) {
+		if (error instanceof ExperimentalAgentSettingsError) return {
+			selection: error.value,
+			settingsPath
+		};
+		throw error;
+	}
+}
+function parseBackgroundToolSettings(rawBackgroundTools) {
+	const raw = rawBackgroundTools && typeof rawBackgroundTools === "object" ? rawBackgroundTools : {};
+	return { enabled: typeof raw.enabled === "boolean" ? raw.enabled : DEFAULTS.backgroundTools.enabled };
+}
+function parseSignalSettings(rawSignals) {
+	const raw = rawSignals && typeof rawSignals === "object" ? rawSignals : {};
+	return {
+		unixSocketPubSub: typeof raw.unixSocketPubSub === "boolean" ? raw.unixSocketPubSub : DEFAULTS.signals.unixSocketPubSub,
+		experimentalGithubSignals: typeof raw.experimentalGithubSignals === "boolean" ? raw.experimentalGithubSignals : DEFAULTS.signals.experimentalGithubSignals,
+		experimentalCrossAgentSignals: typeof raw.experimentalCrossAgentSignals === "boolean" ? raw.experimentalCrossAgentSignals : DEFAULTS.signals.experimentalCrossAgentSignals,
+		experimentalScheduleTools: typeof raw.experimentalScheduleTools === "boolean" ? raw.experimentalScheduleTools : DEFAULTS.signals.experimentalScheduleTools,
+		githubPollIntervalMs: parseGithubPollIntervalMs(raw.githubPollIntervalMs)
+	};
+}
+function parseMcpDiscoverySettings(rawMcp) {
+	const raw = rawMcp && typeof rawMcp === "object" ? rawMcp : {};
+	return {
+		claudeCodeGlobal: typeof raw.claudeCodeGlobal === "boolean" ? raw.claudeCodeGlobal : DEFAULTS.mcp.claudeCodeGlobal,
+		codexGlobal: typeof raw.codexGlobal === "boolean" ? raw.codexGlobal : DEFAULTS.mcp.codexGlobal
+	};
+}
+function getSettingsPath() {
+	return join(getAppDataDir(), "settings.json");
+}
+function getCustomProviderId(name) {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "provider";
+}
+function toCustomProviderModelId(providerName, modelName) {
+	const providerId = getCustomProviderId(providerName);
+	const trimmedModelName = modelName.trim();
+	const providerPrefix = `${providerId}/`;
+	if (trimmedModelName.startsWith(providerPrefix)) return trimmedModelName;
+	return `${providerId}/${trimmedModelName}`;
+}
+/**
+* The shared gateway catalog namespaces provider keys under their owning
+* gateway id, so a custom provider's models surface in the `/models` catalog
+* as `mastracode/<providerId>/<model>` instead of the canonical
+* `<providerId>/<model>` that model resolution expects. Persisting the
+* gateway-qualified id verbatim breaks lookup later (the provider is parsed
+* as `mastracode`). Strip the prefix before saving — but only when the
+* middle segment matches one of the user's configured custom providers, so
+* legitimate `mastracode/...` gateway-routed ids are left untouched.
+*/
+function stripMastraCodeCustomProviderPrefix(modelId, customProviders) {
+	if (!modelId.startsWith("mastracode/")) return modelId;
+	const rest = modelId.slice(11);
+	const [providerId, ...modelParts] = rest.split("/");
+	if (!providerId || modelParts.length === 0 || modelParts.some((part) => part.length === 0)) return modelId;
+	return customProviders.some((provider) => getCustomProviderId(provider.name) === providerId) ? rest : modelId;
+}
+function parseCustomProviders(rawProviders) {
+	if (!Array.isArray(rawProviders)) return [];
+	const parsedProviders = [];
+	for (const rawProvider of rawProviders) {
+		if (!rawProvider || typeof rawProvider !== "object") continue;
+		const candidate = rawProvider;
+		const name = typeof candidate.name === "string" ? candidate.name.trim() : "";
+		const url = typeof candidate.url === "string" ? candidate.url.trim() : "";
+		if (!name || !url) continue;
+		const providerId = getCustomProviderId(name);
+		const models = Array.isArray(candidate.models) ? [...new Set(candidate.models.filter((model) => typeof model === "string").map((model) => model.trim()).map((model) => {
+			const providerPrefix = `${providerId}/`;
+			if (model.startsWith(providerPrefix)) return model.slice(providerPrefix.length);
+			return model;
+		}))].filter((model) => model.length > 0) : [];
+		const apiKey = typeof candidate.apiKey === "string" && candidate.apiKey.trim().length > 0 ? candidate.apiKey.trim() : void 0;
+		parsedProviders.push({
+			name,
+			url,
+			...apiKey ? { apiKey } : {},
+			models
+		});
+	}
+	return parsedProviders;
+}
+const BROWSER_PROVIDERS = /* @__PURE__ */ new Set(["stagehand", "agent-browser"]);
+const STAGEHAND_ENVS = /* @__PURE__ */ new Set(["LOCAL", "BROWSERBASE"]);
+/**
+* Normalize a Stagehand model id, which must be provider-qualified.
+*
+* Stagehand reads the segment before the first slash as the provider, so a
+* bare id like `gpt-4.1` is rejected as an unknown provider and a trailing
+* slash leaves an empty model name that only fails once a request is made.
+* Neither is usable, so both are dropped here rather than persisted.
+*
+* The provider name itself is checked where the command is issued, which can
+* name the supported providers in an error; this module is on the startup path
+* and only imports Stagehand lazily.
+*
+* @returns the trimmed model id, or undefined when it is unusable.
+*/
+function parseStagehandModel(value) {
+	if (typeof value !== "string") return void 0;
+	const model = value.trim();
+	const separator = model.indexOf("/");
+	if (separator <= 0) return void 0;
+	return model.slice(separator + 1).trim() ? model : void 0;
+}
+/**
+* Validate a viewport read from settings.json, falling back to the default when
+* it is missing or malformed.
+*/
+function parseStoredViewport(raw) {
+	if (raw === "window") return "window";
+	if (raw && typeof raw === "object") {
+		const { width, height } = raw;
+		if (isValidDimension(width) && isValidDimension(height)) return {
+			width,
+			height
+		};
+	}
+	return { ...VIEWPORT_PRESETS.desktop };
+}
+/**
+* Validate the `lsp` setting from JSON. Accepts both the boolean opt-in/opt-out
+* form and the full LSPConfig object; anything else is treated as unset.
+*/
+function parseLspSettings(raw) {
+	if (typeof raw === "boolean") return raw;
+	if (raw && typeof raw === "object") return raw;
+}
+/**
+* Resolve the effective LSP config. LSP is opt-in: `false` and an absent
+* setting both mean disabled, `true` means enabled with defaults.
+*/
+function resolveLspSetting(lsp) {
+	if (lsp === true) return {};
+	if (!lsp) return false;
+	return lsp;
+}
+/**
+* Deep-merge and validate browser settings from JSON.
+* Explicitly validates types to handle malformed settings.json gracefully.
+*/
+function parseBrowserSettings(rawBrowser) {
+	const raw = rawBrowser && typeof rawBrowser === "object" ? rawBrowser : {};
+	const rawStagehand = raw.stagehand && typeof raw.stagehand === "object" ? raw.stagehand : {};
+	const stagehandModel = parseStagehandModel(rawStagehand.model);
+	const rawAgentBrowser = raw.agentBrowser && typeof raw.agentBrowser === "object" ? raw.agentBrowser : {};
+	return {
+		enabled: typeof raw.enabled === "boolean" ? raw.enabled : DEFAULTS.browser.enabled,
+		provider: typeof raw.provider === "string" && BROWSER_PROVIDERS.has(raw.provider) ? raw.provider : DEFAULTS.browser.provider,
+		headless: typeof raw.headless === "boolean" ? raw.headless : DEFAULTS.browser.headless,
+		cdpUrl: typeof raw.cdpUrl === "string" && raw.cdpUrl.trim() ? raw.cdpUrl.trim() : void 0,
+		profile: typeof raw.profile === "string" && raw.profile.trim() ? raw.profile.trim() : void 0,
+		executablePath: typeof raw.executablePath === "string" && raw.executablePath.trim() ? raw.executablePath.trim() : void 0,
+		viewport: parseStoredViewport(raw.viewport),
+		scope: typeof raw.scope === "string" && (raw.scope === "shared" || raw.scope === "thread") ? raw.scope : void 0,
+		stagehand: {
+			env: typeof rawStagehand.env === "string" && STAGEHAND_ENVS.has(rawStagehand.env) ? rawStagehand.env : DEFAULTS.browser.stagehand.env,
+			...typeof rawStagehand.apiKey === "string" && rawStagehand.apiKey.trim() ? { apiKey: rawStagehand.apiKey.trim() } : {},
+			...typeof rawStagehand.projectId === "string" && rawStagehand.projectId.trim() ? { projectId: rawStagehand.projectId.trim() } : {},
+			...stagehandModel ? { model: stagehandModel } : {},
+			...typeof rawStagehand.preserveUserDataDir === "boolean" ? { preserveUserDataDir: rawStagehand.preserveUserDataDir } : {}
+		},
+		agentBrowser: typeof rawAgentBrowser.storageState === "string" && rawAgentBrowser.storageState.trim() ? { storageState: rawAgentBrowser.storageState.trim() } : void 0
+	};
+}
+function parseShellPassthroughSettings(rawShellPassthrough) {
+	const raw = rawShellPassthrough && typeof rawShellPassthrough === "object" ? rawShellPassthrough : {};
+	const executable = typeof raw.executable === "string" && raw.executable.trim() ? raw.executable.trim() : void 0;
+	const family = typeof raw.family === "string" && raw.family.trim() ? raw.family.trim() : void 0;
+	const mode = typeof raw.mode === "string" && raw.mode.trim() ? raw.mode.trim() : void 0;
+	const defaultMode = executable ? void 0 : DEFAULTS.shellPassthrough.mode;
+	return {
+		...mode ?? defaultMode ? { mode: mode ?? defaultMode } : {},
+		...executable ? { executable } : {},
+		...family ? { family } : {}
+	};
+}
+function parseVoiceSettings(rawVoice) {
+	const raw = rawVoice && typeof rawVoice === "object" ? rawVoice : {};
+	const enabled = typeof raw.enabled === "boolean" ? raw.enabled : DEFAULTS.voice.enabled;
+	const engine = raw.engine === "macos-native" || raw.engine === "cloud" ? raw.engine : defaultVoiceEngine();
+	const resolved = resolveSTTModel(typeof raw.provider === "string" ? raw.provider : DEFAULTS.voice.provider, typeof raw.model === "string" ? raw.model : void 0);
+	return {
+		enabled,
+		engine,
+		provider: resolved.provider,
+		model: resolved.model
+	};
+}
+const VALID_PROJECT_ID = /^[a-zA-Z0-9_-]+$/;
+function parseObservabilitySettings(raw) {
+	if (!raw || typeof raw !== "object") return {
+		resources: {},
+		localTracing: false
+	};
+	const obj = raw;
+	const localTracing = obj.localTracing === true;
+	const rawResources = obj.resources;
+	if (!rawResources || typeof rawResources !== "object") return {
+		resources: {},
+		localTracing
+	};
+	const resources = {};
+	for (const [key, val] of Object.entries(rawResources)) if (val && typeof val === "object") {
+		const v = val;
+		if (typeof v.projectId === "string" && VALID_PROJECT_ID.test(v.projectId)) resources[key] = {
+			projectId: v.projectId,
+			configuredAt: typeof v.configuredAt === "string" ? v.configuredAt : (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	return {
+		resources,
+		localTracing
+	};
+}
+/**
+* One-time migration: move model-related data from auth.json to settings.json.
+* Reads `_modelRanks`, `_modeModelId_*`, `_subagentModelId*` from auth.json,
+* merges them into settings, removes them from auth.json, and writes both files.
+* No-ops if auth.json has no _ prefixed model data.
+*/
+function migrateFromAuth(settingsPath) {
+	const authPath = join(getAppDataDir(), "auth.json");
+	if (!existsSync(authPath)) return false;
+	let authData;
+	try {
+		authData = JSON.parse(readFileSync(authPath, "utf-8"));
+	} catch {
+		return false;
+	}
+	const modelKeys = Object.keys(authData).filter((k) => k.startsWith("_"));
+	if (modelKeys.length === 0) return false;
+	let settings;
+	if (existsSync(settingsPath)) try {
+		const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
+		const rawCustomPacks = Array.isArray(raw.customModelPacks) ? raw.customModelPacks : [];
+		const modePackOverrides = parseModePackOverrides(raw.models?.modePackOverrides);
+		const experimentalAgentSetting = loadExperimentalAgentSetting(raw.experimentalAgent, settingsPath);
+		settings = {
+			onboarding: {
+				...DEFAULTS.onboarding,
+				...raw.onboarding
+			},
+			models: {
+				...DEFAULTS.models,
+				...raw.models,
+				modePackOverrides,
+				modeThinkingDefaults: parseModeThinkingDefaults(raw.models?.modeThinkingDefaults),
+				packFallbacks: loadPackFallbacks(raw.models?.packFallbacks, rawCustomPacks),
+				packAccountPreferences: loadPackAccountPreferences(raw.models?.packAccountPreferences, rawCustomPacks, modePackOverrides)
+			},
+			preferences: parsePreferences(raw.preferences),
+			storage: {
+				...STORAGE_DEFAULTS,
+				...raw.storage,
+				libsql: {
+					...STORAGE_DEFAULTS.libsql,
+					...raw.storage?.libsql
+				},
+				pg: {
+					...STORAGE_DEFAULTS.pg,
+					...raw.storage?.pg
+				}
+			},
+			customModelPacks: Array.isArray(raw.customModelPacks) ? raw.customModelPacks : [],
+			customProviders: parseCustomProviders(raw.customProviders),
+			modelUseCounts: raw.modelUseCounts && typeof raw.modelUseCounts === "object" ? raw.modelUseCounts : {},
+			updateDismissedVersion: typeof raw.updateDismissedVersion === "string" ? raw.updateDismissedVersion : null,
+			memoryGateway: raw.memoryGateway && typeof raw.memoryGateway === "object" ? raw.memoryGateway : {},
+			lsp: parseLspSettings(raw.lsp),
+			browser: parseBrowserSettings(raw.browser),
+			shellPassthrough: parseShellPassthroughSettings(raw.shellPassthrough),
+			voice: parseVoiceSettings(raw.voice),
+			experimentalAgent: experimentalAgentSetting.selection,
+			_experimentalAgentSettingsPath: experimentalAgentSetting.settingsPath,
+			backgroundTools: parseBackgroundToolSettings(raw.backgroundTools),
+			signals: parseSignalSettings(raw.signals),
+			mcp: parseMcpDiscoverySettings(raw.mcp),
+			observability: parseObservabilitySettings(raw.observability)
+		};
+	} catch {
+		settings = structuredClone(DEFAULTS);
+	}
+	else settings = structuredClone(DEFAULTS);
+	if (authData._modelRanks && typeof authData._modelRanks === "object") settings.modelUseCounts = {
+		...authData._modelRanks,
+		...settings.modelUseCounts
+	};
+	for (const key of modelKeys) {
+		const modeMatch = key.match(/^_modeModelId_(.+)$/);
+		if (modeMatch?.[1] && typeof authData[key] === "string" && !settings.models.modeDefaults[modeMatch[1]]) settings.models.modeDefaults[modeMatch[1]] = authData[key];
+	}
+	for (const key of modelKeys) {
+		if (key === "_subagentModelId" && typeof authData[key] === "string" && !settings.models.subagentModels["default"]) settings.models.subagentModels["default"] = authData[key];
+		const saMatch = key.match(/^_subagentModelId_(.+)$/);
+		if (saMatch?.[1] && typeof authData[key] === "string" && !settings.models.subagentModels[saMatch[1]]) settings.models.subagentModels[saMatch[1]] = authData[key];
+	}
+	saveSettings(settings, settingsPath);
+	for (const key of modelKeys) delete authData[key];
+	try {
+		writeFileAtomically(authPath, JSON.stringify(authData, null, 2));
+	} catch {}
+	return true;
+}
+const LEGACY_VARIED_MODELS = {
+	plan: "openai/gpt-5.4",
+	build: "anthropic/claude-sonnet-4-5",
+	fast: "anthropic/claude-haiku-4-5"
+};
+function migrateLegacyVariedPack(settings) {
+	const legacyPackId = "varied";
+	const customPackId = "custom:varied";
+	if (!(settings.models.activeModelPackId === legacyPackId || settings.onboarding.modePackId === legacyPackId)) return false;
+	const existingIdx = settings.customModelPacks.findIndex((p) => p.name === "varied");
+	if (existingIdx >= 0) {
+		const existing = settings.customModelPacks[existingIdx];
+		if (!Object.entries(LEGACY_VARIED_MODELS).every(([k, v]) => existing.models[k] === v)) existing.models = { ...LEGACY_VARIED_MODELS };
+	} else settings.customModelPacks.push({
+		name: "varied",
+		models: { ...LEGACY_VARIED_MODELS },
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	if (settings.models.activeModelPackId === legacyPackId) {
+		settings.models.activeModelPackId = customPackId;
+		if (Object.keys(settings.models.modeDefaults).length === 0) settings.models.modeDefaults = { ...LEGACY_VARIED_MODELS };
+	}
+	if (settings.onboarding.modePackId === legacyPackId) settings.onboarding.modePackId = customPackId;
+	return true;
+}
+function loadSettings(filePath = getSettingsPath()) {
+	migrateFromAuth(filePath);
+	if (!existsSync(filePath)) return rememberLoadedSettings(structuredClone(DEFAULTS));
+	try {
+		const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+		const rawCustomPacks = Array.isArray(raw.customModelPacks) ? raw.customModelPacks : [];
+		const modePackOverrides = parseModePackOverrides(raw.models?.modePackOverrides);
+		const experimentalAgentSetting = loadExperimentalAgentSetting(raw.experimentalAgent, filePath);
+		const settings = {
+			...raw,
+			onboarding: {
+				...DEFAULTS.onboarding,
+				...raw.onboarding
+			},
+			models: {
+				...DEFAULTS.models,
+				...raw.models,
+				modePackOverrides,
+				modeThinkingDefaults: parseModeThinkingDefaults(raw.models?.modeThinkingDefaults),
+				packFallbacks: loadPackFallbacks(raw.models?.packFallbacks, rawCustomPacks),
+				packAccountPreferences: loadPackAccountPreferences(raw.models?.packAccountPreferences, rawCustomPacks, modePackOverrides)
+			},
+			preferences: parsePreferences(raw.preferences),
+			storage: {
+				...STORAGE_DEFAULTS,
+				...raw.storage,
+				libsql: {
+					...STORAGE_DEFAULTS.libsql,
+					...raw.storage?.libsql
+				},
+				pg: {
+					...STORAGE_DEFAULTS.pg,
+					...raw.storage?.pg
+				}
+			},
+			customModelPacks: Array.isArray(raw.customModelPacks) ? raw.customModelPacks : [],
+			customProviders: parseCustomProviders(raw.customProviders),
+			modelUseCounts: raw.modelUseCounts && typeof raw.modelUseCounts === "object" ? raw.modelUseCounts : {},
+			updateDismissedVersion: typeof raw.updateDismissedVersion === "string" ? raw.updateDismissedVersion : null,
+			memoryGateway: raw.memoryGateway && typeof raw.memoryGateway === "object" ? raw.memoryGateway : {},
+			lsp: parseLspSettings(raw.lsp),
+			browser: parseBrowserSettings(raw.browser),
+			shellPassthrough: parseShellPassthroughSettings(raw.shellPassthrough),
+			voice: parseVoiceSettings(raw.voice),
+			experimentalAgent: experimentalAgentSetting.selection,
+			_experimentalAgentSettingsPath: experimentalAgentSetting.settingsPath,
+			backgroundTools: parseBackgroundToolSettings(raw.backgroundTools),
+			signals: parseSignalSettings(raw.signals),
+			mcp: parseMcpDiscoverySettings(raw.mcp),
+			observability: parseObservabilitySettings(raw.observability)
+		};
+		let settingsChanged = false;
+		if (!isFiniteNumber(raw.preferences?.previewLines)) settingsChanged = true;
+		if (raw.models?.omModelId && !settings.models.omModelOverride) {
+			settings.models.omModelOverride = raw.models.omModelId;
+			settingsChanged = true;
+		}
+		if (migrateLegacyVariedPack(settings)) settingsChanged = true;
+		if (settingsChanged) saveSettings(settings, filePath);
+		return rememberLoadedSettings(settings);
+	} catch {
+		return rememberLoadedSettings(structuredClone(DEFAULTS));
+	}
+}
+const THREAD_ACTIVE_MODEL_PACK_ID_KEY = "activeModelPackId";
+const THREAD_FALLBACK_STATUS_KEY = "mastracodeFallbackStatus";
+function parseThreadSettings(metadata) {
+	const modeModelIds = {};
+	for (const [key, value] of Object.entries(metadata ?? {})) {
+		const modeMatch = key.match(/^modeModelId_(.+)$/);
+		if (modeMatch?.[1] && typeof value === "string" && value.length > 0) modeModelIds[modeMatch[1]] = value;
+	}
+	const rawPackId = metadata?.[THREAD_ACTIVE_MODEL_PACK_ID_KEY];
+	return {
+		activeModelPackId: typeof rawPackId === "string" && rawPackId.length > 0 ? rawPackId : null,
+		modeModelIds
+	};
+}
+/**
+* Resolve active model pack id for the current thread.
+*
+* Priority:
+* 1) explicit thread metadata activeModelPackId
+* 2) inferred from thread modeModelId_* values
+* 3) global settings.models.activeModelPackId
+*/
+function resolveThreadActiveModelPackId(settings, builtinPacks, metadata) {
+	const threadSettings = parseThreadSettings(metadata);
+	const isKnownPack = (packId) => {
+		if (packId.startsWith("custom:")) {
+			const name = packId.slice(7);
+			return settings.customModelPacks.some((p) => p.name === name);
+		}
+		return builtinPacks.some((p) => p.id === packId);
+	};
+	if (threadSettings.activeModelPackId && isKnownPack(threadSettings.activeModelPackId)) return threadSettings.activeModelPackId;
+	const allPacks = [...builtinPacks, ...settings.customModelPacks.map((p) => ({
+		id: `custom:${p.name}`,
+		models: p.models
+	}))];
+	for (const pack of allPacks) {
+		const packEntries = Object.entries(pack.models);
+		const threadEntries = Object.keys(threadSettings.modeModelIds);
+		if (packEntries.length === threadEntries.length && packEntries.every(([modeId, modelId]) => threadSettings.modeModelIds[modeId] === modelId)) return pack.id;
+	}
+	if (settings.models.activeModelPackId && isKnownPack(settings.models.activeModelPackId)) return settings.models.activeModelPackId;
+	return null;
+}
+/**
+* Resolve effective per-mode model defaults.
+*
+* If `activeModelPackId` is set, looks up the pack (built-in or custom) and
+* returns its models. Falls back to the explicit `modeDefaults` map.
+*
+* @param settings  The loaded global settings.
+* @param builtinPacks  Built-in packs for the current provider access
+*                      (from `getAvailableModePacks`). Pass `[]` if unavailable.
+*/
+function resolveModePackModels(settings, pack) {
+	if (pack.id.startsWith("custom:") || pack.id === "custom") return pack.models;
+	return {
+		...pack.models,
+		...settings.models.modePackOverrides?.[pack.id]
+	};
+}
+/**
+* Resolve a session's explicitly active pack when its mode model still matches.
+* Model matching alone is not pack identity: multiple packs may intentionally
+* use the same model, and inference would attach an unrelated fallback chain.
+*/
+function findModePackForModel(settings, packs, modelId, modeId, activePackId) {
+	const activePack = packs.find((pack) => pack.id === activePackId);
+	return activePack && resolveModePackModels(settings, activePack)[modeId] === modelId ? activePack : void 0;
+}
+function resolveModelDefaults(settings, builtinPacks) {
+	const { activeModelPackId, modeDefaults } = settings.models;
+	if (!activeModelPackId) return modeDefaults;
+	if (activeModelPackId.startsWith("custom:")) {
+		const name = activeModelPackId.slice(7);
+		const pack = settings.customModelPacks.find((p) => p.name === name);
+		if (pack) return pack.models;
+		return modeDefaults;
+	}
+	const builtin = builtinPacks.find((p) => p.id === activeModelPackId);
+	if (builtin) return resolveModePackModels(settings, builtin);
+	return modeDefaults;
+}
+/**
+* Resolve the default reasoning-effort level for a mode.
+*
+* Lookup order:
+*   1. `models.modeThinkingDefaults[mode]` when set for the mode.
+*   2. The global `preferences.thinkingLevel`.
+*
+* Session-level overrides (via /think or the session settings panel) take
+* precedence over both and are handled by the caller.
+*/
+function resolveDefaultThinkingLevel(settings, mode) {
+	return resolveDefaultThinkingLevel$1({
+		globalDefault: settings.preferences.thinkingLevel,
+		modeDefaults: settings.models.modeThinkingDefaults
+	}, mode);
+}
+/**
+* Resolve the effective model ID for one of the two OM roles.
+*
+* Lookup order:
+*   1. The role-specific override (`observerModelOverride` /
+*      `reflectorModelOverride`) if set.
+*   2. If `activeOmPackId` points at a built-in pack, that pack's model.
+*   3. The shared `omModelOverride` fallback.
+*
+* @param settings  The loaded global settings.
+* @param role      Which OM role to resolve (`'observer'` or `'reflector'`).
+* @param builtinOmPacks  Built-in OM packs for the current provider access
+*                        (from `getAvailableOmPacks`). Pass `[]` if unavailable.
+*/
+function resolveOmRoleModel(settings, role, builtinOmPacks) {
+	const { activeOmPackId, omModelOverride, observerModelOverride, observerModelSelection, reflectorModelOverride, reflectorModelSelection } = settings.models;
+	const model = role === "observer" ? observerModelSelection : reflectorModelSelection;
+	if (model === "auto") return null;
+	if (model) return model;
+	const roleOverride = role === "observer" ? observerModelOverride : reflectorModelOverride;
+	if (roleOverride) return roleOverride;
+	if (!activeOmPackId) return omModelOverride;
+	if (activeOmPackId === "custom") return omModelOverride;
+	const pack = builtinOmPacks.find((p) => p.id === activeOmPackId);
+	if (pack) return pack.modelId;
+	return omModelOverride;
+}
+/**
+* @deprecated Use `resolveOmRoleModel(settings, 'observer' | 'reflector', ...)`.
+* Equivalent to resolving the observer role (existing callers set both observer
+* and reflector to the same value).
+*/
+function resolveOmModel(settings, builtinOmPacks) {
+	return resolveOmRoleModel(settings, "observer", builtinOmPacks);
+}
+function getSignalSettingsForSave(settings, filePath) {
+	const loadedSignals = loadedSignalSettings.get(settings);
+	if (!loadedSignals || !signalSettingsEqual(settings.signals, loadedSignals) || !existsSync(filePath)) return settings.signals;
+	try {
+		const currentSignals = parseSignalSettings(JSON.parse(readFileSync(filePath, "utf-8")).signals);
+		if (!signalSettingsEqual(currentSignals, loadedSignals)) return currentSignals;
+	} catch {}
+	return settings.signals;
+}
+function writeFileAtomically(filePath, content) {
+	const tempPath = `${filePath}.${process.pid}.${globalThis.crypto.randomUUID()}.tmp`;
+	try {
+		writeFileSync(tempPath, content, {
+			encoding: "utf-8",
+			mode: existsSync(filePath) ? statSync(filePath).mode & 511 : 384
+		});
+		renameSync(tempPath, filePath);
+	} finally {
+		rmSync(tempPath, { force: true });
+	}
+}
+function saveSettings(settings, filePath = getSettingsPath()) {
+	const dir = dirname(filePath);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const signals = getSignalSettingsForSave(settings, filePath);
+	settings.signals = signals;
+	loadedSignalSettings.set(settings, cloneSignalSettings(signals));
+	const settingsToSave = { ...settings };
+	delete settingsToSave._experimentalAgentSettingsPath;
+	writeFileAtomically(filePath, JSON.stringify(settingsToSave, null, 2));
+}
+/** Marker file name to track which provider last used a profile. */
+const PROFILE_PROVIDER_MARKER = ".mastra-provider";
+/**
+* Check which provider last used a profile directory.
+* Returns the provider name if the marker exists, undefined otherwise.
+*/
+function getProfileProvider(profilePath) {
+	const markerPath = join(profilePath, PROFILE_PROVIDER_MARKER);
+	if (!existsSync(markerPath)) return;
+	try {
+		const content = readFileSync(markerPath, "utf-8").trim();
+		if (content === "stagehand" || content === "agent-browser") return content;
+		return;
+	} catch {
+		return;
+	}
+}
+/**
+* Write the provider marker to a profile directory.
+* Creates the directory if it doesn't exist.
+*/
+function setProfileProvider(profilePath, provider) {
+	const markerPath = join(profilePath, PROFILE_PROVIDER_MARKER);
+	if (!existsSync(profilePath)) mkdirSync(profilePath, { recursive: true });
+	writeFileSync(markerPath, provider, "utf-8");
+}
+/**
+* Check if a profile has a provider mismatch.
+* Returns the existing provider if there's a mismatch, undefined otherwise.
+*/
+function checkProfileProviderMismatch(profilePath, targetProvider) {
+	if (!profilePath) return;
+	const existingProvider = getProfileProvider(profilePath);
+	if (existingProvider && existingProvider !== targetProvider) return existingProvider;
+}
+function browserRecordingOptions() {
+	return { outputDir: join(getAppDataDir(), "browser-recordings") };
+}
+/**
+* Snapshot of browser settings safe to store in session state (which session clients can read).
+* Strips credentials; keeps everything `/browser status` needs for drift detection.
+*/
+function toActiveBrowserSettings(settings) {
+	if (!settings.stagehand) return { ...settings };
+	const { apiKey: _apiKey, ...stagehand } = settings.stagehand;
+	return {
+		...settings,
+		stagehand
+	};
+}
+/**
+* Env vars Stagehand reads for each provider it can route (mirrors
+* `STAGEHAND_MODEL_PROVIDERS` in `@mastra/stagehand` and Stagehand's own
+* `providerEnvVarMap`). `null` means the provider needs no API key.
+* Kept here instead of importing `@mastra/stagehand`, which would eagerly
+* load the browser stack into every settings consumer.
+*/
+const STAGEHAND_PROVIDER_ENV_VARS = {
+	openai: ["OPENAI_API_KEY"],
+	anthropic: ["ANTHROPIC_API_KEY"],
+	google: [
+		"GEMINI_API_KEY",
+		"GOOGLE_GENERATIVE_AI_API_KEY",
+		"GOOGLE_API_KEY"
+	],
+	vertex: ["GOOGLE_VERTEX_AI_API_KEY"],
+	groq: ["GROQ_API_KEY"],
+	cerebras: ["CEREBRAS_API_KEY"],
+	togetherai: ["TOGETHER_AI_API_KEY"],
+	mistral: ["MISTRAL_API_KEY"],
+	deepseek: ["DEEPSEEK_API_KEY"],
+	perplexity: ["PERPLEXITY_API_KEY"],
+	azure: ["AZURE_API_KEY"],
+	xai: ["XAI_API_KEY"],
+	gateway: ["AI_GATEWAY_API_KEY"],
+	bedrock: null,
+	ollama: null
+};
+function hasCodexOAuthLogin(authStorage) {
+	return authStorage.get("openai-codex")?.type === "oauth";
+}
+function isOpenAIModel(modelId) {
+	return modelId.startsWith(OPENAI_PREFIX);
+}
+/**
+* Stagehand hands the segment after `provider/` straight to the AI SDK provider,
+* so apply the same id normalization the chat gateway does before it does.
+*/
+function normalizeForStagehand(modelId) {
+	const bare = stripMastraGatewayPrefix(modelId.trim());
+	return bare.startsWith("anthropic/") ? normalizeAnthropicModelId(bare) : bare;
+}
+/** Whether Stagehand could run `provider/model` with the credentials available right now. */
+function stagehandCanRoute(modelId, codexOAuth) {
+	const provider = modelId.split("/", 1)[0];
+	if (!provider || provider === modelId) return false;
+	if (provider === "openai" && codexOAuth) return true;
+	const envVars = STAGEHAND_PROVIDER_ENV_VARS[provider];
+	if (envVars === void 0) return false;
+	if (envVars === null) return true;
+	return envVars.some((name) => Boolean(process.env[name]?.trim()));
+}
+/**
+* Resolve which model Stagehand will use and why, without creating a browser.
+* Order: configured `browser.stagehand.model` → the launch-time chat model when
+* Stagehand can route it → the Codex login's default model → Stagehand's own
+* default. Mirrors the selection in `createBrowserFromSettings` so the UI can
+* show it.
+*/
+function resolveStagehandModel(settings, { chatModelId, authStorage = new AuthStorage() } = {}) {
+	if (settings.provider !== "stagehand") return {
+		modelName: void 0,
+		source: "stagehand-default",
+		viaCodexOAuth: false
+	};
+	const codexOAuth = hasCodexOAuthLogin(authStorage);
+	const configured = settings.stagehand?.model ? normalizeForStagehand(settings.stagehand.model) : void 0;
+	if (configured) return {
+		modelName: configured,
+		source: "settings",
+		viaCodexOAuth: codexOAuth && isOpenAIModel(configured)
+	};
+	const chatModel = chatModelId ? normalizeForStagehand(chatModelId) : void 0;
+	if (chatModel && stagehandCanRoute(chatModel, codexOAuth)) return {
+		modelName: chatModel,
+		source: "chat-model",
+		viaCodexOAuth: codexOAuth && isOpenAIModel(chatModel)
+	};
+	if (codexOAuth) return {
+		modelName: PROVIDER_DEFAULT_MODELS["openai-codex"],
+		source: "codex-oauth",
+		viaCodexOAuth: true
+	};
+	return {
+		modelName: void 0,
+		source: "stagehand-default",
+		viaCodexOAuth: false
+	};
+}
+/**
+* Create a browser instance from settings.
+* Shared by startup (main.ts) and live reconfiguration (/browser command).
+* Returns undefined if browser is disabled.
+*/
+async function createBrowserFromSettings(settings, { chatModelId } = {}) {
+	if (!settings.enabled) return;
+	const { provider, headless, viewport, cdpUrl, profile, executablePath, stagehand, agentBrowser } = settings;
+	const scope = profile ? "shared" : settings.scope;
+	const launchConfig = {
+		headless,
+		viewport,
+		profile,
+		executablePath,
+		scope
+	};
+	if (provider === "stagehand") {
+		const { StagehandBrowser } = await import("@mastra/stagehand");
+		const stagehandOpts = {
+			env: stagehand?.env ?? "LOCAL",
+			apiKey: stagehand?.apiKey ?? process.env.BROWSERBASE_API_KEY,
+			projectId: stagehand?.projectId ?? process.env.BROWSERBASE_PROJECT_ID,
+			preserveUserDataDir: stagehand?.preserveUserDataDir,
+			recording: browserRecordingOptions()
+		};
+		const authStorage = new AuthStorage();
+		const resolved = resolveStagehandModel(settings, {
+			chatModelId,
+			authStorage
+		});
+		if (resolved.modelName && resolved.viaCodexOAuth) {
+			const accountId = authStorage.get("openai-codex")?.accountId;
+			stagehandOpts.model = {
+				modelName: remapOpenAIModelForCodexOAuth(resolved.modelName),
+				apiKey: "codex-oauth",
+				baseURL: "https://chatgpt.com/backend-api/codex",
+				headers: {
+					originator: "mastracode",
+					"User-Agent": "mastracode",
+					...accountId ? { "ChatGPT-Account-ID": accountId } : {}
+				},
+				fetch: buildCodexStagehandFetch(authStorage),
+				middleware: createCodexMiddleware()
+			};
+		} else if (resolved.modelName) stagehandOpts.model = resolved.modelName;
+		return cdpUrl ? new StagehandBrowser({
+			...launchConfig,
+			cdpUrl,
+			scope: "shared",
+			...stagehandOpts
+		}) : new StagehandBrowser({
+			...launchConfig,
+			...stagehandOpts
+		});
+	} else if (provider === "agent-browser") {
+		const { AgentBrowser } = await import("@mastra/agent-browser");
+		const agentBrowserOpts = {
+			storageState: agentBrowser?.storageState,
+			recording: browserRecordingOptions()
+		};
+		return cdpUrl ? new AgentBrowser({
+			...launchConfig,
+			cdpUrl,
+			scope: "shared",
+			...agentBrowserOpts
+		}) : new AgentBrowser({
+			...launchConfig,
+			...agentBrowserOpts,
+			scope
+		});
+	}
+	throw new Error(`Unsupported browser provider: ${provider}`);
+}
+//#endregion
+export { ExperimentalAgentSettingsError, GITHUB_POLL_INTERVAL_DEFAULT_MS, GITHUB_POLL_INTERVAL_MAX_MS, GITHUB_POLL_INTERVAL_MIN_MS, MASTRA_GATEWAY_DEFAULT_URL, MASTRA_GATEWAY_PROVIDER, MEMORY_GATEWAY_DEFAULT_URL, MEMORY_GATEWAY_PROVIDER, OBSERVABILITY_AUTH_PREFIX, STAGEHAND_PROVIDER_ENV_VARS, STORAGE_DEFAULTS, THINKING_LEVEL_VALUES, THREAD_ACTIVE_MODEL_PACK_ID_KEY, THREAD_FALLBACK_STATUS_KEY, VIEWPORT_PRESETS, WEB_SEARCH_PROVIDER_VALUES, checkProfileProviderMismatch, createBrowserFromSettings, defaultVoiceEngine, findModePackForModel, getCustomProviderId, getProfileProvider, getSettingsPath, isThinkingLevelSetting, loadSettings, migrateAccountPreferences, migrateLegacyVariedPack, parseCustomProviders, parseExperimentalAgentSetting, parseThreadSettings, parseViewportInput, pruneRemovedAccountPreferences, resolveDefaultThinkingLevel, resolveLspSetting, resolveModePackModels, resolveModelDefaults, resolveOmModel, resolveOmRoleModel, resolveStagehandModel, resolveThreadActiveModelPackId, saveSettings, setProfileProvider, stripMastraCodeCustomProviderPrefix, toActiveBrowserSettings, toCustomProviderModelId };
+
+//# sourceMappingURL=settings.js.map