nolo-cli 0.148.0-alpha.1 → 0.151.0-alpha.2

package/{chunk-DCFPQW22.js → chunk-Z7OJUX6S.js}

@@ -1,21 +1,121 @@
 import {
   toolRegistry
-} from "./chunk-2JMMBU6V.js";
+} from "./chunk-Y2DXOPSO.js";
 import {
-  i18n_default
-} from "./chunk-42Z3EMC4.js";
+  runtime_default
+} from "./chunk-556RW72X.js";
 import {
   canonicalizeToolNames
-} from "./chunk-XUWRURDF.js";
+} from "./chunk-5EBLANFT.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   isNoloHostedProvider
-} from "./chunk-Y3PMXGLH.js";
+} from "./chunk-CHCS6XPJ.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
+
+// packages/ai/chat/inlineImageUrlsForCustomProvider.ts
+var INLINE_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
+var INLINE_IMAGE_TOTAL_MAX_BYTES = 20 * 1024 * 1024;
+var FILE_CONTENT_PATH = "/api/v1/db/file/content/";
+var shouldInlineImageUrlsForAgent = (agentConfig) => {
+  const apiSource = agentConfig?.apiSource?.toLowerCase();
+  const provider = agentConfig?.provider?.toLowerCase();
+  const model = agentConfig?.model?.toLowerCase();
+  if (apiSource === "custom" || provider === "custom") return true;
+  if (isNoloHostedProvider(provider)) return true;
+  return provider === "openrouter" && model === "minimax/minimax-m3";
+};
+var isInlineCandidate = (url) => /^https?:\/\//i.test(url) && url.includes(FILE_CONTENT_PATH);
+var bytesToBase64 = (bytes) => {
+  const chunks = [];
+  for (let offset = 0; offset < bytes.length; offset += 32768) {
+    chunks.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(offset, offset + 32768))));
+  }
+  return btoa(chunks.join(""));
+};
+var defaultFetchImage = async (url, signal, _maxBytes) => {
+  const response = await fetch(url, { signal });
+  if (!response.ok) {
+    return {
+      ok: false,
+      error: `HTTP ${response.status}`
+    };
+  }
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  return {
+    ok: true,
+    mimeType: response.headers.get("content-type") ?? "application/octet-stream",
+    bytes
+  };
+};
+var cloneImagePartWithDataUrl = async (part, fetchImage, options, usedBytes) => {
+  const url = part?.image_url?.url;
+  if (typeof url !== "string" || !isInlineCandidate(url) || options.isAllowedImageUrl && !options.isAllowedImageUrl(url)) return part;
+  if (options.signal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
+  const remaining = options.maxTotalBytes === void 0 ? void 0 : options.maxTotalBytes - usedBytes.value;
+  const fetchLimit = options.maxBytes === void 0 ? remaining : remaining === void 0 ? options.maxBytes : Math.min(options.maxBytes, remaining);
+  const result = await fetchImage(url, options.signal, fetchLimit);
+  if (options.signal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
+  if (result.skippedSize !== void 0) {
+    const reason = options.maxBytes !== void 0 && result.skippedSize > options.maxBytes ? "per-image" : "total-budget";
+    options.onSkipTooLarge?.(url, result.skippedSize, reason);
+    return part;
+  }
+  if (!result.ok || !result.bytes) return part;
+  if (options.maxBytes !== void 0 && result.bytes.byteLength > options.maxBytes) {
+    options.onSkipTooLarge?.(url, result.bytes.byteLength, "per-image");
+    return part;
+  }
+  if (options.maxTotalBytes !== void 0 && usedBytes.value + result.bytes.byteLength > options.maxTotalBytes) {
+    options.onSkipTooLarge?.(url, result.bytes.byteLength, "total-budget");
+    return part;
+  }
+  usedBytes.value += result.bytes.byteLength;
+  const mimeType = (result.mimeType || "application/octet-stream").split(";")[0].trim() || "application/octet-stream";
+  return { ...part, image_url: { ...part.image_url, url: `data:${mimeType};base64,${bytesToBase64(result.bytes)}` } };
+};
+var inlineImageUrlsForCustomProvider = async (bodyData, options) => {
+  if (!options.shouldInline) return bodyData;
+  const body = bodyData;
+  if (!Array.isArray(body?.messages)) return bodyData;
+  const fetchImage = options.fetchImage ?? defaultFetchImage;
+  const fetched = /* @__PURE__ */ new Map();
+  const fetchOnce = (url, signal, maxBytes) => {
+    let result = fetched.get(url);
+    if (!result) {
+      result = fetchImage(url, signal, maxBytes);
+      fetched.set(url, result);
+    }
+    return result;
+  };
+  const usedBytes = { value: 0 };
+  let changed = false;
+  const messages = [...body.messages];
+  for (let mi = messages.length - 1; mi >= 0; mi--) {
+    const message = messages[mi];
+    if (!Array.isArray(message?.content)) continue;
+    const content = [...message.content];
+    for (let pi = content.length - 1; pi >= 0; pi--) {
+      const part = content[pi];
+      if (part?.type !== "image_url") continue;
+      if (options.maxTotalBytes !== void 0 && usedBytes.value >= options.maxTotalBytes) {
+        if (typeof part?.image_url?.url === "string" && isInlineCandidate(part.image_url.url)) options.onSkipTooLarge?.(part.image_url.url, void 0, "total-budget");
+        continue;
+      }
+      const cloned = await cloneImagePartWithDataUrl(part, fetchOnce, options, usedBytes);
+      if (cloned !== part) {
+        content[pi] = cloned;
+        changed = true;
+      }
+    }
+    if (content.some((part, index) => part !== message.content[index])) messages[mi] = { ...message, content };
+  }
+  return changed ? { ...body, messages } : bodyData;
+};
 
 // packages/ai/tools/toolSchemaCompatibility.ts
 var COMPOSITION_KEYS = ["anyOf", "oneOf", "allOf"];
@@ -63,12 +163,12 @@ var PREPARE_TOOLS_CACHE_LIMIT = 128;
 var warnedUnknownToolNames = /* @__PURE__ */ new Set();
 function getTranslation(keys, defaultVal) {
   for (const key of keys) {
-    if (i18n_default.exists(key)) {
-      return i18n_default.t(key);
+    if (runtime_default.exists(key)) {
+      return runtime_default.t(key);
     }
     const aiKey = key.startsWith("ai:") ? key : `ai:${key}`;
-    if (i18n_default.exists(aiKey)) {
-      return i18n_default.t(aiKey);
+    if (runtime_default.exists(aiKey)) {
+      return runtime_default.t(aiKey);
     }
   }
   return defaultVal;
@@ -115,7 +215,7 @@ function translateSchema(schema) {
   return nextSchema;
 }
 function currentI18nLanguage() {
-  return typeof i18n_default.language === "string" ? i18n_default.language : "";
+  return typeof runtime_default.language === "string" ? runtime_default.language : "";
 }
 function translateSchemaCached(schema) {
   if (!schema || typeof schema !== "object") return schema;
@@ -128,10 +228,11 @@ function translateSchemaCached(schema) {
   translatedFunctionCache.set(cacheKey, translated);
   return translated;
 }
-function buildPrepareToolsCacheKey(toolNames, disabledToolNames, provider) {
+function buildPrepareToolsCacheKey(toolNames, disabledToolNames, provider, selectableRuntimeCount) {
   return [
     currentI18nLanguage(),
     provider ?? "",
+    selectableRuntimeCount !== void 0 ? String(selectableRuntimeCount) : "",
     disabledToolNames.join(""),
     toolNames.join("")
   ].join("\0");
@@ -148,13 +249,15 @@ function rememberPrepareToolsResult(key, value) {
 var prepareTools = (toolNames, options) => {
   const disabledList = canonicalizeToolNames(options?.disabledToolNames ?? []);
   const disabledToolNames = new Set(disabledList);
-  const canonicalNames = canonicalizeToolNames(toolNames).filter(
-    (toolName) => !disabledToolNames.has(toolName)
+  const selectableCount = typeof options?.selectableRuntimeCount === "number" ? options.selectableRuntimeCount : typeof options?.runtimeCatalog?.selectableCount === "number" ? options.runtimeCatalog.selectableCount : void 0;
+  const canonicalNames = canonicalizeToolNames(toolNames).filter((toolName) => !disabledToolNames.has(toolName)).filter(
+    (toolName) => !(selectableCount !== void 0 && selectableCount <= 1 && toolName === "listRuntimes")
   );
   const cacheKey = buildPrepareToolsCacheKey(
     canonicalNames,
     disabledList,
-    options?.provider
+    options?.provider,
+    selectableCount
   );
   const cached = prepareToolsResultCache.get(cacheKey);
   if (cached) {
@@ -180,96 +283,8 @@ var prepareTools = (toolNames, options) => {
   return prepared.slice();
 };
 
-// packages/ai/chat/inlineImageUrlsForCustomProvider.ts
-var FILE_CONTENT_PATH = "/api/v1/db/file/content/";
-var shouldInlineImageUrlsForAgent = (agentConfig) => {
-  const apiSource = agentConfig?.apiSource?.toLowerCase();
-  const provider = agentConfig?.provider?.toLowerCase();
-  const model = agentConfig?.model?.toLowerCase();
-  if (apiSource === "custom" || provider === "custom") return true;
-  if (isNoloHostedProvider(provider)) return true;
-  return provider === "openrouter" && model === "minimax/minimax-m3";
-};
-var isInlineCandidate = (url) => /^https?:\/\//i.test(url) && url.includes(FILE_CONTENT_PATH);
-var bytesToBase64 = (bytes) => {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary);
-};
-var defaultFetchImage = async (url) => {
-  const response = await fetch(url);
-  if (!response.ok) {
-    return {
-      ok: false,
-      error: `HTTP ${response.status}`
-    };
-  }
-  const bytes = new Uint8Array(await response.arrayBuffer());
-  return {
-    ok: true,
-    mimeType: response.headers.get("content-type") ?? "application/octet-stream",
-    bytes
-  };
-};
-var cloneImagePartWithDataUrl = async (part, fetchImage, isAllowedImageUrl) => {
-  const url = part?.image_url?.url;
-  if (typeof url !== "string" || !isInlineCandidate(url) || isAllowedImageUrl && !isAllowedImageUrl(url)) {
-    return part;
-  }
-  const result = await fetchImage(url);
-  if (!result.ok || !result.bytes) return part;
-  const mimeType = result.mimeType || "application/octet-stream";
-  return {
-    ...part,
-    image_url: {
-      ...part.image_url,
-      url: `data:${mimeType};base64,${bytesToBase64(result.bytes)}`
-    }
-  };
-};
-var inlineImageUrlsForCustomProvider = async (bodyData, options) => {
-  if (!options.shouldInline) return bodyData;
-  const body = bodyData;
-  if (!Array.isArray(body?.messages)) return bodyData;
-  const fetchImage = options.fetchImage ?? defaultFetchImage;
-  let changed = false;
-  const messages = [];
-  for (const message of body.messages) {
-    if (!Array.isArray(message?.content)) {
-      messages.push(message);
-      continue;
-    }
-    const content = await Promise.all(
-      message.content.map(async (part) => {
-        if (part?.type !== "image_url") return part;
-        return cloneImagePartWithDataUrl(
-          part,
-          fetchImage,
-          options.isAllowedImageUrl
-        );
-      })
-    );
-    let messageChanged = false;
-    for (let i = 0; i < content.length; i++) {
-      if (content[i] !== message.content[i]) {
-        changed = true;
-        messageChanged = true;
-        break;
-      }
-    }
-    messages.push(messageChanged ? { ...message, content } : message);
-  }
-  if (!changed) return bodyData;
-  return {
-    ...body,
-    messages
-  };
-};
-
 export {
-  prepareTools,
   shouldInlineImageUrlsForAgent,
-  inlineImageUrlsForCustomProvider
+  inlineImageUrlsForCustomProvider,
+  prepareTools
 };

package/chunk-ZEZC7IIM.js

@@ -0,0 +1,126 @@
+// packages/connector-experimental/codexBinary.ts
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var WINDOWS_APPS_CODEX_PATTERN = /\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\resources$/i;
+function pathEntries(env) {
+  return (env.PATH ?? process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+}
+function findWindowsAppsCodex(env) {
+  if (process.platform !== "win32") return "";
+  for (const entry of pathEntries(env)) {
+    if (!WINDOWS_APPS_CODEX_PATTERN.test(entry)) continue;
+    const candidate = join(entry, "codex.exe");
+    if (existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+function copyCodexToUserBin(source, env) {
+  const target = env.NOLO_CODEX_SHIM_PATH ?? join(homedir(), ".nolo", "bin", "codex.exe");
+  if (existsSync(target)) return target;
+  mkdirSync(dirname(target), { recursive: true });
+  copyFileSync(source, target);
+  return target;
+}
+function resolveLaunchableCodexCommand(env = process.env) {
+  const explicit = env.NOLO_CODEX_BIN?.trim();
+  if (explicit) return explicit;
+  const windowsAppsCodex = findWindowsAppsCodex(env);
+  if (windowsAppsCodex) return copyCodexToUserBin(windowsAppsCodex, env);
+  return "codex";
+}
+
+// packages/connector-experimental/cliProcessEnv.ts
+import { execSync } from "child_process";
+function readMacSystemProxyEnv() {
+  if (process.platform !== "darwin") return {};
+  try {
+    const raw = String(execSync("scutil --proxy", { encoding: "utf8" }) || "");
+    const values = /* @__PURE__ */ new Map();
+    for (const line of raw.split("\n")) {
+      const match = line.match(/^\s*([A-Za-z0-9_]+)\s*:\s*(.+?)\s*$/);
+      if (!match) continue;
+      values.set(match[1], match[2].replace(/^"|"$/g, ""));
+    }
+    const httpEnabled = values.get("HTTPEnable") === "1";
+    const httpsEnabled = values.get("HTTPSEnable") === "1";
+    const httpHost = values.get("HTTPProxy")?.trim();
+    const httpsHost = values.get("HTTPSProxy")?.trim();
+    const httpPort = values.get("HTTPPort")?.trim();
+    const httpsPort = values.get("HTTPSPort")?.trim();
+    const noProxy = values.get("ExceptionsList")?.trim();
+    const httpProxy = httpEnabled && httpHost && httpPort ? `http://${httpHost}:${httpPort}` : "";
+    const httpsProxy = httpsEnabled && httpsHost && httpsPort ? `http://${httpsHost}:${httpsPort}` : "";
+    const allProxy = httpsProxy || httpProxy;
+    return {
+      ...httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {},
+      ...httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {},
+      ...allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {},
+      ...noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+function normalizeProxyEnv(env) {
+  const explicitHttp = env.HTTP_PROXY?.trim() || env.http_proxy?.trim() || "";
+  const explicitHttps = env.HTTPS_PROXY?.trim() || env.https_proxy?.trim() || "";
+  const explicitAll = env.ALL_PROXY?.trim() || env.all_proxy?.trim() || "";
+  const explicitNoProxy = env.NO_PROXY?.trim() || env.no_proxy?.trim() || "";
+  const fallback = explicitHttp || explicitHttps || explicitAll ? {} : readMacSystemProxyEnv();
+  const httpProxy = explicitHttp || fallback.HTTP_PROXY || fallback.http_proxy || "";
+  const httpsProxy = explicitHttps || fallback.HTTPS_PROXY || fallback.https_proxy || httpProxy;
+  const allProxy = explicitAll || fallback.ALL_PROXY || fallback.all_proxy || httpsProxy || httpProxy;
+  const noProxy = explicitNoProxy || fallback.NO_PROXY || fallback.no_proxy || "";
+  return {
+    ...env,
+    ...httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {},
+    ...httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {},
+    ...allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {},
+    ...noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}
+  };
+}
+function buildCliProcessEnv(extraEnv) {
+  const baseEnv = {
+    ...process.env,
+    ...extraEnv,
+    NO_COLOR: "1"
+  };
+  if (process.platform === "darwin") {
+    const defaultMacPaths = [
+      `${process.env.HOME || ""}/.local/bin`,
+      "/opt/homebrew/bin",
+      "/opt/homebrew/sbin",
+      "/usr/local/bin",
+      "/usr/local/sbin",
+      `${process.env.HOME || ""}/.bun/bin`,
+      `${process.env.HOME || ""}/Library/pnpm`,
+      `${process.env.HOME || ""}/.npm-global/bin`,
+      `${process.env.HOME || ""}/bin`
+    ];
+    const existingPath = baseEnv.PATH || "/usr/bin:/bin:/usr/sbin:/sbin";
+    const paths = existingPath.split(":");
+    for (const p of defaultMacPaths) {
+      if (p && !paths.includes(p)) {
+        paths.unshift(p);
+      }
+    }
+    baseEnv.PATH = paths.join(":");
+  }
+  if (baseEnv.HOME) {
+    const delimiter = process.platform === "win32" ? ";" : ":";
+    const openCodeBin = `${baseEnv.HOME}/.opencode/bin`;
+    const paths = (baseEnv.PATH || "").split(delimiter);
+    if (!paths.includes(openCodeBin)) baseEnv.PATH = [...paths, openCodeBin].filter(Boolean).join(delimiter);
+  }
+  return Object.fromEntries(
+    Object.entries(normalizeProxyEnv(baseEnv)).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  );
+}
+
+export {
+  resolveLaunchableCodexCommand,
+  buildCliProcessEnv
+};

package/{chunk-ALGORS6Y.js → chunk-ZF6526IQ.js}

@@ -1,10 +1,15 @@
 import {
   buildLocalAgentLookupKeys,
+  classifyAgentApiKeyRef,
+  formatUnsupportedAgentApiKeyRefMessage,
   shouldReadAgentKeyRemotely
-} from "./chunk-OTGFTBLI.js";
+} from "./chunk-UUPR3TD7.js";
 import {
   resolveCliAgentKeyInput
-} from "./chunk-SV5IJK6K.js";
+} from "./chunk-NBTY7YJF.js";
+import {
+  createAgentKey
+} from "./chunk-5EMSBTQ6.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -19,9 +24,6 @@ import {
   readPipeText,
   spawnProcess
 } from "./chunk-Y6ROFCZO.js";
-import {
-  createAgentKey
-} from "./chunk-3AH7LNUB.js";
 
 // packages/cli/agentRecordHelpers.ts
 import { readFileSync } from "node:fs";
@@ -231,7 +233,14 @@ async function deleteDbRecord(args) {
   }
   return data;
 }
+function assertSupportedAgentApiKeyRef(record) {
+  const verdict = classifyAgentApiKeyRef(record?.apiKeyRef);
+  if (!verdict.ok) {
+    throw new Error(formatUnsupportedAgentApiKeyRefMessage(verdict.ref));
+  }
+}
 async function writeAgentRecord(args) {
+  assertSupportedAgentApiKeyRef(args.record);
   const res = await fetchWithTransportFallback(`${args.serverUrl}/api/v1/db/write/`, {
     method: "POST",
     headers: {
@@ -252,6 +261,30 @@ async function writeAgentRecord(args) {
     throw new Error(`write failed: HTTP ${res.status} ${JSON.stringify(data)}`);
   }
 }
+async function invalidateAgentRecordCache(args) {
+  const invalidated = [];
+  for (const key of new Set(args.keys.filter((k) => typeof k === "string" && k))) {
+    try {
+      await args.db.del(key);
+      invalidated.push(key);
+    } catch {
+    }
+  }
+  return invalidated;
+}
+async function refreshAgentRecordCache(args) {
+  try {
+    await args.db.put(args.agentKey, {
+      ...args.record,
+      dbKey: args.agentKey,
+      key: args.record?.key || args.agentKey,
+      serverOrigin: args.serverOrigin,
+      cachedAt: Date.now()
+    });
+  } catch {
+    await invalidateAgentRecordCache({ db: args.db, keys: [args.agentKey] });
+  }
+}
 async function resolveAgentRecordFromHybridStore(args) {
   const agentKey = resolveCliAgentKeyInput(args.agentInput);
   const authToken = args.cliArgs ? resolveAuthToken(args.cliArgs, args.env) : resolveAuthToken(args.env);
@@ -484,7 +517,7 @@ function parseAgentUpdateArgs(args) {
   );
   const expiresAt = parseIsoTimestampOption(readOption(args, "--expires-at"), "--expires-at");
   const handle = readOption(args, "--handle")?.trim();
-  const promptSources = [prompt, promptFile, promptDoc].filter(Boolean);
+  const promptSources = [prompt, promptFile, promptDoc].filter((value) => value !== void 0);
   if (promptSources.length > 1) {
     throw new Error("--prompt / --prompt-file / --prompt-doc are mutually exclusive.");
   }
@@ -492,7 +525,7 @@ function parseAgentUpdateArgs(args) {
   if (cliProvider) updates.cliProvider = cliProvider;
   if (apiSource) updates.apiSource = apiSource;
   if (provider) updates.provider = provider;
-  if (prompt) updates.prompt = prompt;
+  if (prompt !== void 0) updates.prompt = prompt;
   if (promptFile) updates.prompt = readFileSync(promptFile, "utf8");
   if (tools) updates.tools = parseJsonishValue(tools);
   if (name) updates.name = name;
@@ -523,7 +556,7 @@ async function buildCreatedAgentRecord(args) {
   const resolvedAgentInput = resolveCliAgentKeyInput(args.parsed.agentInput);
   const agentKey = resolvedAgentInput.startsWith("agent-") ? resolvedAgentInput : createAgentKey.private(userId || "local", resolvedAgentInput);
   if (args.parsed.presetId) {
-    const { resolveProviderPresetFields } = await import("./providerPresetApply-DD6NGWW6.js");
+    const { resolveProviderPresetFields } = await import("./providerPresetApply-MY66I6NT.js");
     const fields = resolveProviderPresetFields(args.parsed.presetId);
     if (fields.kind === "manual") {
       throw new Error(
@@ -668,6 +701,8 @@ export {
   queryUserRecords,
   deleteDbRecord,
   writeAgentRecord,
+  invalidateAgentRecordCache,
+  refreshAgentRecordCache,
   resolveAgentRecordFromHybridStore,
   agentRecordHasConfiguredCredential,
   sanitizeAgentRecordForCliOutput,

package/chunk-ZIWPQEFU.js

@@ -0,0 +1,165 @@
+import {
+  noloAgentId
+} from "./chunk-GKXCHNTE.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+
+// packages/app/theme/fontPreference.ts
+var FONT_PRESET_ALIASES = {
+  system: "system",
+  default: "system",
+  hei: "hei",
+  heiti: "hei",
+  sans: "hei",
+  song: "song",
+  songti: "song",
+  serif: "song",
+  kai: "kai",
+  kaiti: "kai",
+  "kai-ti": "kai",
+  "fang-song": "fang-song",
+  fangsong: "fang-song",
+  "fang song": "fang-song"
+};
+var normalizeFontPreset = (value) => {
+  const normalized = asTrimmedLowercaseString(value);
+  if (!Object.hasOwn(FONT_PRESET_ALIASES, normalized)) return void 0;
+  return FONT_PRESET_ALIASES[normalized];
+};
+
+// packages/ai/policy/types.ts
+var DEFAULT_AGENT_BASE_POLICY = {
+  version: 1,
+  tone: {
+    preset: "default",
+    resolutionMode: "blend"
+  },
+  knowledgeCaptureMaxLevel: 4,
+  spaceContextMaxLevel: 4,
+  selfEvolutionMode: "knowledge_only"
+};
+var DEFAULT_USER_PREFERENCE_PROFILE = {
+  version: 1,
+  tone: {
+    preset: "default"
+  },
+  knowledgeCaptureLevel: 2,
+  spaceContextLevel: 3
+};
+
+// packages/app/settings/settingTypes.ts
+var SYSTEM_DEFAULT_AGENT_ID = "system-default";
+
+// packages/app/settings/settingNormalizers.ts
+var hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
+var normalizeDefaultAgentIdSetting = (value) => {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  return value === noloAgentId || value === SYSTEM_DEFAULT_AGENT_ID ? SYSTEM_DEFAULT_AGENT_ID : value;
+};
+var normalizeAuthorityHomeServerSetting = (value) => {
+  const normalized = normalizeServerOrigin(value);
+  return /^https?:\/\//i.test(normalized) ? normalized : null;
+};
+var normalizeTonePresetSetting = (value) => {
+  switch (value) {
+    case "professional":
+    case "friendly":
+    case "direct":
+    case "pragmatic":
+    case "default":
+      return value;
+    default:
+      return DEFAULT_USER_PREFERENCE_PROFILE.tone?.preset ?? "default";
+  }
+};
+var normalizePolicyLevelSetting = (value, fallback) => {
+  const n = Number(value);
+  if (n === 1 || n === 2 || n === 3 || n === 4) {
+    return n;
+  }
+  return fallback;
+};
+var resolveDefaultAgentIdSetting = (value) => normalizeDefaultAgentIdSetting(value) ?? SYSTEM_DEFAULT_AGENT_ID;
+var omitKeys = (record, keys) => {
+  const next = { ...record };
+  keys.forEach((key) => {
+    delete next[key];
+  });
+  return next;
+};
+var isRecordLike = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var normalizeSystemBuiltinSkills = (value, defaults) => {
+  const base = isRecordLike(value) ? value : {};
+  const result = { ...defaults };
+  for (const key of Object.keys(base)) {
+    result[key] = Boolean(base[key]);
+  }
+  return result;
+};
+
+// packages/ai/policy/selfUpdateFields.ts
+var AGENT_UPDATE_FIELD_NAMES = [
+  "name",
+  "handle",
+  "model",
+  "provider",
+  "prompt",
+  "introduction",
+  "greeting",
+  "isPublic",
+  "tags",
+  "tools",
+  "references",
+  "temperature",
+  "top_p",
+  "frequency_penalty",
+  "presence_penalty",
+  "max_tokens",
+  "reasoning_effort"
+];
+var PRIMARY_AUTO_APPROVE_SELF_UPDATE_FIELDS = [
+  "greeting",
+  "introduction",
+  "tags"
+];
+var DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS = [
+  ...PRIMARY_AUTO_APPROVE_SELF_UPDATE_FIELDS
+];
+var VALID_AGENT_UPDATE_FIELDS = new Set(AGENT_UPDATE_FIELD_NAMES);
+var normalizeAgentUpdateFieldList = (value, fallback = DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS) => {
+  if (!Array.isArray(value)) {
+    return [...fallback];
+  }
+  const normalized = Array.from(
+    new Set(
+      value.filter(
+        (item) => typeof item === "string" && VALID_AGENT_UPDATE_FIELDS.has(item)
+      )
+    )
+  );
+  return normalized;
+};
+
+export {
+  normalizeFontPreset,
+  DEFAULT_AGENT_BASE_POLICY,
+  DEFAULT_USER_PREFERENCE_PROFILE,
+  AGENT_UPDATE_FIELD_NAMES,
+  DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS,
+  normalizeAgentUpdateFieldList,
+  SYSTEM_DEFAULT_AGENT_ID,
+  hasOwn,
+  normalizeDefaultAgentIdSetting,
+  normalizeAuthorityHomeServerSetting,
+  normalizeTonePresetSetting,
+  normalizePolicyLevelSetting,
+  resolveDefaultAgentIdSetting,
+  omitKeys,
+  normalizeSystemBuiltinSkills
+};