@mastra/code-sdk 0.0.0-livekit-beta-v3-20260709031728

package/dist/onboarding/settings.js

@@ -0,0 +1,594 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { AuthStorage } from "../auth/storage.js";
+import { buildCodexStagehandFetch, createCodexMiddleware } from "../providers/openai-codex.js";
+import { getAppDataDir } from "../utils/project.js";
+import { DEFAULT_STT_PROVIDER, resolveSTTModel } from "../voice/stt-registry.js";
+const MEMORY_GATEWAY_PROVIDER = "mastra-gateway";
+const MEMORY_GATEWAY_DEFAULT_URL = "https://gateway-api.mastra.ai";
+const OBSERVABILITY_AUTH_PREFIX = "observability:";
+const STORAGE_DEFAULTS = {
+  backend: "libsql",
+  libsql: {},
+  pg: {}
+};
+function defaultVoiceEngine() {
+  return process.platform === "darwin" ? "macos-native" : "cloud";
+}
+const DEFAULTS = {
+  onboarding: {
+    completedAt: null,
+    skippedAt: null,
+    version: 0,
+    modePackId: null,
+    omPackId: null,
+    quietModePreferenceSelected: true
+  },
+  models: {
+    activeModelPackId: null,
+    modeDefaults: {},
+    activeOmPackId: null,
+    omModelOverride: null,
+    observerModelOverride: null,
+    reflectorModelOverride: null,
+    omObservationThreshold: null,
+    omReflectionThreshold: null,
+    omCavemanObservations: null,
+    omObserveAttachments: null,
+    subagentModels: {},
+    goalJudgeModel: null,
+    goalMaxTurns: null
+  },
+  preferences: {
+    yolo: null,
+    theme: "auto",
+    thinkingLevel: "off",
+    quietMode: false,
+    quietModeMaxToolPreviewLines: 2
+  },
+  storage: { ...STORAGE_DEFAULTS },
+  customModelPacks: [],
+  customProviders: [],
+  modelUseCounts: {},
+  updateDismissedVersion: null,
+  memoryGateway: {},
+  lsp: {},
+  browser: {
+    enabled: false,
+    provider: "stagehand",
+    headless: false,
+    viewport: { width: 1280, height: 720 },
+    stagehand: { env: "LOCAL" }
+  },
+  shellPassthrough: { mode: "default" },
+  voice: { enabled: false, engine: defaultVoiceEngine(), provider: DEFAULT_STT_PROVIDER },
+  signals: { unixSocketPubSub: false, experimentalGithubSignals: false },
+  observability: { resources: {}, localTracing: false }
+};
+const THINKING_LEVEL_VALUES = ["off", "low", "medium", "high", "xhigh"];
+const QUIET_MODE_MAX_TOOL_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;
+}
+function parseThinkingLevel(value) {
+  return typeof value === "string" && THINKING_LEVEL_VALUES.includes(value) ? value : DEFAULTS.preferences.thinkingLevel;
+}
+function parseQuietModeMaxToolPreviewLines(value) {
+  const rawValue = typeof value === "number" && Number.isFinite(value) ? value : DEFAULTS.preferences.quietModeMaxToolPreviewLines;
+  return Math.min(QUIET_MODE_MAX_TOOL_PREVIEW_LINES_MAX, Math.max(0, Math.floor(rawValue)));
+}
+function parsePreferences(rawPreferences) {
+  const raw = rawPreferences && typeof rawPreferences === "object" ? rawPreferences : {};
+  return {
+    ...DEFAULTS.preferences,
+    ...raw,
+    thinkingLevel: parseThinkingLevel(raw.thinkingLevel),
+    quietModeMaxToolPreviewLines: parseQuietModeMaxToolPreviewLines(raw.quietModeMaxToolPreviewLines)
+  };
+}
+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
+  };
+}
+function hasQuietModePreferenceSelected(rawOnboarding) {
+  return Boolean(
+    rawOnboarding && typeof rawOnboarding === "object" && Object.prototype.hasOwnProperty.call(rawOnboarding, "quietModePreferenceSelected")
+  );
+}
+function applyQuietModePreferenceRollout(settings, rawOnboarding) {
+  if (hasQuietModePreferenceSelected(rawOnboarding)) return;
+  settings.onboarding.quietModePreferenceSelected = settings.preferences.quietMode === true;
+}
+function getNewInstallDefaults() {
+  const settings = structuredClone(DEFAULTS);
+  settings.preferences.quietMode = true;
+  settings.onboarding.quietModePreferenceSelected = true;
+  return settings;
+}
+function getSettingsPath() {
+  return join(getAppDataDir(), "settings.json");
+}
+function getCustomProviderId(name) {
+  const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "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}`;
+}
+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"]);
+function parseBrowserSettings(rawBrowser) {
+  const raw = rawBrowser && typeof rawBrowser === "object" ? rawBrowser : {};
+  const rawViewport = raw.viewport && typeof raw.viewport === "object" ? raw.viewport : {};
+  const rawStagehand = raw.stagehand && typeof raw.stagehand === "object" ? raw.stagehand : {};
+  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: {
+      width: typeof rawViewport.width === "number" ? rawViewport.width : DEFAULTS.browser.viewport.width,
+      height: typeof rawViewport.height === "number" ? rawViewport.height : DEFAULTS.browser.viewport.height
+    },
+    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() } : {},
+      ...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 provider = typeof raw.provider === "string" ? raw.provider : DEFAULTS.voice.provider;
+  const model = typeof raw.model === "string" ? raw.model : void 0;
+  const resolved = resolveSTTModel(provider, model);
+  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 };
+}
+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"));
+      settings = {
+        onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
+        models: { ...DEFAULTS.models, ...raw.models },
+        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: raw.lsp && typeof raw.lsp === "object" ? raw.lsp : void 0,
+        browser: parseBrowserSettings(raw.browser),
+        shellPassthrough: parseShellPassthroughSettings(raw.shellPassthrough),
+        voice: parseVoiceSettings(raw.voice),
+        signals: parseSignalSettings(raw.signals),
+        observability: parseObservabilitySettings(raw.observability)
+      };
+      applyQuietModePreferenceRollout(settings, raw.onboarding);
+    } 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 {
+    writeFileSync(authPath, JSON.stringify(authData, null, 2), "utf-8");
+  } 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";
+  const hasLegacyReference = settings.models.activeModelPackId === legacyPackId || settings.onboarding.modePackId === legacyPackId;
+  if (!hasLegacyReference) return false;
+  const existingIdx = settings.customModelPacks.findIndex((p) => p.name === "varied");
+  if (existingIdx >= 0) {
+    const existing = settings.customModelPacks[existingIdx];
+    const modelsMatch = Object.entries(LEGACY_VARIED_MODELS).every(([k, v]) => existing.models[k] === v);
+    if (!modelsMatch) {
+      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(getNewInstallDefaults());
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    const settings = {
+      ...raw,
+      onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
+      models: { ...DEFAULTS.models, ...raw.models },
+      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: raw.lsp && typeof raw.lsp === "object" ? raw.lsp : void 0,
+      browser: parseBrowserSettings(raw.browser),
+      shellPassthrough: parseShellPassthroughSettings(raw.shellPassthrough),
+      voice: parseVoiceSettings(raw.voice),
+      signals: parseSignalSettings(raw.signals),
+      observability: parseObservabilitySettings(raw.observability)
+    };
+    let settingsChanged = false;
+    if (!hasQuietModePreferenceSelected(raw.onboarding)) {
+      applyQuietModePreferenceRollout(settings, raw.onboarding);
+      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";
+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];
+  const activeModelPackId = typeof rawPackId === "string" && rawPackId.length > 0 ? rawPackId : null;
+  return {
+    activeModelPackId,
+    modeModelIds
+  };
+}
+function resolveThreadActiveModelPackId(settings, builtinPacks, metadata) {
+  const threadSettings = parseThreadSettings(metadata);
+  const isKnownPack = (packId) => {
+    if (packId.startsWith("custom:")) {
+      const name = packId.slice("custom:".length);
+      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);
+    const matches = packEntries.length === threadEntries.length && packEntries.every(([modeId, modelId]) => threadSettings.modeModelIds[modeId] === modelId);
+    if (matches) return pack.id;
+  }
+  if (settings.models.activeModelPackId && isKnownPack(settings.models.activeModelPackId)) {
+    return settings.models.activeModelPackId;
+  }
+  return null;
+}
+function resolveModelDefaults(settings, builtinPacks) {
+  const { activeModelPackId, modeDefaults } = settings.models;
+  if (!activeModelPackId) return modeDefaults;
+  if (activeModelPackId.startsWith("custom:")) {
+    const name = activeModelPackId.slice("custom:".length);
+    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 builtin.models;
+  return modeDefaults;
+}
+function resolveOmRoleModel(settings, role, builtinOmPacks) {
+  const { activeOmPackId, omModelOverride, observerModelOverride, reflectorModelOverride } = settings.models;
+  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;
+}
+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 currentRaw = JSON.parse(readFileSync(filePath, "utf-8"));
+    const currentSignals = parseSignalSettings(currentRaw.signals);
+    if (!signalSettingsEqual(currentSignals, loadedSignals)) {
+      return currentSignals;
+    }
+  } catch {
+  }
+  return settings.signals;
+}
+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));
+  writeFileSync(filePath, JSON.stringify(settings, null, 2), "utf-8");
+}
+const PROFILE_PROVIDER_MARKER = ".mastra-provider";
+function getProfileProvider(profilePath) {
+  const markerPath = join(profilePath, PROFILE_PROVIDER_MARKER);
+  if (!existsSync(markerPath)) {
+    return void 0;
+  }
+  try {
+    const content = readFileSync(markerPath, "utf-8").trim();
+    if (content === "stagehand" || content === "agent-browser") {
+      return content;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setProfileProvider(profilePath, provider) {
+  const markerPath = join(profilePath, PROFILE_PROVIDER_MARKER);
+  if (!existsSync(profilePath)) {
+    mkdirSync(profilePath, { recursive: true });
+  }
+  writeFileSync(markerPath, provider, "utf-8");
+}
+function checkProfileProviderMismatch(profilePath, targetProvider) {
+  if (!profilePath) {
+    return void 0;
+  }
+  const existingProvider = getProfileProvider(profilePath);
+  if (existingProvider && existingProvider !== targetProvider) {
+    return existingProvider;
+  }
+  return void 0;
+}
+function browserRecordingOptions() {
+  return { outputDir: join(getAppDataDir(), "browser-recordings") };
+}
+async function createBrowserFromSettings(settings) {
+  if (!settings.enabled) {
+    return void 0;
+  }
+  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 cred = authStorage.get("openai-codex");
+    if (cred?.type === "oauth") {
+      const accountId = cred.accountId;
+      stagehandOpts.model = {
+        modelName: "openai/gpt-5.4-mini",
+        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()
+      };
+    }
+    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}`);
+}
+export {
+  MEMORY_GATEWAY_DEFAULT_URL,
+  MEMORY_GATEWAY_PROVIDER,
+  OBSERVABILITY_AUTH_PREFIX,
+  STORAGE_DEFAULTS,
+  THREAD_ACTIVE_MODEL_PACK_ID_KEY,
+  checkProfileProviderMismatch,
+  createBrowserFromSettings,
+  defaultVoiceEngine,
+  getCustomProviderId,
+  getProfileProvider,
+  getSettingsPath,
+  loadSettings,
+  migrateLegacyVariedPack,
+  parseCustomProviders,
+  parseThreadSettings,
+  resolveModelDefaults,
+  resolveOmModel,
+  resolveOmRoleModel,
+  resolveThreadActiveModelPackId,
+  saveSettings,
+  setProfileProvider,
+  toCustomProviderModelId
+};
+//# sourceMappingURL=settings.js.map