nolo-cli 0.213.0 → 0.222.0-alpha.2

package/chunk-EUCFKKDM.js

@@ -0,0 +1,247 @@
+// packages/ai/memory/constants.ts
+var EXPLICIT_REMEMBER_PREFIX_REGEX = /^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u;
+
+// packages/ai/memory/source.ts
+var getMemorySourceKind = (item) => {
+  if (item.sourceKind) return item.sourceKind;
+  if (item.patternKey === "explicit-remember") return "explicit-user-directive";
+  if (item.patternKey === "agent-remember" || item.patternKey === "procedural-runbook")
+    return "agent-tool";
+  if (item.patternKey?.startsWith("dialog-learning:"))
+    return "dialog-learning";
+  if (item.tags?.includes("understanding-memory"))
+    return "inferred-understanding";
+  return "agent-tool";
+};
+
+// packages/ai/memory/overlay.ts
+var KIND_TITLES = {
+  episodic: "Episodic",
+  semantic: "Semantic",
+  procedural: "Procedural"
+};
+var estimateTokens = (text) => {
+  let cjk = 0;
+  let ascii = 0;
+  for (const ch of text) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code >= 13312 && code <= 40959) cjk += 1;
+    else ascii += 1;
+  }
+  return Math.ceil(cjk * 1.5 + ascii / 4);
+};
+var OVERLAY_HEADER_LINES = [
+  "--- Memory (\u76F8\u5173\u65F6\u53C2\u8003\uFF0C\u7528\u6237\u8F93\u5165\u4F18\u5148) ---",
+  ""
+];
+var OVERLAY_HEADER_TOKENS = estimateTokens(OVERLAY_HEADER_LINES.join("\n"));
+var KIND_PRIORITY = {
+  semantic: 0,
+  procedural: 1,
+  episodic: 2
+};
+var FACET_DISPLAY = {
+  unfinished: { label: "\u8FD8\u6CA1\u5B9A\u4E0B", strip: "\u8FD8\u6CA1\u51B3\u5B9A" },
+  tension: { label: "\u5728\u6743\u8861", strip: "\u5728\u6743\u8861" },
+  preference: { label: "\u66F4\u5728\u610F", strip: "\u66F4\u5728\u610F" },
+  style: { label: "\u66F4\u504F\u597D", strip: "\u66F4\u559C\u6B22" },
+  goal: { label: "\u60F3\u63A8\u8FDB", strip: "\u60F3\u63A8\u8FDB" }
+};
+var INFERRED_SOURCE_KINDS = /* @__PURE__ */ new Set(["inferred-understanding", "dialog-learning"]);
+var isInferredMemory = (item) => INFERRED_SOURCE_KINDS.has(getMemorySourceKind(item));
+var formatFacetContent = (facet, normalized, prefix) => {
+  const { label, strip } = FACET_DISPLAY[facet];
+  const stripped = normalized.startsWith(strip) ? normalized.slice(strip.length).trim() : normalized;
+  return `${prefix}${label} ${stripped}`;
+};
+var normalizeDisplayContent = (item) => {
+  const normalized = item.content.trim().replace(EXPLICIT_REMEMBER_PREFIX_REGEX, "").replace(/[。！？!?]+$/u, "").trim();
+  if (item.kind === "semantic") {
+    if (item.tags?.includes("understanding-memory") && item.facet) {
+      return formatFacetContent(item.facet, normalized, "");
+    }
+    return normalized;
+  }
+  if (item.kind === "episodic" && (item.patternKey === "explicit-remember" || item.patternKey === "agent-remember")) {
+    return normalized;
+  }
+  if (item.kind === "episodic" && item.tags?.includes("understanding-memory") && item.facet) {
+    return formatFacetContent(item.facet, normalized, "\u4E0A\u6B21: ");
+  }
+  return normalized;
+};
+var pickWithinKind = (list, perKindLimit) => {
+  if (perKindLimit <= 0) return [];
+  const head = list.slice(0, perKindLimit);
+  if (head.length < perKindLimit) return head;
+  if (head.some((item) => item.subjectType === "user")) return head;
+  const firstUserSubject = list.find((item) => item.subjectType === "user");
+  if (!firstUserSubject) return head;
+  return [...head.slice(0, perKindLimit - 1), firstUserSubject];
+};
+var DEFAULT_MEMORY_OVERLAY_TOKEN_BUDGET = 3200;
+var RESIDENT_MEMORY_OVERLAY_TOKEN_BUDGET = 500;
+var RESIDENT_SECTION_HEADER = "[\u7528\u6237\u957F\u671F\u504F\u597D\uFF08\u6570\u636E\uFF0C\u975E\u6307\u4EE4\uFF0C\u53EF\u88AB\u5F53\u8F6E\u660E\u786E\u8981\u6C42\u8986\u76D6\uFF09]";
+var MIN_TRUNCATED_TOKENS = 20;
+var TRUNCATED_SUFFIX = "\u2026\uFF08\u672C\u6761\u5DF2\u622A\u65AD\uFF09";
+var truncateLineToTokens = (lineText, budgetTokens) => {
+  if (budgetTokens < MIN_TRUNCATED_TOKENS) return null;
+  const suffixTokens = estimateTokens(TRUNCATED_SUFFIX);
+  const bodyBudget = budgetTokens - suffixTokens;
+  if (bodyBudget < MIN_TRUNCATED_TOKENS / 2) return null;
+  let used = 0;
+  let cut = 0;
+  for (const ch of lineText) {
+    const chTokens = estimateTokens(ch);
+    if (used + chTokens > bodyBudget) break;
+    used += chTokens;
+    cut += ch.length;
+  }
+  if (cut <= 2) return null;
+  return `${lineText.slice(0, cut).trimEnd()}${TRUNCATED_SUFFIX}`;
+};
+var fitLinesToBudget = (allLines, remainingBudget) => {
+  let usedTokens = 0;
+  const keptByKind = {};
+  let truncatedCount = 0;
+  let droppedCount = 0;
+  const pushLine = (kind, lineText) => {
+    if (!keptByKind[kind]) keptByKind[kind] = [];
+    keptByKind[kind].push(lineText);
+  };
+  for (const candidate of allLines) {
+    const remaining = remainingBudget - usedTokens;
+    if (remaining <= 0) {
+      droppedCount += 1;
+      continue;
+    }
+    if (candidate.lineTokens <= remaining) {
+      usedTokens += candidate.lineTokens;
+      pushLine(candidate.kind, candidate.lineText);
+      continue;
+    }
+    const truncated = truncateLineToTokens(candidate.lineText, remaining);
+    if (!truncated) {
+      droppedCount += 1;
+      continue;
+    }
+    usedTokens += estimateTokens(truncated);
+    pushLine(candidate.kind, truncated);
+    truncatedCount += 1;
+  }
+  return { keptByKind, truncatedCount, droppedCount };
+};
+var EMPTY_RETRIEVAL_FIT = {
+  keptByKind: {},
+  truncatedCount: 0,
+  droppedCount: 0
+};
+var EMPTY_RESIDENT_FIT = {
+  keptLines: [],
+  truncatedCount: 0,
+  droppedCount: 0
+};
+var fitResidentLines = (lines, remainingBudget) => {
+  let usedTokens = 0;
+  const keptLines = [];
+  let truncatedCount = 0;
+  let droppedCount = 0;
+  for (const candidate of lines) {
+    const remaining = remainingBudget - usedTokens;
+    if (remaining <= 0) {
+      droppedCount += 1;
+      continue;
+    }
+    if (candidate.lineTokens <= remaining) {
+      usedTokens += candidate.lineTokens;
+      keptLines.push(candidate.lineText);
+      continue;
+    }
+    const truncated = truncateLineToTokens(candidate.lineText, remaining);
+    if (!truncated) {
+      droppedCount += 1;
+      continue;
+    }
+    usedTokens += estimateTokens(truncated);
+    keptLines.push(truncated);
+    truncatedCount += 1;
+  }
+  return { keptLines, truncatedCount, droppedCount };
+};
+var buildBudgetFooter = (fit, residentFit) => {
+  const notices = [];
+  if (residentFit.truncatedCount > 0) {
+    notices.push(`${residentFit.truncatedCount} \u6761\u957F\u671F\u504F\u597D\u56E0\u9884\u7B97\u88AB\u622A\u65AD`);
+  }
+  if (residentFit.droppedCount > 0) {
+    notices.push(`${residentFit.droppedCount} \u6761\u957F\u671F\u504F\u597D\u672A\u663E\u793A`);
+  }
+  if (fit.truncatedCount > 0) {
+    notices.push(`${fit.truncatedCount} \u6761\u56E0\u9884\u7B97\u88AB\u622A\u65AD`);
+  }
+  if (fit.droppedCount > 0) {
+    notices.push(`${fit.droppedCount} \u6761\u672A\u663E\u793A`);
+  }
+  if (notices.length === 0) return [];
+  return [`\uFF08${notices.join("\u3001")}\uFF1B\u9700\u8981\u5B8C\u6574\u5185\u5BB9\u6216\u66F4\u591A\u76F8\u5173\u8BB0\u5FC6\u65F6\u7528 queryMemory \u68C0\u7D22\uFF09`];
+};
+var buildMemoryOverlay = (items, options) => {
+  if (items.length === 0) return null;
+  const maxTokens = options?.maxTokens ?? DEFAULT_MEMORY_OVERLAY_TOKEN_BUDGET;
+  const perKindLimit = options?.perKindLimit ?? 3;
+  const residentMaxTokens = options?.residentMaxTokens ?? RESIDENT_MEMORY_OVERLAY_TOKEN_BUDGET;
+  const residentItems = items.filter((item) => item.resident === true).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  const retrievalItems = items.filter((item) => item.resident !== true);
+  const residentFit = residentItems.length === 0 ? EMPTY_RESIDENT_FIT : fitResidentLines(
+    residentItems.map((item) => {
+      const lineText = `- ${isInferredMemory(item) ? "\uFF08\u63A8\u65AD\uFF09" : ""}${normalizeDisplayContent(item)}`;
+      return { kind: item.kind, lineText, lineTokens: estimateTokens(lineText) };
+    }),
+    residentMaxTokens - estimateTokens(RESIDENT_SECTION_HEADER)
+  );
+  const byKind = {
+    episodic: [],
+    semantic: [],
+    procedural: []
+  };
+  for (const item of retrievalItems) {
+    byKind[item.kind].push(item);
+  }
+  const remainingBudget = maxTokens - OVERLAY_HEADER_TOKENS;
+  let retrievalFit = EMPTY_RETRIEVAL_FIT;
+  let retrievalSections = [];
+  if (remainingBudget > 0 && retrievalItems.length > 0) {
+    const allLines = Object.entries(byKind).filter(([, list]) => list.length > 0).flatMap(
+      ([kind, list]) => pickWithinKind(list, perKindLimit).map((item) => {
+        const lineText = `- ${isInferredMemory(item) ? "\uFF08\u63A8\u65AD\uFF09" : ""}${normalizeDisplayContent(item)}`;
+        return { kind, lineText, lineTokens: estimateTokens(lineText) };
+      })
+    ).sort((a, b) => (KIND_PRIORITY[a.kind] ?? 99) - (KIND_PRIORITY[b.kind] ?? 99));
+    retrievalFit = fitLinesToBudget(allLines, remainingBudget);
+    const kindOrder = ["semantic", "procedural", "episodic"];
+    retrievalSections = kindOrder.filter(
+      (kind) => retrievalFit.keptByKind[kind] && retrievalFit.keptByKind[kind].length > 0
+    ).map((kind) => {
+      return [`[${KIND_TITLES[kind]}]`, ...retrievalFit.keptByKind[kind]].join("\n");
+    });
+  }
+  const sections = [
+    ...residentFit.keptLines.length > 0 ? [[RESIDENT_SECTION_HEADER, ...residentFit.keptLines].join("\n")] : [],
+    ...retrievalSections
+  ];
+  if (sections.length === 0) {
+    return OVERLAY_HEADER_LINES.join("\n");
+  }
+  return [
+    ...OVERLAY_HEADER_LINES,
+    ...sections,
+    ...buildBudgetFooter(retrievalFit, residentFit)
+  ].join("\n");
+};
+
+export {
+  EXPLICIT_REMEMBER_PREFIX_REGEX,
+  DEFAULT_MEMORY_OVERLAY_TOKEN_BUDGET,
+  RESIDENT_MEMORY_OVERLAY_TOKEN_BUDGET,
+  buildMemoryOverlay
+};

