nolo-cli 0.108.0-alpha.2 → 0.108.1

package/chunk-IN5UVHHP.js

@@ -0,0 +1,843 @@
+import {
+  clipMultilineText,
+  fetchAndSerializeTable,
+  waitForAbortableDelay
+} from "./chunk-JONVI6DK.js";
+import {
+  isGatewayHttpStatus
+} from "./chunk-NF64D32W.js";
+import {
+  createDrainExhaustedResponse,
+  isCoreDrainingBody,
+  normalizeNonNegativeMs,
+  parseRetryAfterHeaderMs
+} from "./chunk-XPWGOTBQ.js";
+import {
+  resolvePageReadMarkdown,
+  slateToSimplifiedMarkdown
+} from "./chunk-6VRWNU5J.js";
+import {
+  extractCategorizedMentions
+} from "./chunk-AGIM7IMJ.js";
+import {
+  fetchAndCacheMessages
+} from "./chunk-2DRYS3G3.js";
+import {
+  createSpaceKey
+} from "./chunk-UAD2WT54.js";
+import {
+  read
+} from "./chunk-RNNWTMKT.js";
+import {
+  getRuntimeServerContext
+} from "./chunk-4YRTZIVN.js";
+import {
+  extractRuntimePageCapabilities,
+  resolveBuiltinSkillPage,
+  resolveSkillGraphFromRoots
+} from "./chunk-RRQQAG7W.js";
+import {
+  isAbortError
+} from "./chunk-7DPNBQSV.js";
+import {
+  extractCustomId
+} from "./chunk-M2EJHDJP.js";
+import {
+  estimateTokenCount
+} from "./chunk-PSCNXBYA.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  wrapHistoricalSummaryWithReplayGuard
+} from "./chunk-4VJAC32I.js";
+
+// packages/ai/chat/parseApiError.ts
+var CONTEXT_OVERFLOW_ACTIONS = [
+  "compact-and-retry",
+  "new-dialog",
+  "switch-model",
+  "retry"
+];
+var CONTEXT_TOO_LARGE_ACTIONS = [
+  "new-dialog",
+  "switch-model",
+  "retry"
+];
+var truncateErrorMessage = (message, maxChars = 320) => message.length <= maxChars ? message : `${message.slice(0, maxChars)}\u2026`;
+var isContextOverflowText = (message) => /maximum context|context (length|window|overflow|limit)|context_length_exceed\w*|requested about .*tokens|too many tokens|prompt is too long|exceeds? (the )?(model|max)/i.test(
+  message
+);
+function classifyApiError(input) {
+  const { status, message, body, code } = input;
+  const errorMessage = message;
+  let defaultMessage = `\u72B6\u6001\u7801 ${status} ${input.statusText ?? ""}`;
+  switch (status) {
+    case 400:
+      if (isContextOverflowText(errorMessage) || isContextOverflowText(body) || code === "UPSTREAM_400") {
+        return {
+          kind: "context_overflow",
+          message: "\u4E0A\u4E0B\u6587\u8FC7\u957F\uFF1A\u672C\u8F6E\u6D88\u606F\u6216\u5DE5\u5177\u7ED3\u679C\u592A\u5927\u3002\u8BF7\u7F29\u5C0F\u8303\u56F4\uFF0C\u6216\u5148\u8BFB\u53D6\u66F4\u5C0F\u7247\u6BB5\u540E\u518D\u7EE7\u7EED\u3002",
+          code,
+          status,
+          retryable: true,
+          actions: [...CONTEXT_OVERFLOW_ACTIONS]
+        };
+      }
+      if (code === "MISSING_PROVIDER_API_KEY") {
+        return {
+          kind: "generic",
+          message: truncateErrorMessage(errorMessage),
+          code,
+          status,
+          retryable: false
+        };
+      }
+      if (errorMessage && errorMessage !== defaultMessage) {
+        return {
+          kind: "generic",
+          message: `\u8BF7\u6C42\u53C2\u6570\u9519\u8BEF: ${truncateErrorMessage(errorMessage)}`,
+          code,
+          status,
+          retryable: false
+        };
+      }
+      return { kind: "generic", message: "\u8BF7\u6C42\u53C2\u6570\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u8F93\u5165", code, status, retryable: false };
+    case 413:
+      return {
+        kind: "context_too_large",
+        message: "\u8BF7\u6C42\u5185\u5BB9\u8FC7\u5927\uFF1A\u8BF7\u51CF\u5C11\u4E00\u6B21\u53D1\u9001\u7684\u6D88\u606F\u3001\u6587\u4EF6\u6216\u5DE5\u5177\u7ED3\u679C\u3002",
+        code,
+        status,
+        retryable: true,
+        actions: [...CONTEXT_TOO_LARGE_ACTIONS]
+      };
+    case 401:
+      return {
+        kind: "auth",
+        message: code === "AUTH_TOKEN_EXPIRED" ? "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u5148\u767B\u51FA\u540E\u91CD\u65B0\u767B\u5F55" : code === "AUTH_ACCOUNT_INVALID" ? "\u8D26\u6237\u65E0\u6548\u6216\u5DF2\u88AB\u505C\u7528\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458" : code === "AUTH_NO_TOKEN" ? "\u672A\u68C0\u6D4B\u5230\u767B\u5F55\u72B6\u6001\uFF0C\u8BF7\u5148\u767B\u5F55" : code === "AUTH_INVALID_TOKEN" ? "\u767B\u5F55\u51ED\u8BC1\u65E0\u6548\uFF0C\u8BF7\u5148\u767B\u51FA\u540E\u91CD\u65B0\u767B\u5F55" : code === "AUTH_TOKEN_NOT_ACTIVE" ? "\u4EE4\u724C\u5C1A\u672A\u751F\u6548\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5" : errorMessage && errorMessage !== `\u72B6\u6001\u7801 401 Unauthorized` ? `\u8BA4\u8BC1\u9519\u8BEF: ${truncateErrorMessage(errorMessage)}` : "\u8EAB\u4EFD\u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u5148\u767B\u51FA\u540E\u91CD\u65B0\u767B\u5F55",
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+    case 503:
+      return {
+        kind: "server",
+        message: errorMessage && errorMessage !== `\u72B6\u6001\u7801 503 Service Unavailable` ? truncateErrorMessage(errorMessage) : "\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+    case 504:
+      return {
+        kind: "timeout",
+        message: "\u8BF7\u6C42\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+    default:
+      return {
+        kind: "generic",
+        message: `API\u8BF7\u6C42\u5931\u8D25: ${truncateErrorMessage(errorMessage)}`,
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+  }
+}
+async function parseApiErrorInfo(response) {
+  const errorBody = await response.text();
+  let errorMessage = `\u72B6\u6001\u7801 ${response.status} ${response.statusText}`;
+  let errorCode = `E${response.status}`;
+  try {
+    const errorJson = JSON.parse(errorBody);
+    errorMessage = errorJson?.error?.message || errorJson?.message || errorJson?.msg || errorBody || errorMessage;
+    errorCode = errorJson?.error?.code || errorJson?.code || errorCode;
+  } catch (_e) {
+    if (errorBody) {
+      errorMessage = errorBody;
+    }
+  }
+  return classifyApiError({
+    status: response.status,
+    statusText: response.statusText,
+    message: errorMessage,
+    body: errorBody,
+    code: errorCode
+  });
+}
+async function parseApiError(response) {
+  return (await parseApiErrorInfo(response)).message;
+}
+function classifyGenerationError(data, status) {
+  const error = data?.error ?? data;
+  const upstreamStatus = error?.status ?? data?.status;
+  if (status === void 0 && typeof upstreamStatus === "number") status = upstreamStatus;
+  const rawCode = error?.code ?? data?.code;
+  const code = typeof rawCode === "string" && /^[a-zA-Z0-9_.:-]{1,80}$/.test(rawCode) && !/^(sk-|Bearer|AIza)/i.test(rawCode) ? rawCode : void 0;
+  const message = typeof error?.message === "string" ? error.message : typeof error?.msg === "string" ? error.msg : typeof data === "string" ? data : "";
+  const evidence = `${code ?? ""} ${message}`;
+  let category = "config_protocol";
+  if (/content[_ -]filter|content[_ -]policy|safety[_ -](?:violation|blocked)|policy[_ -]violation|prohibited[_ -]content/i.test(evidence)) {
+    category = "policy";
+  } else if (/thought_signature|reasoning_effort|not supported|invalid[_ -](?:request|argument)|authentication|api[_ -]key/i.test(evidence) || status === 401 || status === 403) {
+    category = "config_protocol";
+  } else if (code === "EMPTY_RESPONSE" || /空响应|empty response/i.test(message)) {
+    category = "empty";
+  } else if (status === 408 || status === 429 || status !== void 0 && status >= 500 || /timeout|timed out|秒内没有返回新内容|network|fetch failed|failed to fetch|ECONNRESET|ECONNREFUSED|EPIPE|socket hang up|connection (?:reset|closed)|rate[_ -]limit|overloaded|temporarily unavailable|internal_server_error|service_unavailable/i.test(evidence)) {
+    category = "transient";
+  }
+  const messages = {
+    config_protocol: "\u6A21\u578B\u914D\u7F6E\u6216\u5DE5\u5177\u901A\u4FE1\u4E0D\u517C\u5BB9\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u68C0\u67E5\u914D\u7F6E\uFF1B\u91CD\u590D\u53D1\u9001\u4E0D\u4F1A\u89E3\u51B3\u6B64\u95EE\u9898\u3002",
+    empty: "\u6A21\u578B\u8FD4\u56DE\u4E86\u7A7A\u54CD\u5E94\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u68C0\u67E5\u670D\u52A1\u54CD\u5E94\u3002",
+    policy: "\u670D\u52A1\u5546\u7684\u5185\u5BB9\u5B89\u5168\u89C4\u5219\u963B\u6B62\u4E86\u672C\u6B21\u8BF7\u6C42\u3002\u8BF7\u68C0\u67E5\u8BF7\u6C42\u662F\u5426\u7B26\u5408\u5176\u89C4\u5219\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u91CD\u8BD5\u6216\u6539\u5199\u5185\u5BB9\u3002",
+    transient: "\u6A21\u578B\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\u3002\u4F60\u53EF\u4EE5\u7A0D\u540E\u624B\u52A8\u91CD\u8BD5\u540C\u4E00\u6A21\u578B\uFF08\u65B0\u8BF7\u6C42\u53EF\u80FD\u4EA7\u751F\u8D39\u7528\uFF09\u3002"
+  };
+  return {
+    category,
+    message: messages[category],
+    retryable: category === "transient",
+    actions: category === "transient" ? ["retry"] : [],
+    diagnostic: { ...code ? { code } : {}, ...status ? { status } : {} }
+  };
+}
+
+// packages/ai/chat/serverProxyRetry.ts
+var DEFAULT_SERVER_PROXY_RETRY_AFTER_MS = 1500;
+var MAX_SERVER_PROXY_RETRIES = 2;
+var MAX_STATUS_RETRIES = 3;
+var MAX_SERVER_DRAIN_STATUS_RETRIES = 30;
+var readRetryableResponseBody = async (response) => {
+  try {
+    return await response.clone().json();
+  } catch {
+    return null;
+  }
+};
+var resolveServerProxyRetryAfterMs = (response, body) => parseRetryAfterHeaderMs(response.headers.get("Retry-After")) ?? normalizeNonNegativeMs(
+  body?.retryAfterMs,
+  DEFAULT_SERVER_PROXY_RETRY_AFTER_MS
+);
+var isRetryableServerProxyFetchError = (error) => {
+  if (!error || isAbortError(error)) return false;
+  const message = typeof error?.message === "string" ? error.message : String(error);
+  return /ECONNREFUSED|ECONNRESET|EPIPE|socket hang up|network error|failed to fetch|fetch failed|connection closed|load failed|502|503|504/i.test(
+    message
+  );
+};
+var waitForServerProxyRetry = async (retryAfterMs, signal) => {
+  const delayMs = normalizeNonNegativeMs(
+    retryAfterMs,
+    DEFAULT_SERVER_PROXY_RETRY_AFTER_MS
+  );
+  if (delayMs <= 0) return;
+  await waitForAbortableDelay(delayMs, signal);
+};
+var performServerProxyFetchWithRetry = async ({
+  execute,
+  signal,
+  logPrefix = "[fetchWithServerProxy]",
+  onRetry,
+  retryNetworkErrors = true
+}) => {
+  let networkRetries = 0;
+  let statusRetries = 0;
+  while (true) {
+    try {
+      const response = await execute();
+      const responseBody = isGatewayHttpStatus(response.status) ? await readRetryableResponseBody(response) : null;
+      const isCoreDraining = response.status === 503 && isCoreDrainingBody(responseBody);
+      const maxStatusRetries = isCoreDraining ? MAX_SERVER_DRAIN_STATUS_RETRIES : MAX_STATUS_RETRIES;
+      const classified = classifyGenerationError(responseBody, response.status);
+      if (classified.category === "transient" && statusRetries < maxStatusRetries && isGatewayHttpStatus(response.status)) {
+        statusRetries += 1;
+        const retryAfterMs = resolveServerProxyRetryAfterMs(
+          response,
+          responseBody
+        );
+        console.warn(
+          `${logPrefix} \u68C0\u6D4B\u5230${response.status}\u72B6\u6001\uFF0C${retryAfterMs}ms\u540E\u91CD\u8BD5...`
+        );
+        onRetry?.({
+          attempt: statusRetries,
+          maxAttempts: maxStatusRetries,
+          delayMs: retryAfterMs
+        });
+        await waitForServerProxyRetry(retryAfterMs, signal);
+        continue;
+      }
+      if (isCoreDraining) {
+        console.warn(`${logPrefix} core_draining \u91CD\u8BD5\u8017\u5C3D\uFF0C\u8FD4\u56DE\u53CB\u597D\u63D0\u793A`);
+        return createDrainExhaustedResponse(response);
+      }
+      return response;
+    } catch (error) {
+      if (retryNetworkErrors && networkRetries < MAX_SERVER_PROXY_RETRIES && isRetryableServerProxyFetchError(error)) {
+        networkRetries += 1;
+        const retryDelay = networkRetries * 1e3;
+        console.warn(
+          `${logPrefix} \u68C0\u6D4B\u5230\u7F51\u7EDC\u77AC\u65AD\uFF0C${retryDelay}ms\u540E\u91CD\u8BD5(\u7B2C${networkRetries}\u6B21)...`,
+          error
+        );
+        onRetry?.({
+          attempt: networkRetries,
+          maxAttempts: MAX_SERVER_PROXY_RETRIES,
+          delayMs: retryDelay
+        });
+        await waitForServerProxyRetry(retryDelay, signal);
+        continue;
+      }
+      throw error;
+    }
+  }
+};
+
+// packages/ai/agent/referenceUtils.ts
+function mergeReferences(base, extra) {
+  const safeBase = Array.isArray(base) ? base : [];
+  const safeExtra = Array.isArray(extra) ? extra : [];
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const item of [...safeBase, ...safeExtra]) {
+    const key = item.dbKey;
+    if (key && seen.has(key)) continue;
+    if (key) seen.add(key);
+    merged.push(item);
+  }
+  return merged;
+}
+var loadContentsByKeys = async (keys, dispatch, preloaded) => {
+  const contentByKey = /* @__PURE__ */ new Map();
+  const uniqueKeys = Array.from(new Set(keys.filter(Boolean)));
+  await Promise.all(
+    uniqueKeys.map(async (dbKey) => {
+      if (preloaded?.has(dbKey)) {
+        const content = preloaded.get(dbKey);
+        if (content) contentByKey.set(dbKey, content);
+        return;
+      }
+      const builtin = resolveBuiltinSkillPage(dbKey);
+      if (builtin) {
+        contentByKey.set(dbKey, builtin);
+        return;
+      }
+      try {
+        const content = await dispatch(read({ dbKey })).unwrap();
+        if (content) contentByKey.set(dbKey, content);
+      } catch {
+      }
+    })
+  );
+  return contentByKey;
+};
+var resolveReferenceAssets = async (references, dispatch) => {
+  if (!Array.isArray(references) || references.length === 0) {
+    return {
+      references: [],
+      referencedTools: [],
+      recommendedSkillTools: [],
+      recommendedSkillHints: [],
+      skillPromptPatches: [],
+      contentByKey: /* @__PURE__ */ new Map()
+    };
+  }
+  const entries = await Promise.all(
+    references.filter((ref) => ref?.dbKey).map(async (ref) => {
+      const builtin = resolveBuiltinSkillPage(ref.dbKey);
+      if (builtin) return { ref, content: builtin };
+      try {
+        const content = await dispatch(read({ dbKey: ref.dbKey })).unwrap();
+        return { ref, content };
+      } catch {
+        return { ref, content: null };
+      }
+    })
+  );
+  const contentByKey = /* @__PURE__ */ new Map();
+  const toolSet = /* @__PURE__ */ new Set();
+  const recommendedToolSet = /* @__PURE__ */ new Set();
+  const recommendedSkillHints = /* @__PURE__ */ new Set();
+  const skillPromptPatches = /* @__PURE__ */ new Set();
+  const normalizedReferences = [];
+  const hardSkillKeys = /* @__PURE__ */ new Set();
+  const softSkillKeys = /* @__PURE__ */ new Set();
+  for (const { ref, content } of entries) {
+    if (content) {
+      contentByKey.set(ref.dbKey, content);
+    }
+    const capabilities = extractRuntimePageCapabilities(content);
+    for (const tool of capabilities.directTools) {
+      toolSet.add(tool);
+    }
+    for (const tool of capabilities.hardSkillTools) {
+      toolSet.add(tool);
+    }
+    for (const hint of capabilities.softSkillHints) {
+      recommendedSkillHints.add(hint);
+    }
+    for (const patch of capabilities.promptPatches) {
+      skillPromptPatches.add(patch);
+    }
+    for (const skillKey of capabilities.hardSkillKeys) {
+      hardSkillKeys.add(skillKey);
+    }
+    for (const skillKey of capabilities.softSkillKeys) {
+      softSkillKeys.add(skillKey);
+    }
+    normalizedReferences.push({
+      ...ref,
+      type: capabilities.shouldUpgradeReference ? "instruction" : ref.type
+    });
+  }
+  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
+    roots: [
+      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" })),
+      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" }))
+    ],
+    loadPage: async (identifier) => {
+      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
+      return loaded.get(identifier) ?? null;
+    },
+    contentByKey
+  });
+  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
+  for (const tool of resolvedSkillLinks.requiredTools) {
+    toolSet.add(tool);
+  }
+  for (const tool of resolvedSkillLinks.recommendedTools) {
+    recommendedToolSet.add(tool);
+  }
+  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
+    recommendedSkillHints.add(hint);
+  }
+  for (const patch of resolvedSkillLinks.skillPromptPatches) {
+    skillPromptPatches.add(patch);
+  }
+  return {
+    references: normalizedReferences,
+    referencedTools: Array.from(toolSet),
+    recommendedSkillTools: Array.from(recommendedToolSet),
+    recommendedSkillHints: Array.from(recommendedSkillHints),
+    skillPromptPatches: Array.from(skillPromptPatches),
+    contentByKey
+  };
+};
+var resolveToolsFromKeys = async (keys, dispatch, preloaded) => {
+  if (!Array.isArray(keys) || keys.length === 0) {
+    return {
+      tools: [],
+      recommendedSkillTools: [],
+      recommendedSkillHints: [],
+      skillPromptPatches: [],
+      contentByKey: /* @__PURE__ */ new Map()
+    };
+  }
+  const contentByKey = await loadContentsByKeys(keys, dispatch, preloaded);
+  const toolSet = /* @__PURE__ */ new Set();
+  const recommendedToolSet = /* @__PURE__ */ new Set();
+  const recommendedSkillHints = /* @__PURE__ */ new Set();
+  const skillPromptPatches = /* @__PURE__ */ new Set();
+  const hardSkillKeys = /* @__PURE__ */ new Set();
+  const softSkillKeys = /* @__PURE__ */ new Set();
+  for (const content of contentByKey.values()) {
+    const capabilities = extractRuntimePageCapabilities(content);
+    for (const tool of [...capabilities.directTools, ...capabilities.hardSkillTools]) {
+      toolSet.add(tool);
+    }
+    for (const hint of capabilities.softSkillHints) {
+      recommendedSkillHints.add(hint);
+    }
+    for (const patch of capabilities.promptPatches) {
+      skillPromptPatches.add(patch);
+    }
+    for (const skillKey of capabilities.hardSkillKeys) {
+      hardSkillKeys.add(skillKey);
+    }
+    for (const skillKey of capabilities.softSkillKeys) {
+      softSkillKeys.add(skillKey);
+    }
+  }
+  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
+    roots: [
+      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" })),
+      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" }))
+    ],
+    loadPage: async (identifier) => {
+      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
+      return loaded.get(identifier) ?? null;
+    },
+    contentByKey
+  });
+  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
+  for (const tool of resolvedSkillLinks.requiredTools) {
+    toolSet.add(tool);
+  }
+  for (const tool of resolvedSkillLinks.recommendedTools) {
+    recommendedToolSet.add(tool);
+  }
+  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
+    recommendedSkillHints.add(hint);
+  }
+  for (const patch of resolvedSkillLinks.skillPromptPatches) {
+    skillPromptPatches.add(patch);
+  }
+  return {
+    tools: Array.from(toolSet),
+    recommendedSkillTools: Array.from(recommendedToolSet),
+    recommendedSkillHints: Array.from(recommendedSkillHints),
+    skillPromptPatches: Array.from(skillPromptPatches),
+    contentByKey
+  };
+};
+
+// packages/create/editor/transforms/slateToText.ts
+function getNodeText(node) {
+  if (node.text) {
+    return node.text;
+  }
+  if (node.children && Array.isArray(node.children)) {
+    return node.children.map(getNodeText).join("\n");
+  }
+  return "";
+}
+function slateToText(nodes) {
+  if (!nodes || nodes.length === 0) {
+    return "";
+  }
+  return nodes.map(getNodeText).join("\n\n");
+}
+
+// packages/ai/context/buildReferenceContext.ts
+var MAX_META_TEXT_LENGTH = 80;
+var DIALOG_REFERENCE_MESSAGE_LIMIT = 20;
+var DIALOG_REFERENCE_SNIPPET_CHARS = 1200;
+var DIALOG_HANDOFF_SNIPPET_CHARS = 360;
+var truncateMetaText = (value, max = MAX_META_TEXT_LENGTH) => {
+  if (!value) return "";
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 3)}...`;
+};
+var readSafe = async (dispatch, dbKey) => {
+  try {
+    return await dispatch(read({
+      dbKey
+    })).unwrap();
+  } catch {
+    return null;
+  }
+};
+var buildMentionMetaMap = async (slateData, dispatch) => {
+  const metaMap = /* @__PURE__ */ new Map();
+  const mentions = extractCategorizedMentions(slateData);
+  if (!mentions) return metaMap;
+  const pageEntries = await Promise.all(
+    (mentions.pages || []).map(async (pageId) => {
+      const pageData = await readSafe(dispatch, pageId);
+      if (!pageData) {
+        return [`page:${pageId}`, { displayType: "page", metaParts: [] }];
+      }
+      if (pageData.type === "dialog" /* DIALOG */) {
+        const agentCount = Array.isArray(pageData.cybots) ? pageData.cybots.length : 0;
+        return [
+          `page:${pageId}`,
+          {
+            displayType: "dialog",
+            title: pageData.title,
+            metaParts: [
+              `agents=${agentCount}`,
+              `updated=${pageData.updatedAt || pageData.updated_at || pageData.updated || "Unknown"}`
+            ]
+          }
+        ];
+      }
+      const tags = pageData.tags && pageData.tags.length > 0 ? pageData.tags.slice(0, 5).join(", ") : "";
+      return [
+        `page:${pageId}`,
+        {
+          displayType: "page",
+          title: pageData.title,
+          metaParts: [
+            pageData.spaceId ? `space=${pageData.spaceId}` : "",
+            tags ? `tags=${tags}` : "",
+            `updated=${pageData.updatedAt || pageData.updated_at || pageData.updated || "Unknown"}`
+          ].filter(Boolean)
+        }
+      ];
+    })
+  );
+  pageEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
+  const agentEntries = await Promise.all(
+    (mentions.agents || []).map(async (agentId) => {
+      const agentData = await readSafe(dispatch, agentId);
+      if (!agentData) {
+        return [`agent:${agentId}`, { displayType: "agent", metaParts: [] }];
+      }
+      const desc = truncateMetaText(
+        agentData.description || agentData.introduction || ""
+      );
+      return [
+        `agent:${agentId}`,
+        {
+          displayType: "agent",
+          title: agentData.name,
+          metaParts: [
+            `public=${agentData.isPublic ? "yes" : "no"}`,
+            desc ? `desc=${desc}` : ""
+          ].filter(Boolean)
+        }
+      ];
+    })
+  );
+  agentEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
+  const spaceEntries = await Promise.all(
+    (mentions.spaces || []).map(async (spaceId) => {
+      const spaceKey = createSpaceKey.space(spaceId);
+      const spaceData = await readSafe(dispatch, spaceKey);
+      if (!spaceData) {
+        return [`space:${spaceId}`, { displayType: "space", metaParts: [] }];
+      }
+      const desc = truncateMetaText(spaceData.description || "");
+      const categoriesCount = Object.keys(spaceData.categories || {}).length;
+      const contentsCount = Object.keys(spaceData.contents || {}).length;
+      return [
+        `space:${spaceId}`,
+        {
+          displayType: "space",
+          title: spaceData.name,
+          metaParts: [
+            desc ? `desc=${desc}` : "",
+            `categories=${categoriesCount}`,
+            `contents=${contentsCount}`
+          ].filter(Boolean)
+        }
+      ];
+    })
+  );
+  spaceEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
+  return metaMap;
+};
+var buildInlineMention = (node, metaMap) => {
+  const resourceType = node.resourceType || "unknown";
+  const resourceId = node.resourceId || "unknown";
+  const key = `${resourceType}:${resourceId}`;
+  const meta = metaMap.get(key);
+  const label = meta?.title || node.label || resourceId || "mention";
+  const displayType = meta?.displayType || resourceType;
+  const metaParts = meta?.metaParts ?? [];
+  const idPart = resourceType === "tool" ? `tool=${resourceId}` : `dbkey=${resourceId}`;
+  const metaSuffix = metaParts.length ? ` | ${metaParts.join(" | ")}` : "";
+  return `@${label}(${displayType} | ${idPart}${metaSuffix})`;
+};
+var clipReferenceText = (value, max) => {
+  const raw = typeof value === "string" ? value : value == null ? "" : JSON.stringify(value);
+  return clipMultilineText(raw, max);
+};
+var fetchDialogReference = async (dbKey, refContent, dispatch) => {
+  const dialogConfig = refContent;
+  const dialogTitle = dialogConfig.title || `Untitled Dialog (${dbKey})`;
+  const dialogId = extractCustomId(dbKey) || dbKey.replace(/^dialog-/, "");
+  const checkpoint = dialogConfig.runtimeCheckpoint || null;
+  const summary = asTrimmedString(dialogConfig.summary);
+  const messages = await dispatch(
+    async (_dispatch, getState, { db }) => {
+      const state = getState();
+      const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
+      return await fetchAndCacheMessages({
+        db,
+        dialogId,
+        limit: DIALOG_REFERENCE_MESSAGE_LIMIT,
+        token,
+        remoteServers: remoteServers.length > 0 ? remoteServers : void 0
+      });
+    }
+  );
+  const sortedMessages = [...messages].reverse();
+  const formatContent = (content) => clipReferenceText(content, DIALOG_REFERENCE_SNIPPET_CHARS);
+  const transcript = sortedMessages.map((msg, index) => {
+    const toolLine = msg.toolName ? ` tool=${msg.toolName}` : "";
+    const agentLine = msg.cybotKey ? ` agent=${msg.cybotKey}` : "";
+    const createdLine = msg.createdAt ? ` at=${msg.createdAt}` : "";
+    return [
+      `### Message ${index + 1}: ${msg.role || "unknown"} id=${msg.id || "unknown"}${toolLine}${agentLine}${createdLine}`,
+      formatContent(msg.content) || "[empty]"
+    ].join("\n");
+  }).join("\n\n");
+  const checkpointLines = [];
+  if (checkpoint && typeof checkpoint === "object") {
+    if (checkpoint.status) checkpointLines.push(`- status: ${checkpoint.status}`);
+    if (checkpoint.lastUserInput) checkpointLines.push(`- lastUserInput: ${formatContent(checkpoint.lastUserInput)}`);
+    if (checkpoint.lastAssistantText) checkpointLines.push(`- lastAssistantText: ${formatContent(checkpoint.lastAssistantText)}`);
+    if (Array.isArray(checkpoint.lastToolNames) && checkpoint.lastToolNames.length) {
+      checkpointLines.push(`- lastToolNames: ${checkpoint.lastToolNames.join(", ")}`);
+    }
+    if (Array.isArray(checkpoint.toolSurface?.finalToolNames) && checkpoint.toolSurface.finalToolNames.length) {
+      checkpointLines.push(`- availableToolNames: ${checkpoint.toolSurface.finalToolNames.join(", ")}`);
+    }
+  }
+  const recentToolEvidence = sortedMessages.filter((msg) => msg.role === "tool" || msg.toolName).slice(-3).map((msg) => {
+    const label = msg.toolName ? `${msg.toolName}` : "tool";
+    return `- ${label} id=${msg.id || "unknown"}: ${clipReferenceText(msg.content, DIALOG_HANDOFF_SNIPPET_CHARS) || "[empty]"}`;
+  });
+  const handoffLines = [
+    `- Use this when continuing work, transferring to another Agent, comparing with the current task, or preparing a document/plan from the prior discussion.`,
+    `- Current state source: ${checkpointLines.length ? "Runtime Checkpoint" : "summaries and recent transcript"}.`,
+    summary ? `- Compressed background: passive summary is available below; treat it as lossy, not original wording.` : "",
+    recentToolEvidence.length ? `- Recent tool evidence:
+${recentToolEvidence.join("\n")}` : `- Recent tool evidence: none loaded in the latest ${DIALOG_REFERENCE_MESSAGE_LIMIT} messages.`,
+    `- For exact claims, old decisions, original wording, files/tools mentioned earlier, or anything not visible in the recent transcript, call searchDialogMessages with DB Key ${dbKey}.`
+  ].filter(Boolean);
+  const referenceBody = [
+    `Conversation Reference:`,
+    `DB Key: ${dbKey}`,
+    `Title: ${dialogTitle}`,
+    `Status: ${dialogConfig.status || "unknown"}`,
+    `Loaded Recent Messages: ${sortedMessages.length}`,
+    `Conversation Handoff:
+${handoffLines.join("\n")}`,
+    checkpointLines.length ? `Runtime Checkpoint:
+${checkpointLines.join("\n")}` : "",
+    summary ? `Passive Summary (compressed history, not original wording):
+${wrapHistoricalSummaryWithReplayGuard(summary)}` : "",
+    `Recent Transcript (original message excerpts, oldest to newest):
+${transcript || "[no recent messages loaded]"}`,
+    [
+      `Coverage Note: This reference intentionally loads only the latest ${DIALOG_REFERENCE_MESSAGE_LIMIT} messages plus summaries/checkpoint to control token load.`,
+      `Original Message Lookup Policy: If the user asks for an exact old message, original wording, who said what, why a decision was made, early-history detail, file/tool evidence, failed attempts, or a comparison with prior work, use searchDialogMessages({ dialogKey: "${dbKey}", query: "..." }) before making a factual claim from this referenced conversation.`
+    ].join("\n")
+  ].filter(Boolean).join("\n\n");
+  const tokenEstimate = estimateTokenCount(referenceBody);
+  return `${referenceBody}
+
+Token Load Estimate: ${tokenEstimate} tokens for this conversation reference.
+---
+
+`;
+};
+var fetchTableReference = async (dbKey, refContent, dispatch) => {
+  const tableMeta = refContent;
+  const title = tableMeta.displayName || tableMeta.description || `Untitled Table (${dbKey})`;
+  const { markdown: tableMd } = await dispatch(
+    async (_dispatch, getState, { db }) => {
+      const state = getState();
+      const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
+      return await fetchAndSerializeTable(tableMeta, db, {
+        token,
+        remoteServers
+      });
+    }
+  );
+  const tags = tableMeta.tags?.length ? tableMeta.tags.join(", ") : "None";
+  const description = tableMeta.description || "No description provided.";
+  return `Reference Item (Table):
+DB Key: ${dbKey}
+Title: ${title}
+Description: ${description}
+Tags: ${tags}
+Content (Markdown Table):
+
+${tableMd}
+---
+
+`;
+};
+var fetchSlateReference = async (dbKey, refContent, dispatch, options) => {
+  const hasSlate = Array.isArray(refContent?.slateData) && refContent.slateData.length > 0;
+  const legacyContent = hasSlate ? null : resolvePageReadMarkdown(refContent).trim() || null;
+  if (!hasSlate && !legacyContent) return null;
+  const title = refContent.title || `Untitled (${dbKey})`;
+  let contentString;
+  let contentType;
+  const inlineMentionMeta = options.inlineMentionMeta ?? options.format === "simplified_markdown";
+  if (legacyContent) {
+    contentType = "Markdown (legacy content)";
+    contentString = legacyContent;
+  } else switch (options.format) {
+    case "text":
+      contentType = "Plain Text";
+      contentString = slateToText(refContent.slateData);
+      break;
+    case "simplified_markdown":
+      contentType = "Simplified Markdown";
+      if (inlineMentionMeta) {
+        const metaMap = await buildMentionMetaMap(refContent.slateData, dispatch);
+        contentString = slateToSimplifiedMarkdown(refContent.slateData, {
+          mentionResolver: (node) => buildInlineMention(node, metaMap)
+        });
+      } else {
+        contentString = slateToSimplifiedMarkdown(refContent.slateData);
+      }
+      break;
+    case "json":
+    default:
+      contentType = "Slate JSON";
+      contentString = JSON.stringify(refContent.slateData, null, 2);
+      break;
+  }
+  if (!contentString || typeof contentString === "string" && !contentString.trim() || contentString === "[]") {
+    return null;
+  }
+  const tags = (refContent.tags || []).length > 0 ? refContent.tags.join(", ") : "None";
+  const createdAt = refContent.created || "Unknown Creation Date";
+  const updatedAt = refContent.updated || "Unknown Update Date";
+  return `Reference Item:
+DB Key: ${dbKey}
+Title: ${title}
+Content (${contentType}):
+${contentString}
+Tags: ${tags}
+Created At: ${createdAt}
+Updated At: ${updatedAt}
+---
+
+`;
+};
+var fetchReferenceContents = async (references, dispatch, options = { format: "simplified_markdown" }) => {
+  const result = /* @__PURE__ */ new Map();
+  if (!references || references.length === 0) return result;
+  const referencePromises = references.map(async (dbKey) => {
+    try {
+      const hasPreloaded = options.preloaded?.has(dbKey);
+      const refContent = hasPreloaded ? options.preloaded?.get(dbKey) : await dispatch(read({
+        dbKey
+      })).unwrap();
+      if (!refContent) return null;
+      let formatted = null;
+      if (refContent.type === "dialog" /* DIALOG */) {
+        formatted = await fetchDialogReference(dbKey, refContent, dispatch);
+      } else if (refContent.type === "table" /* TABLE */) {
+        formatted = await fetchTableReference(dbKey, refContent, dispatch);
+      } else {
+        formatted = await fetchSlateReference(dbKey, refContent, dispatch, options);
+      }
+      if (formatted) return [dbKey, formatted];
+      return null;
+    } catch (error) {
+      console.error(`Error fetching reference ${dbKey}:`, error);
+      return null;
+    }
+  });
+  const resolved = await Promise.all(referencePromises);
+  resolved.forEach((item) => {
+    if (item) result.set(item[0], item[1]);
+  });
+  return result;
+};
+
+export {
+  CONTEXT_OVERFLOW_ACTIONS,
+  CONTEXT_TOO_LARGE_ACTIONS,
+  isContextOverflowText,
+  classifyApiError,
+  parseApiError,
+  classifyGenerationError,
+  performServerProxyFetchWithRetry,
+  fetchReferenceContents,
+  mergeReferences,
+  resolveReferenceAssets,
+  resolveToolsFromKeys
+};