nolo-cli 0.1.8 → 0.1.10

package/ai/llm/usageRequestOptions.ts

@@ -0,0 +1,59 @@
+export interface UsageRequestOptions {
+  stream_options?: {
+    include_usage: true;
+  };
+  usage?: {
+    include: true;
+  };
+}
+
+export type UsageRequestApi = "chat-completions" | "responses";
+
+const STREAM_USAGE_PROVIDERS = new Set([
+  "google",
+  "openrouter",
+  "xai",
+  "openai",
+  "fireworks",
+  "mistral",
+]);
+
+const EXTRA_USAGE_FIELD_PROVIDERS = new Set(["openrouter"]);
+
+const normalizeProviderName = (providerName?: string | null) =>
+  typeof providerName === "string" ? providerName.trim().toLowerCase() : "";
+
+export const getUsageRequestOptions = (
+  providerName?: string | null,
+  options?: { api?: UsageRequestApi }
+): UsageRequestOptions => {
+  const normalizedProvider = normalizeProviderName(providerName);
+  const api = options?.api ?? "chat-completions";
+
+  if (api === "responses") {
+    return EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider)
+      ? {
+          usage: {
+            include: true as const,
+          },
+        }
+      : {};
+  }
+
+  return {
+    ...(STREAM_USAGE_PROVIDERS.has(normalizedProvider)
+      ? {
+          stream_options: {
+            include_usage: true as const,
+          },
+        }
+      : {}),
+    ...(EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider)
+      ? {
+          usage: {
+            include: true as const,
+          },
+        }
+      : {}),
+  };
+};

package/ai/memory/capture.ts

@@ -0,0 +1,148 @@
+import serverDb from "database/server/db";
+import { maybeConsolidateExplicitRemember } from "./consolidate";
+import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
+import type { MemoryOwnerType, MemorySubjectType, MemoryVisibility } from "./types";
+
+const EXPLICIT_REMEMBER_PATTERNS = [
+  "记住",
+  "你要记住",
+  "请记住",
+  "以后记住",
+];
+
+export const shouldCaptureExplicitMemory = (userInput: string): boolean => {
+  const text = userInput.trim();
+  if (!text) return false;
+  return EXPLICIT_REMEMBER_PATTERNS.some((pattern) => {
+    const index = text.indexOf(pattern);
+    if (index < 0) return false;
+
+    const prefix = text.slice(0, index).trim();
+    const suffix = text.slice(index + pattern.length).trim();
+    if (!suffix) return false;
+    if (!prefix) return true;
+
+    return /^(这个|这件事|这一点|这点|请你|你)?$/u.test(prefix);
+  });
+};
+
+const buildExplicitMemoryTargets = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+}): Array<{
+  ownerType: MemoryOwnerType;
+  ownerId: string;
+  visibility: MemoryVisibility;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+  importance: number;
+  confidence: number;
+  tags: string[];
+}> => {
+  if (input.userId) {
+    return [
+      {
+        ownerType: "user",
+        ownerId: input.userId,
+        visibility: "private",
+        subjectType: "user",
+        subjectId: input.userId,
+        importance: 0.95,
+        confidence: 0.95,
+        tags: ["explicit-memory"],
+      },
+    ];
+  }
+
+  if (input.spaceId) {
+    return [
+      {
+        ownerType: "space",
+        ownerId: input.spaceId,
+        visibility: "shared",
+        subjectType: "space",
+        subjectId: input.spaceId,
+        importance: 0.85,
+        confidence: 0.9,
+        tags: ["explicit-memory", "space-context"],
+      },
+    ];
+  }
+
+  return [];
+};
+
+export const captureExplicitMemoryEpisode = async (input: {
+  db?: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  dialogId: string;
+  userInput: string;
+}): Promise<void> => {
+  if (!shouldCaptureExplicitMemory(input.userInput)) return;
+  const db = input.db ?? serverDb;
+  const targets = buildExplicitMemoryTargets(input);
+
+  for (const target of targets) {
+    const item = createMemoryItem({
+      ownerType: target.ownerType,
+      ownerId: target.ownerId,
+      visibility: target.visibility,
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
+      kind: "episodic",
+      content: input.userInput.trim(),
+      importance: target.importance,
+      confidence: target.confidence,
+      tags: target.tags,
+      patternKey: "explicit-remember",
+      sourceDialogId: input.dialogId,
+    });
+    await writeMemoryItemWithIndexesToDb(db, item);
+  }
+};
+
+export const consolidateExplicitMemoryAfterDialog = async (input: {
+  db?: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  dialogId: string;
+  userInput: string;
+}): Promise<void> => {
+  if (!shouldCaptureExplicitMemory(input.userInput)) return;
+  const db = input.db ?? serverDb;
+  const targets = buildExplicitMemoryTargets(input);
+
+  for (const target of targets) {
+    await maybeConsolidateExplicitRemember({
+      db,
+      owner: { ownerType: target.ownerType, ownerId: target.ownerId },
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
+      visibility: target.visibility,
+      content: input.userInput.trim(),
+    });
+  }
+};
+
+export const scheduleExplicitMemoryConsolidation = (input: {
+  db?: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  dialogId: string;
+  userInput: string;
+}): void => {
+  queueMicrotask(() => {
+    void consolidateExplicitMemoryAfterDialog(input).catch((error) => {
+      console.warn("[memory] explicit post-dialog consolidation failed", {
+        dialogId: input.dialogId,
+        userId: input.userId ?? null,
+        spaceId: input.spaceId ?? null,
+        error,
+      });
+    });
+  });
+};