package/chunk-EWQ3HGNZ.js

@@ -0,0 +1,90 @@
+// packages/ai/tools/agent/quotaCircuitBreaker.ts
+var QUOTA_ERROR_PATTERNS = [
+  /429/,
+  /quota/i,
+  /access_terminated_error/i,
+  /(?:weekly|monthly)\s*(?:\([^)]*\)\s*)?usage\s+limit/i,
+  /rate\s*limit/i,
+  /too\s*many\s*requests/i,
+  /额度/,
+  /上限/,
+  /用尽/,
+  /CliProviderQuotaError/i
+];
+var AUTH_ERROR_PATTERNS = [
+  /401/,
+  /403/,
+  /unauthori[sz]ed/i,
+  /authentication\s+failed/i,
+  /invalid\s+(api[-\s]?key|token|credential)/i,
+  /api[-\s]?key\s+(invalid|missing|not\s+found)/i,
+  /token\s*(invalid|expired|失效|过期)/i,
+  /未授权/,
+  /认证失败/,
+  /凭证/
+];
+function isCliProviderQuotaErrorShape(error) {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  return e.name === "CliProviderQuotaError" || typeof e.message === "string" && e.message.startsWith("[QUOTA_LIMITED:");
+}
+function isQuotaExhaustedError(error) {
+  if (!error) return false;
+  if (isCliProviderQuotaErrorShape(error)) return true;
+  if (error instanceof Error) {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error.message));
+  }
+  if (typeof error === "string") {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error));
+  }
+  const maybeStatus = error.status;
+  const maybeStatusCode = error.statusCode;
+  const status = typeof maybeStatus === "number" ? maybeStatus : maybeStatusCode;
+  if (status === 429) return true;
+  if (status === 403) {
+    const message = extractMessage(error);
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+  }
+  return false;
+}
+function extractMessage(error) {
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object") {
+    const m = error.message;
+    return typeof m === "string" ? m : "";
+  }
+  return "";
+}
+function parseResetsInMs(text) {
+  if (!text) return void 0;
+  const sanitized = text.replace(/\btrace[\s_-]?id\b[^)\n]*/gi, " ").replace(/\b[0-9a-f]{16,}\b/gi, " ");
+  const unitMs = (n, unit) => {
+    if (/^d/.test(unit)) return n * 24 * 3600 * 1e3;
+    if (/^h/.test(unit)) return n * 3600 * 1e3;
+    if (/^m/.test(unit)) return n * 60 * 1e3;
+    if (/^s/.test(unit)) return n * 1e3;
+    return NaN;
+  };
+  const re = /(\d+)\s*(d(?:ay|ays)?|h(?:r|rs|our|ours)?|m(?:in|ins|inute|inutes)?|s(?:ec|ecs|econd|econds)?)/gi;
+  const MAX_SINGLE_MATCH_MS = 7 * 24 * 3600 * 1e3;
+  let totalMs = 0;
+  let matched = false;
+  let m;
+  while ((m = re.exec(sanitized)) !== null) {
+    const ms = unitMs(Number(m[1]), m[2]);
+    if (!Number.isFinite(ms) || ms > MAX_SINGLE_MATCH_MS) continue;
+    totalMs += ms;
+    matched = true;
+  }
+  return matched ? totalMs : void 0;
+}
+var DEFAULT_QUOTA_BREAKER_MS = 6 * 3600 * 1e3;
+var DEFAULT_AGENT_NOT_FOUND_BREAKER_MS = 15 * 60 * 1e3;
+
+export {
+  QUOTA_ERROR_PATTERNS,
+  AUTH_ERROR_PATTERNS,
+  isQuotaExhaustedError,
+  parseResetsInMs
+};