nolo-cli 0.108.0-alpha.2 → 0.108.1

package/{chunk-42V6BK2E.js → chunk-6MXDOUMH.js}

@@ -1,8 +1,9 @@
 import {
-  mergeAvailabilityDeadline
-} from "./chunk-FDTR4QJ6.js";
+  mergeAvailabilityDeadline,
+  resolveCredentialKeyWithFallback
+} from "./chunk-3MZAGMYY.js";
 
-// packages/cli/credentialAvailability.ts
+// packages/agent-runtime/credentialAvailability.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -13,36 +14,6 @@ function resolveNoloHome(env = process.env) {
 function resolveCredentialAvailabilityPath(env = process.env) {
   return join(resolveNoloHome(env), FILE_NAME);
 }
-function resolveCredentialKey(agent) {
-  if (!agent || typeof agent !== "object") return void 0;
-  for (const field of ["apiKeyRef", "credentialRef"]) {
-    const value = agent[field];
-    if (typeof value === "string") {
-      const trimmed = value.trim();
-      if (trimmed) return trimmed;
-    }
-  }
-  return void 0;
-}
-function resolveCredentialKeyWithFallback(agent) {
-  const byRef = resolveCredentialKey(agent);
-  if (byRef) return byRef;
-  if (!agent || typeof agent !== "object") return void 0;
-  const endpoint = agent.customProviderUrl;
-  if (typeof endpoint === "string") {
-    const trimmed = endpoint.trim();
-    if (trimmed) {
-      try {
-        const origin = new URL(trimmed).origin;
-        if (origin && origin !== "null") return `custom-endpoint:${origin}`;
-      } catch {
-      }
-    }
-  }
-  const key = agent.key;
-  if (typeof key === "string" && key.trim()) return `custom-agent:${key.trim()}`;
-  return void 0;
-}
 function parseFile(raw) {
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object") return { entries: {} };
@@ -80,12 +51,14 @@ function normalizeEntry(entry) {
   if (!entry || typeof entry !== "object") return void 0;
   const at = entry.nextAvailableAt;
   if (typeof at !== "number" || !Number.isFinite(at)) return void 0;
+  const marked = entry.markedAt;
+  const markedAt = typeof marked === "number" && Number.isFinite(marked) ? { markedAt: marked } : {};
   if ("lastProbeAt" in entry) {
     const probe = entry.lastProbeAt;
     if (typeof probe !== "number" || !Number.isFinite(probe)) return void 0;
-    return { nextAvailableAt: at, lastProbeAt: probe };
+    return { nextAvailableAt: at, ...markedAt, lastProbeAt: probe };
   }
-  return { nextAvailableAt: at };
+  return { nextAvailableAt: at, ...markedAt };
 }
 async function readCredentialAvailability(env = process.env, now = Date.now()) {
   const entries = await readCredentialEntries(env, now);
@@ -117,10 +90,19 @@ async function markCredentialUnavailable(credentialKey, nextAvailableAt, env = p
   if (typeof merged !== "number" || !Number.isFinite(merged)) return;
   live[credentialKey] = {
     nextAvailableAt: merged,
+    markedAt: now,
     ...existing?.lastProbeAt !== void 0 ? { lastProbeAt: existing.lastProbeAt } : {}
   };
   await writeCredentialAvailability(live, env);
 }
+async function clearCredentialAvailabilityIfMarkedAt(credentialKey, expectedMarkedAt, env = process.env, now = Date.now()) {
+  if (!credentialKey) return;
+  const live = await readCredentialEntries(env, now);
+  const existing = live[credentialKey];
+  if (!existing || existing.markedAt !== expectedMarkedAt) return;
+  delete live[credentialKey];
+  await writeCredentialAvailability(live, env);
+}
 async function clearCredentialAvailability(credentialKey, env = process.env, now = Date.now()) {
   if (!credentialKey) return;
   const live = await readCredentialEntries(env, now);
@@ -155,10 +137,10 @@ function applyCredentialAvailability(agents, credentialAvailability) {
 }
 
 export {
-  resolveCredentialKeyWithFallback,
   readCredentialAvailability,
   readCredentialEntry,
   markCredentialUnavailable,
+  clearCredentialAvailabilityIfMarkedAt,
   clearCredentialAvailability,
   recordCredentialProbe,
   applyCredentialAvailability

package/{chunk-QOKAKDPE.js → chunk-6Q7UTJKR.js}

@@ -1,6 +1,12 @@
+import {
+  createClientLogger
+} from "./chunk-QQ56R7KS.js";
 import {
   isLevelNotFoundError
 } from "./chunk-OW765XBU.js";
+import {
+  isAbortError
+} from "./chunk-7DPNBQSV.js";
 import {
   API_ENDPOINTS,
   NOLO_CLUSTER_SERVERS,
@@ -20,97 +26,6 @@ var isDevelopment = !isProduction;
 var getIsDesktopApp = () => (typeof process !== "undefined" ? process.env?.NOLO_DESKTOP : processEnv?.NOLO_DESKTOP) === "1" || typeof window !== "undefined" && window.__NOLO_DESKTOP__ === true;
 var isDesktopApp = getIsDesktopApp();
 
-// packages/core/clientLogger.ts
-var LOG_LEVELS = {
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40
-};
-var serializeValue = (value, seen = /* @__PURE__ */ new WeakSet()) => {
-  if (value instanceof Error) {
-    return {
-      name: value.name,
-      message: value.message,
-      ...value.stack ? { stack: value.stack } : {}
-    };
-  }
-  if (typeof value !== "object" || value === null) {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  }
-  if (seen.has(value)) {
-    return "[Circular]";
-  }
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      return value.map((item) => serializeValue(item, seen));
-    }
-    return Object.fromEntries(
-      Object.entries(value).map(([key, item]) => [key, serializeValue(item, seen)])
-    );
-  } finally {
-    seen.delete(value);
-  }
-};
-var getLogLevel = () => {
-  const configured = typeof process !== "undefined" && typeof process.env?.NOLO_LOG_LEVEL === "string" ? process.env.NOLO_LOG_LEVEL : "info";
-  return LOG_LEVELS[configured] ?? LOG_LEVELS.info;
-};
-var writeLog = (level, name, fields, message) => {
-  if (LOG_LEVELS[level] < getLogLevel()) {
-    return;
-  }
-  const serializedFields = serializeValue(fields);
-  const payload = {
-    level,
-    ...name ? { name } : {},
-    ...serializedFields,
-    ...message ? { msg: message } : {}
-  };
-  const output = JSON.stringify(payload);
-  const isNodeRuntime = typeof process !== "undefined" && typeof process.stderr?.write === "function";
-  if (isNodeRuntime) {
-    process.stderr.write(`${output}
-`);
-    return;
-  }
-  const consoleMethod = console[level] ?? console.log;
-  if (Object.keys(fields).length === 0 && message) {
-    consoleMethod(`[${name}] ${message}`);
-  } else {
-    consoleMethod(output);
-  }
-};
-var parseArgs = (first, second) => {
-  if (typeof first === "string") {
-    return { fields: {}, message: first };
-  }
-  return { fields: first ?? {}, message: second };
-};
-var createClientLogger = (name, parentFields = {}) => {
-  const log = (level, first, second) => {
-    const { fields, message } = parseArgs(first, second);
-    writeLog(level, name, { ...parentFields, ...fields }, message);
-  };
-  return {
-    debug: (first, second) => log("debug", first, second),
-    info: (first, second) => log("info", first, second),
-    warn: (first, second) => log("warn", first, second),
-    error: (first, second) => log("error", first, second),
-    child: (fields) => createClientLogger(name, { ...parentFields, ...fields })
-  };
-};
-
-// packages/core/abortError.ts
-function isAbortError(error) {
-  if (!error || typeof error !== "object") return false;
-  return error.name === "AbortError";
-}
-
 // packages/app/utils/retryFetch.ts
 var TRANSIENT_READ_RETRY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
 var DEFAULT_RETRY_DELAYS_MS = [300, 1e3];
@@ -258,11 +173,8 @@ var normalizeTimeFields = (data) => ({
 });
 
 export {
-  isProduction,
   isDevelopment,
   getIsDesktopApp,
-  createClientLogger,
-  isAbortError,
   logger,
   getAllServers,
   fetchFromClientDb,

package/{chunk-J4MOO56S.js → chunk-6VRWNU5J.js}

@@ -153,6 +153,13 @@ function slateToSimplifiedMarkdown(nodes, options = {}) {
 }
 
 // packages/ai/tools/readDocTool.ts
+var resolvePageReadMarkdown = (pageData) => {
+  const slateData = pageData.slateData;
+  if (Array.isArray(slateData) && slateData.length > 0) {
+    return slateToSimplifiedMarkdown(slateData);
+  }
+  return typeof pageData.content === "string" ? pageData.content : "";
+};
 var readDocFunctionSchema = {
   name: "readDoc",
   description: [
@@ -175,7 +182,7 @@ var readPageFunctionSchema = {
   name: "readPage"
 };
 var buildReadDocResult = (pageData) => {
-  const markdownContent = slateToSimplifiedMarkdown(pageData.slateData || []);
+  const markdownContent = resolvePageReadMarkdown(pageData);
   const rawData = {
     success: true,
     id: pageData.dbKey,
@@ -199,7 +206,7 @@ async function readDocFunc(args, thunkApi) {
     throw new Error(`\u65E0\u6548\u7684\u9875\u9762 ID: ${id}\u3002\u9875\u9762 ID \u901A\u5E38\u4EE5 "page-" \u5F00\u5934\u3002`);
   }
   try {
-    const { readAction } = await import("./read-COE3ZYR6.js");
+    const { readAction } = await import("./read-RNUQ7F34.js");
     const pageData = await readAction({ dbKey: id }, thunkApi);
     if (!pageData) {
       throw new Error(`\u672A\u627E\u5230 ID \u4E3A ${id} \u7684\u9875\u9762\u3002`);
@@ -213,6 +220,7 @@ var readPageFunc = readDocFunc;
 
 export {
   slateToSimplifiedMarkdown,
+  resolvePageReadMarkdown,
   readDocFunctionSchema,
   readPageFunctionSchema,
   buildReadDocResult,

package/{chunk-IQPFGYO3.js → chunk-726TCFLQ.js}

@@ -2,16 +2,16 @@ import {
   deleteDbRecord,
   queryUserRecords,
   readDbRecord
-} from "./chunk-LWKP7AWH.js";
+} from "./chunk-A337PRRR.js";
 import {
   mergeAndDedupUserData
-} from "./chunk-KQHGZWSV.js";
+} from "./chunk-OXME3PEE.js";
+import {
+  isTombstoneRecord
+} from "./chunk-D2MDMY2M.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
-import {
-  isTombstoneRecord
-} from "./chunk-GBRG75BQ.js";
 
 // packages/cli/globalRecordOperations.ts
 async function listUserRecordsFromServers(args) {

package/{chunk-CW67PN7L.js → chunk-7B3BVGU3.js}

@@ -1,21 +1,28 @@
 import {
-  clearCliLocalRuntimePreparedAgentCache
-} from "./chunk-UDIIVXKA.js";
+  refreshSubscriptionQuotas
+} from "./chunk-U4STABYN.js";
 import {
   getReadableCliDb
-} from "./chunk-LS2ZANRJ.js";
+} from "./chunk-V6WXGTUJ.js";
 import {
   buildCreatedAgentRecord,
   buildUpdatedAgentRecord,
   normalizeAgentRecordForOutput,
   parseAgentUpdateArgs,
+  refreshAgentRecordCache,
   resolveAgentRecordFromHybridStore,
   sanitizeAgentRecordForCliOutput,
   writeAgentRecord
-} from "./chunk-LWKP7AWH.js";
+} from "./chunk-A337PRRR.js";
+import {
+  clearCliLocalRuntimePreparedAgentCache
+} from "./chunk-KWEDNOZZ.js";
+import {
+  readCredentialAvailability
+} from "./chunk-6MXDOUMH.js";
 import {
   resolveCliAgentKeyInput
-} from "./chunk-SV5IJK6K.js";
+} from "./chunk-NBTY7YJF.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -67,8 +74,32 @@ async function runAgentReadCommand(args, deps = {}) {
     if (!result) {
       throw new Error(`agent not found: ${agentKey}`);
     }
+    const rawRecord = result.record;
+    const recordQuota = rawRecord?.quota;
+    const hasSubscriptionCredential = typeof rawRecord?.apiKeyRef === "string" && rawRecord.apiKeyRef.trim() !== "";
+    const fresh = hasSubscriptionCredential ? await refreshSubscriptionQuotas({
+      entries: [{ key: result.agentKey, ...recordQuota ? { quota: recordQuota } : {} }],
+      onlyKeys: [result.agentKey],
+      env,
+      cliArgs: args,
+      fetchImpl
+    }) : {};
+    const quota = fresh[result.agentKey] ?? recordQuota;
+    const rawRecordObj = result.record;
+    const credAvail = await readCredentialAvailability(env).catch(() => ({}));
+    const credGroup = typeof rawRecordObj?.apiKeyRef === "string" ? rawRecordObj.apiKeyRef : void 0;
+    const credDeadline = credGroup ? credAvail[credGroup] : void 0;
+    const recordDeadline = typeof rawRecordObj?.nextAvailableAt === "number" ? rawRecordObj.nextAvailableAt : void 0;
+    const effectiveNextAvailableAt = Math.max(recordDeadline ?? 0, credDeadline ?? 0) || void 0;
+    const isRateLimited = typeof effectiveNextAvailableAt === "number" && effectiveNextAvailableAt > Date.now();
     output.write(JSON.stringify({
       ...normalizeAgentRecordForOutput(result.agentKey, authToken, result.record),
+      ...isRateLimited ? {
+        rateLimited: true,
+        cooldownRemainingSeconds: Math.ceil((effectiveNextAvailableAt - Date.now()) / 1e3),
+        nextAvailableAt: new Date(effectiveNextAvailableAt).toISOString()
+      } : {},
+      ...quota ? { quota } : {},
       source: result.source
     }, null, 2));
     output.write("\n");
@@ -130,10 +161,10 @@ async function runAgentUpdateCommand(args, deps = {}) {
       userId,
       record: built.nextRecord
     });
-    await db.put(built.agentKey, {
-      ...built.nextRecord,
-      dbKey: built.agentKey,
-      key: built.nextRecord?.key || built.agentKey,
+    await refreshAgentRecordCache({
+      db,
+      agentKey: built.agentKey,
+      record: built.nextRecord,
       serverOrigin: built.serverUrl
     });
     clearCliLocalRuntimePreparedAgentCache();
@@ -212,7 +243,7 @@ async function runAgentCreateCommand(args, deps = {}) {
     clearCliLocalRuntimePreparedAgentCache();
     let verifyResult;
     if (parsed.verify) {
-      const { verifyCustomProvider } = await import("./agentProviderCommands-X3UNW77C.js");
+      const { verifyCustomProvider } = await import("./agentProviderCommands-7PCGR77I.js");
       const rec = built.nextRecord;
       verifyResult = await verifyCustomProvider({
         providerUrl: rec.customProviderUrl,
@@ -222,15 +253,34 @@ async function runAgentCreateCommand(args, deps = {}) {
         fetchImpl
       });
     }
+    const apiKeyRef = String(built.updates?.apiKeyRef || "").trim();
+    let authHint;
+    const OAUTH_REFS = /* @__PURE__ */ new Set(["claude", "chatgpt", "xai", "antigravity", "cloudflare"]);
+    if (apiKeyRef && OAUTH_REFS.has(apiKeyRef)) {
+      try {
+        const { createOAuthTokenStore } = await import("./oauthTokenStore-PADKLNOC.js");
+        const store = createOAuthTokenStore();
+        if (!store.read(apiKeyRef)) {
+          authHint = `Subscription "${apiKeyRef}" is not authorized yet. Run \`nolo auth ${apiKeyRef}\` to log in.`;
+        }
+      } catch {
+      }
+    }
     output.write(JSON.stringify({
       ok: true,
       agentKey: built.agentKey,
       baseUrl: built.serverUrl,
       updates: sanitizeAgentRecordForCliOutput(built.updates),
       record: sanitizeAgentRecordForCliOutput(built.nextRecord),
-      ...verifyResult ? { verify: verifyResult } : {}
+      ...verifyResult ? { verify: verifyResult } : {},
+      ...authHint ? { hint: authHint } : {}
     }, null, 2));
     output.write("\n");
+    if (authHint) {
+      const errorOutput = deps.error ?? process.stderr;
+      errorOutput.write(`[nolo] Hint: ${authHint}
+`);
+    }
     return 0;
   } catch (error) {
     output.write(

package/chunk-7DPNBQSV.js

@@ -0,0 +1,9 @@
+// packages/core/abortError.ts
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.name === "AbortError";
+}
+
+export {
+  isAbortError
+};

package/{chunk-LWKP7AWH.js → chunk-A337PRRR.js}

@@ -1,17 +1,16 @@
 import {
   buildLocalAgentLookupKeys,
   shouldReadAgentKeyRemotely
-} from "./chunk-Z77CRGTW.js";
+} from "./chunk-PHHFVGOJ.js";
 import {
   resolveCliAgentKeyInput
-} from "./chunk-SV5IJK6K.js";
+} from "./chunk-NBTY7YJF.js";
+import {
+  createAgentKey
+} from "./chunk-RLRYVSCD.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
-import {
-  readPipeText,
-  spawnProcess
-} from "./chunk-X7HHHIOZ.js";
 import {
   parseUserIdFromAuthToken,
   readOption,
@@ -20,8 +19,9 @@ import {
   resolveServerUrl
 } from "./chunk-A7GB5UGH.js";
 import {
-  createAgentKey
-} from "./chunk-VMFTFOWF.js";
+  readPipeText,
+  spawnProcess
+} from "./chunk-Y6ROFCZO.js";
 
 // packages/cli/agentRecordHelpers.ts
 import { readFileSync } from "node:fs";
@@ -252,6 +252,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 +508,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 +516,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;
@@ -511,7 +535,7 @@ function parseAgentUpdateArgs(args) {
     updates[entry.slice(0, index)] = parseJsonishValue(entry.slice(index + 1));
   }
   if (Object.keys(updates).length === 0) {
-    if (!promptDoc && !copyProviderFrom) {
+    if (!promptDoc && !copyProviderFrom && !presetId) {
       throw new Error("No updates provided. Use --model / --cli-provider / --api-source / --field key=value.");
     }
   }
@@ -523,21 +547,19 @@ 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-XI3WUPTI.js");
+    const { resolveProviderPresetFields } = await import("./providerPresetApply-HIPK67DU.js");
     const fields = resolveProviderPresetFields(args.parsed.presetId);
     if (fields.kind === "manual") {
       throw new Error(
         `unknown --preset "${args.parsed.presetId}". Run \`nolo agent providers\` to list preset ids.`
       );
     }
-    if (fields.kind === "oauth" || fields.requiresDesktopOAuth) {
-      throw new Error(
-        `--preset "${args.parsed.presetId}" is an OAuth subscription; create it in Nolo Desktop (OAuth login required).`
-      );
-    }
     const u = args.parsed.updates;
     u.apiSource = "custom";
     u.provider = u.provider ?? fields.provider;
+    if (fields.apiKeyRef && !u.apiKeyRef) {
+      u.apiKeyRef = fields.apiKeyRef;
+    }
     if (fields.customProviderUrl && !u.customProviderUrl) {
       u.customProviderUrl = fields.customProviderUrl;
     }
@@ -670,6 +692,8 @@ export {
   queryUserRecords,
   deleteDbRecord,
   writeAgentRecord,
+  invalidateAgentRecordCache,
+  refreshAgentRecordCache,
   resolveAgentRecordFromHybridStore,
   agentRecordHasConfiguredCredential,
   sanitizeAgentRecordForCliOutput,

package/chunk-AGIM7IMJ.js

@@ -0,0 +1,147 @@
+// packages/create/editor/utils/slateUtils.ts
+var slateNodeToString = (node) => {
+  if (typeof node?.text === "string") return node.text;
+  const children = Array.isArray(node?.children) ? node.children : [];
+  return children.map(slateNodeToString).join("");
+};
+var createEmptyParagraph = () => ({
+  type: "paragraph",
+  children: [{ text: "" }]
+});
+var ensureEditorContent = (slateData) => Array.isArray(slateData) && slateData.length > 0 ? slateData : [createEmptyParagraph()];
+var deepEqual = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  const isArrayA = Array.isArray(a);
+  const isArrayB = Array.isArray(b);
+  if (isArrayA || isArrayB) {
+    if (!isArrayA || !isArrayB) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+};
+var compareSlateContent = (newContent, oldContent) => {
+  if (newContent === oldContent) return false;
+  if (!newContent || !oldContent) return true;
+  if (newContent.length !== oldContent.length) return true;
+  return !deepEqual(newContent, oldContent);
+};
+var extractTitleFromSlate = (slateData) => {
+  if (!Array.isArray(slateData) || slateData.length === 0) return "\u65B0\u9875\u9762";
+  const titleNode = slateData.find((node) => node.type === "heading-one");
+  if (titleNode) {
+    const text = slateNodeToString(titleNode).trim();
+    if (text) {
+      return text;
+    }
+  }
+  for (const node of slateData) {
+    const text = slateNodeToString(node).trim();
+    if (text) {
+      return text.length > 30 ? `${text.substring(0, 30)}...` : text;
+    }
+  }
+  return "\u65B0\u9875\u9762";
+};
+var splitSlateTitleAndBody = (slateData, explicitTitle) => {
+  const content = ensureEditorContent(slateData);
+  const firstNode = content[0];
+  const hasExplicitTitle = explicitTitle !== void 0 && explicitTitle !== null;
+  const normalizedExplicitTitle = hasExplicitTitle ? explicitTitle.trim() : null;
+  const firstNonEmptyText = content.map((node) => slateNodeToString(node).trim()).find(Boolean);
+  if (firstNode?.type === "heading-one") {
+    const firstText = slateNodeToString(firstNode).trim();
+    const shouldTreatAsTitle = !!firstText && (normalizedExplicitTitle == null || normalizedExplicitTitle === firstText);
+    if (shouldTreatAsTitle) {
+      const body = content.slice(1);
+      return {
+        title: firstText,
+        body: ensureEditorContent(body)
+      };
+    }
+  }
+  return {
+    title: normalizedExplicitTitle ?? (firstNonEmptyText || ""),
+    body: content
+  };
+};
+var extractMentionsFromSlate = (slateData) => {
+  const tools = /* @__PURE__ */ new Set();
+  const traverse = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "mention" && node.resourceId) {
+        if (node.resourceType === "tool") {
+          tools.add(node.resourceId);
+        }
+      }
+      if (node.children && Array.isArray(node.children)) {
+        traverse(node.children);
+      }
+    }
+  };
+  if (Array.isArray(slateData)) {
+    traverse(slateData);
+  }
+  return Array.from(tools);
+};
+var extractCategorizedMentions = (slateData) => {
+  const result = {
+    tools: [],
+    pages: [],
+    agents: [],
+    spaces: []
+  };
+  const traverse = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "mention" && node.resourceId && node.resourceType) {
+        switch (node.resourceType) {
+          case "tool":
+            result.tools.push(node.resourceId);
+            break;
+          case "page":
+            result.pages.push(node.resourceId);
+            break;
+          case "agent":
+            result.agents.push(node.resourceId);
+            break;
+          case "space":
+            result.spaces.push(node.resourceId);
+            break;
+        }
+      }
+      if (node.children && Array.isArray(node.children)) {
+        traverse(node.children);
+      }
+    }
+  };
+  if (Array.isArray(slateData)) {
+    traverse(slateData);
+  }
+  result.tools = [...new Set(result.tools)];
+  result.pages = [...new Set(result.pages)];
+  result.agents = [...new Set(result.agents)];
+  result.spaces = [...new Set(result.spaces)];
+  return result;
+};
+
+export {
+  createEmptyParagraph,
+  ensureEditorContent,
+  compareSlateContent,
+  extractTitleFromSlate,
+  splitSlateTitleAndBody,
+  extractMentionsFromSlate,
+  extractCategorizedMentions
+};