package/ai/memory/consolidate.ts

@@ -0,0 +1,104 @@
+import serverDb from "database/server/db";
+import { loadMemoryCandidatesFromDb } from "./query";
+import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
+import type { MemoryItem, MemoryOwnerRef, MemorySubjectType } from "./types";
+
+const EXPLICIT_REMEMBER_PREFIXES = [
+  "你要记住",
+  "请记住",
+  "以后记住",
+  "记住",
+];
+
+const normalizeExplicitRememberContent = (text: string): string => {
+  let normalized = text.trim();
+  for (const prefix of EXPLICIT_REMEMBER_PREFIXES) {
+    if (normalized.startsWith(prefix)) {
+      normalized = normalized.slice(prefix.length).trim();
+      break;
+    }
+  }
+
+  normalized = normalized
+    .replace(/^[，,。.\s:：]+/, "")
+    .replace(/[。！？!?]+$/g, "")
+    .trim();
+
+  return normalized;
+};
+
+const buildSemanticPatternKey = (normalizedContent: string): string =>
+  `semantic-explicit:${normalizedContent.toLowerCase()}`;
+
+const shouldKeepAsSemanticCandidate = (normalizedContent: string): boolean =>
+  normalizedContent.length >= 6;
+
+const findMatchingExplicitEpisodes = (
+  items: MemoryItem[],
+  normalizedContent: string,
+  subjectId: string
+): MemoryItem[] =>
+  items.filter((item) => {
+    if (item.kind !== "episodic") return false;
+    if (item.patternKey !== "explicit-remember") return false;
+    if (item.subjectId !== subjectId) return false;
+    return normalizeExplicitRememberContent(item.content) === normalizedContent;
+  });
+
+export const maybeConsolidateExplicitRemember = async (input: {
+  db?: any;
+  owner: MemoryOwnerRef;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+  visibility: "private" | "shared" | "public";
+  content: string;
+}): Promise<void> => {
+  const normalizedContent = normalizeExplicitRememberContent(input.content);
+  if (!shouldKeepAsSemanticCandidate(normalizedContent)) return;
+
+  const db = input.db ?? serverDb;
+  const items = await loadMemoryCandidatesFromDb(db, {
+    owners: [input.owner],
+    subjects: [{ subjectType: input.subjectType, subjectId: input.subjectId }],
+    kinds: ["episodic", "semantic"],
+    ownerLimit: 50,
+  });
+
+  const matchingEpisodes = findMatchingExplicitEpisodes(
+    items,
+    normalizedContent,
+    input.subjectId
+  );
+  if (matchingEpisodes.length < 2) return;
+
+  const semanticPatternKey = buildSemanticPatternKey(normalizedContent);
+  const existingSemantic = items.find(
+    (item) =>
+      item.kind === "semantic" &&
+      item.subjectId === input.subjectId &&
+      item.patternKey === semanticPatternKey
+  );
+  if (existingSemantic) return;
+
+  const semantic = createMemoryItem({
+    ownerType: input.owner.ownerType,
+    ownerId: input.owner.ownerId,
+    visibility: input.visibility,
+    subjectType: input.subjectType,
+    subjectId: input.subjectId,
+    kind: "semantic",
+    content: normalizedContent,
+    importance: 0.92,
+    confidence: 0.72,
+    tags: ["explicit-memory", "consolidated"],
+    patternKey: semanticPatternKey,
+    sourceDialogId: matchingEpisodes[matchingEpisodes.length - 1]?.sourceDialogId,
+  });
+
+  await writeMemoryItemWithIndexesToDb(db, semantic);
+};
+
+export const __test__ = {
+  normalizeExplicitRememberContent,
+  buildSemanticPatternKey,
+};

package/ai/memory/delete.ts

@@ -0,0 +1,147 @@
+import serverDb from "database/server/db";
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+  memoryOwnerRange,
+} from "database/keys";
+import type {
+  MemoryFacet,
+  MemoryItem,
+  MemoryKind,
+  MemoryOwnerRef,
+  MemorySubjectType,
+} from "./types";
+
+interface DeleteMemoryFilters {
+  ids?: string[];
+  kinds?: MemoryKind[];
+  facets?: MemoryFacet[];
+  subjectType?: MemorySubjectType;
+  subjectId?: string;
+  patternKeyPrefix?: string;
+  sourceDialogId?: string;
+  tags?: string[];
+  limit?: number;
+}
+
+export interface DeleteMemoryResult {
+  deletedCount: number;
+  deletedIds: string[];
+  matchedItems: MemoryItem[];
+}
+
+const normalizeSet = (values?: string[]): Set<string> | null => {
+  if (!Array.isArray(values) || values.length === 0) return null;
+  const normalized = values
+    .map((value) => value.trim())
+    .filter(Boolean);
+  return normalized.length > 0 ? new Set(normalized) : null;
+};
+
+const matchesFilters = (item: MemoryItem, filters: DeleteMemoryFilters): boolean => {
+  const idSet = normalizeSet(filters.ids);
+  if (idSet && !idSet.has(item.id)) return false;
+
+  const kindSet = normalizeSet(filters.kinds);
+  if (kindSet && !kindSet.has(item.kind)) return false;
+
+  const facetSet = normalizeSet(filters.facets);
+  if (facetSet && (!item.facet || !facetSet.has(item.facet))) return false;
+
+  if (filters.subjectType && item.subjectType !== filters.subjectType) return false;
+  if (filters.subjectId && item.subjectId !== filters.subjectId) return false;
+
+  const prefix = typeof filters.patternKeyPrefix === "string"
+    ? filters.patternKeyPrefix.trim()
+    : "";
+  if (prefix && !(item.patternKey ?? "").startsWith(prefix)) return false;
+
+  if (filters.sourceDialogId && item.sourceDialogId !== filters.sourceDialogId) {
+    return false;
+  }
+
+  const tagSet = normalizeSet(filters.tags);
+  if (tagSet) {
+    const itemTags = new Set((item.tags ?? []).map((tag) => tag.trim()).filter(Boolean));
+    for (const tag of tagSet) {
+      if (!itemTags.has(tag)) return false;
+    }
+  }
+
+  return true;
+};
+
+const deleteMemoryItemWithIndexesInBatch = (
+  batch: any,
+  item: MemoryItem
+) => {
+  batch.del(createMemoryKey(item.ownerType, item.ownerId, item.id));
+  batch.del(
+    createMemoryOwnerIndexKey(
+      item.ownerType,
+      item.ownerId,
+      item.createdAt,
+      item.id
+    )
+  );
+  batch.del(
+    createMemorySubjectKindIndexKey(
+      item.subjectType,
+      item.subjectId,
+      item.kind,
+      item.createdAt,
+      item.id
+    )
+  );
+};
+
+export const deleteMemoriesForOwnerFromDb = async (
+  db: any,
+  owner: MemoryOwnerRef,
+  filters: DeleteMemoryFilters = {}
+): Promise<DeleteMemoryResult> => {
+  const range = memoryOwnerRange(owner.ownerType, owner.ownerId);
+  const matchedItems: MemoryItem[] = [];
+  const limit = typeof filters.limit === "number" && filters.limit > 0
+    ? filters.limit
+    : Number.POSITIVE_INFINITY;
+
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true,
+  })) {
+    const memoryId = typeof value?.memoryId === "string" ? value.memoryId : "";
+    if (!memoryId) continue;
+    const item = (await db
+      .get(createMemoryKey(owner.ownerType, owner.ownerId, memoryId))
+      .catch(() => null)) as MemoryItem | null;
+    if (!item) continue;
+    if (!matchesFilters(item, filters)) continue;
+    matchedItems.push(item);
+    if (matchedItems.length >= limit) break;
+  }
+
+  if (matchedItems.length === 0) {
+    return { deletedCount: 0, deletedIds: [], matchedItems: [] };
+  }
+
+  const batch = db.batch();
+  for (const item of matchedItems) {
+    deleteMemoryItemWithIndexesInBatch(batch, item);
+  }
+  await batch.write();
+
+  return {
+    deletedCount: matchedItems.length,
+    deletedIds: matchedItems.map((item) => item.id),
+    matchedItems,
+  };
+};
+
+export const deleteMemoriesForOwner = async (
+  owner: MemoryOwnerRef,
+  filters: DeleteMemoryFilters = {}
+): Promise<DeleteMemoryResult> =>
+  deleteMemoriesForOwnerFromDb(serverDb, owner, filters);

package/ai/memory/overlay.ts

@@ -0,0 +1,84 @@
+import type { MemoryItem } from "./types";
+
+const KIND_TITLES: Record<MemoryItem["kind"], string> = {
+  episodic: "Episodic",
+  semantic: "Semantic",
+  procedural: "Procedural",
+};
+
+const normalizeDisplayContent = (item: MemoryItem): string => {
+  const normalized = item.content
+    .trim()
+    .replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "")
+    .replace(/[。！？!?]+$/u, "")
+    .trim();
+  const stripPrefix = (prefix: string) =>
+    normalized.startsWith(prefix) ? normalized.slice(prefix.length).trim() : normalized;
+
+  if (item.kind === "semantic") {
+    if (item.tags?.includes("understanding-memory")) {
+      switch (item.facet) {
+        case "unfinished":
+          return `用户仍未定下：${stripPrefix("还没决定")}`;
+        case "tension":
+          return `用户当前在权衡：${stripPrefix("在权衡")}`;
+        case "preference":
+          return `用户当前更在意：${stripPrefix("更在意")}`;
+        case "style":
+          return `用户互动偏好：${stripPrefix("更喜欢")}`;
+        case "goal":
+          return `用户当前目标：${stripPrefix("想推进")}`;
+      }
+    }
+    return `用户长期偏好/事实：${normalized}`;
+  }
+
+  if (item.kind === "episodic" && item.patternKey === "explicit-remember") {
+    return `用户明确要求你记住：${normalized}`;
+  }
+
+  if (item.kind === "episodic" && item.tags?.includes("understanding-memory")) {
+    switch (item.facet) {
+      case "unfinished":
+        return `最近一次对话显示：用户还没定下 ${stripPrefix("还没决定")}`;
+      case "tension":
+        return `最近一次对话显示：用户还在权衡 ${stripPrefix("在权衡")}`;
+      case "preference":
+        return `最近一次对话显示：用户更在意 ${stripPrefix("更在意")}`;
+      case "style":
+        return `最近一次对话显示：用户更偏好 ${stripPrefix("更喜欢")}`;
+      case "goal":
+        return `最近一次对话显示：用户想推进 ${stripPrefix("想推进")}`;
+    }
+  }
+
+  return normalized;
+};
+
+export const buildMemoryOverlay = (items: MemoryItem[]): string | null => {
+  if (items.length === 0) return null;
+
+  const byKind: Record<string, MemoryItem[]> = {
+    episodic: [],
+    semantic: [],
+    procedural: [],
+  };
+  for (const item of items) {
+    byKind[item.kind].push(item);
+  }
+
+  const sections = Object.entries(byKind)
+    .filter(([, list]) => list.length > 0)
+    .map(([kind, list]) => {
+      const lines = list.slice(0, 3).map((item) => `- ${normalizeDisplayContent(item)}`);
+      return [`[${KIND_TITLES[kind as MemoryItem["kind"]]}]`, ...lines].join("\n");
+    });
+
+  return [
+    "--- Memory Overlay ---",
+    "以下是当前请求可用的记忆事实；相关时直接基于这些记忆回答。",
+    "用户当前输入优先于记忆；记忆只辅助理解，不要求迎合。",
+    "",
+    ...sections,
+  ].join("\n");
+};

package/ai/memory/query.ts

@@ -0,0 +1,38 @@
+import serverDb from "database/server/db";
+import type {
+  MemoryItem,
+  MemoryKind,
+  MemoryOwnerRef,
+  MemorySubjectRef,
+} from "./types";
+import {
+  buildDefaultSubjects,
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb,
+  loadOwnerItemsFromDb,
+  loadSubjectKindItemsFromDb,
+} from "./queryShared";
+
+export {
+  buildDefaultSubjects,
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb,
+  loadOwnerItemsFromDb,
+  loadSubjectKindItemsFromDb,
+};
+
+export const loadOwnerItems = async (
+  owner: MemoryOwnerRef,
+  limit: number
+): Promise<MemoryItem[]> => {
+  return loadOwnerItemsFromDb(serverDb, owner, limit);
+};
+
+export const loadMemoryCandidates = async (input: {
+  owners: MemoryOwnerRef[];
+  subjects: MemorySubjectRef[];
+  kinds?: MemoryKind[];
+  ownerLimit?: number;
+}): Promise<MemoryItem[]> => {
+  return loadMemoryCandidatesFromDb(serverDb, input);
+};