@lobehub/lobehub 2.0.0-next.360 → 2.0.0-next.361

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.361](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.360...v2.0.0-next.361)
+
+<sup>Released on **2026-01-24**</sup>
+
+#### ✨ Features
+
+- **userMemories**: Added memory layer activity.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **userMemories**: Added memory layer activity, closes [#11747](https://github.com/lobehub/lobe-chat/issues/11747) ([2021b1c](https://github.com/lobehub/lobe-chat/commit/2021b1c))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.360](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.359...v2.0.0-next.360)
 
 <sup>Released on **2026-01-24**</sup>

package/changelog/v1.json

@@ -1,4 +1,9 @@
 [
+  {
+    "children": {},
+    "date": "2026-01-24",
+    "version": "2.0.0-next.361"
+  },
   {
     "children": {
       "fixes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.360",
+  "version": "2.0.0-next.361",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/const/src/userMemory.ts

@@ -3,6 +3,7 @@ import { DEFAULT_EMBEDDING_PROVIDER } from '@lobechat/business-const';
 import { DEFAULT_EMBEDDING_MODEL } from './settings';
 
 export const DEFAULT_SEARCH_USER_MEMORY_TOP_K = {
+  activities: 3,
   contexts: 0,
   experiences: 0,
   preferences: 3,

package/packages/database/src/models/userMemory/model.ts

@@ -1,5 +1,6 @@
 import { AssociatedObjectSchema } from '@lobechat/memory-user-memory';
 import {
+  ActivityTypeEnum,
   IdentityTypeEnum,
   LayersEnum,
   MemorySourceType,
@@ -40,7 +41,10 @@ import {
   UserMemoryIdentity,
   UserMemoryItem,
   UserMemoryPreference,
+  UserMemoryActivitiesWithoutVectors,
+  UserMemoryActivity,
   userMemories,
+  userMemoriesActivities,
   userMemoriesContexts,
   userMemoriesExperiences,
   userMemoriesIdentities,
@@ -104,6 +108,16 @@ export interface CreateUserMemoryContextParams extends BaseCreateUserMemoryParam
   >;
 }
 
+export interface CreateUserMemoryActivityParams extends BaseCreateUserMemoryParams {
+  activity: Optional<
+    Omit<
+      UserMemoryActivity,
+      'id' | 'userId' | 'createdAt' | 'updatedAt' | 'accessedAt' | 'userMemoryId'
+    >,
+    'capturedAt'
+  >;
+}
+
 export interface CreateUserMemoryExperienceParams extends BaseCreateUserMemoryParams {
   experience: Optional<
     Omit<
@@ -135,6 +149,7 @@ export interface CreateUserMemoryPreferenceParams extends BaseCreateUserMemoryPa
 }
 
 export type CreateUserMemoryParams =
+  | CreateUserMemoryActivityParams
   | CreateUserMemoryContextParams
   | CreateUserMemoryExperienceParams
   | CreateUserMemoryIdentityParams
@@ -143,7 +158,7 @@ export type CreateUserMemoryParams =
 export interface SearchUserMemoryParams {
   embedding?: number[];
   limit?: number;
-  limits?: Partial<Record<'contexts' | 'experiences' | 'preferences', number>>;
+  limits?: Partial<Record<'activities' | 'contexts' | 'experiences' | 'preferences', number>>;
   memoryCategory?: string;
   memoryType?: string;
   query?: string;
@@ -151,12 +166,13 @@ export interface SearchUserMemoryParams {
 
 export interface SearchUserMemoryWithEmbeddingParams {
   embedding?: number[];
-  limits?: Partial<Record<'contexts' | 'experiences' | 'preferences', number>>;
+  limits?: Partial<Record<'activities' | 'contexts' | 'experiences' | 'preferences', number>>;
   memoryCategory?: string;
   memoryType?: string;
 }
 
 export interface UserMemorySearchAggregatedResult {
+  activities: UserMemoryActivitiesWithoutVectors[];
   contexts: UserMemoryContextWithoutVectors[];
   experiences: UserMemoryExperienceWithoutVectors[];
   preferences: UserMemoryPreferenceWithoutVectors[];
@@ -380,12 +396,67 @@ export class UserMemoryModel {
         const extra = JSON.parse(parsed.data.extra || '{}');
         parsed.data.extra = extra;
         associations.push(parsed.data);
+        return;
+      }
+
+      if (
+        item &&
+        typeof item === 'object' &&
+        'name' in item &&
+        typeof (item as any).name === 'string'
+      ) {
+        associations.push({ name: (item as any).name });
       }
     });
 
     return associations.length > 0 ? associations : [];
   }
 
+  static parseAssociatedLocations(
+    value?:
+      | {
+          address?: unknown;
+          name?: unknown;
+          tags?: unknown;
+          type?: unknown;
+        }[]
+      | Record<string, unknown>,
+  ) {
+    if (!value) return [];
+
+    const raw = Array.isArray(value) ? value : [value];
+    const locations: {
+      address?: string;
+      name?: string;
+      tags?: string[];
+      type?: string;
+    }[] = [];
+
+    raw.forEach((item) => {
+      if (!item || typeof item !== 'object') return;
+
+      const address = typeof (item as any).address === 'string' ? (item as any).address : undefined;
+      const name = typeof (item as any).name === 'string' ? (item as any).name : undefined;
+      const type = typeof (item as any).type === 'string' ? (item as any).type : undefined;
+      const tagsRaw = (item as any).tags;
+      const tags =
+        Array.isArray(tagsRaw) && tagsRaw.every((tag) => typeof tag === 'string')
+          ? (tagsRaw as string[])
+          : undefined;
+
+      if (address || name || type || tags) {
+        locations.push({
+          address,
+          name,
+          tags,
+          type,
+        });
+      }
+    });
+
+    return locations;
+  }
+
   static parseDateFromString(value?: string | Date | null): Date | null {
     if (!value) return null;
     if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
@@ -537,6 +608,46 @@ export class UserMemoryModel {
     });
   };
 
+  createActivityMemory = async (
+    params: CreateUserMemoryActivityParams,
+  ): Promise<{ activity: UserMemoryActivity; memory: UserMemoryItem }> => {
+    return this.db.transaction(async (tx) => {
+      const baseValues = this.buildBaseMemoryInsertValues(params, {
+        metadata: params.activity.metadata ?? null,
+        status: params.activity.status ?? 'pending',
+        tags: params.activity.tags ?? null,
+      });
+
+      const [memory] = await tx.insert(userMemories).values(baseValues).returning();
+      if (!memory) throw new Error('Failed to create user memory activity');
+
+      const activityValues = {
+        associatedLocations: params.activity.associatedLocations ?? null,
+        associatedObjects: params.activity.associatedObjects ?? [],
+        associatedSubjects: params.activity.associatedSubjects ?? [],
+        capturedAt: params.activity.capturedAt,
+        endsAt: coerceDate(params.activity.endsAt),
+        feedback: params.activity.feedback ?? null,
+        feedbackVector: params.activity.feedbackVector ?? null,
+        metadata: params.activity.metadata ?? null,
+        narrative: params.activity.narrative ?? null,
+        narrativeVector: params.activity.narrativeVector ?? null,
+        notes: params.activity.notes ?? null,
+        startsAt: coerceDate(params.activity.startsAt),
+        status: params.activity.status ?? null,
+        tags: params.activity.tags ?? [],
+        timezone: params.activity.timezone ?? null,
+        type: params.activity.type ?? ActivityTypeEnum.Other,
+        userId: this.userId,
+        userMemoryId: memory.id,
+      } satisfies typeof userMemoriesActivities.$inferInsert;
+
+      const [activity] = await tx.insert(userMemoriesActivities).values(activityValues).returning();
+
+      return { activity, memory };
+    });
+  };
+
   createPreferenceMemory = async (
     params: CreateUserMemoryPreferenceParams,
   ): Promise<{ memory: UserMemoryItem; preference: UserMemoryPreference }> => {
@@ -575,12 +686,13 @@ export class UserMemoryModel {
     const { embedding, limits } = params;
 
     const resolvedLimits = {
+      activities: limits?.activities,
       contexts: limits?.contexts,
       experiences: limits?.experiences,
       preferences: limits?.preferences,
     };
 
-    const [experiences, contexts, preferences] = await Promise.all([
+    const [experiences, contexts, preferences, activities] = await Promise.all([
       this.searchExperiences({
         embedding,
         limit: resolvedLimits.experiences,
@@ -593,6 +705,10 @@ export class UserMemoryModel {
         embedding,
         limit: resolvedLimits.preferences,
       }),
+      this.searchActivities({
+        embedding,
+        limit: resolvedLimits.activities,
+      }),
     ]);
 
     const accessedMemoryIds = new Set<string>();
@@ -602,6 +718,9 @@ export class UserMemoryModel {
     preferences.forEach((preference) => {
       if (preference.userMemoryId) accessedMemoryIds.add(preference.userMemoryId);
     });
+    activities.forEach((activity) => {
+      if (activity.userMemoryId) accessedMemoryIds.add(activity.userMemoryId);
+    });
     const contextLinkIds: string[] = [];
     contexts.forEach((context) => {
       const ids = Array.isArray(context.userMemoryIds) ? (context.userMemoryIds as string[]) : [];
@@ -617,6 +736,7 @@ export class UserMemoryModel {
     }
 
     return {
+      activities,
       contexts,
       experiences,
       preferences,
@@ -1795,6 +1915,61 @@ export class UserMemoryModel {
     await this.db.delete(userMemories).where(eq(userMemories.userId, this.userId));
   };
 
+  searchActivities = async (params: {
+    embedding?: number[];
+    limit?: number;
+    type?: string;
+  }): Promise<UserMemoryActivitiesWithoutVectors[]> => {
+    const { embedding, limit = 5, type } = params;
+    if (limit <= 0) {
+      return [];
+    }
+
+    let query = this.db
+      .select({
+        accessedAt: userMemoriesActivities.accessedAt,
+        associatedLocations: userMemoriesActivities.associatedLocations,
+        associatedObjects: userMemoriesActivities.associatedObjects,
+        associatedSubjects: userMemoriesActivities.associatedSubjects,
+        capturedAt: userMemoriesActivities.capturedAt,
+        createdAt: userMemoriesActivities.createdAt,
+        endsAt: userMemoriesActivities.endsAt,
+        feedback: userMemoriesActivities.feedback,
+        id: userMemoriesActivities.id,
+        metadata: userMemoriesActivities.metadata,
+        narrative: userMemoriesActivities.narrative,
+        notes: userMemoriesActivities.notes,
+        startsAt: userMemoriesActivities.startsAt,
+        status: userMemoriesActivities.status,
+        tags: userMemoriesActivities.tags,
+        timezone: userMemoriesActivities.timezone,
+        type: userMemoriesActivities.type,
+        updatedAt: userMemoriesActivities.updatedAt,
+        userId: userMemoriesActivities.userId,
+        userMemoryId: userMemoriesActivities.userMemoryId,
+        ...(embedding && {
+          similarity: sql<number>`1 - (${cosineDistance(userMemoriesActivities.narrativeVector, embedding)}) AS similarity`,
+        }),
+      })
+      .from(userMemoriesActivities)
+      .$dynamic();
+
+    const conditions = [eq(userMemoriesActivities.userId, this.userId)];
+    if (type) {
+      conditions.push(eq(userMemoriesActivities.type, type));
+    }
+
+    query = query.where(and(...conditions));
+
+    if (embedding) {
+      query = query.orderBy(desc(sql`similarity`));
+    } else {
+      query = query.orderBy(desc(userMemoriesActivities.createdAt));
+    }
+
+    return query.limit(limit) as Promise<UserMemoryActivitiesWithoutVectors[]>;
+  };
+
   searchContexts = async (params: {
     embedding?: number[];
     limit?: number;

package/packages/database/src/models/userMemory/sources/benchmarkLoCoMo.ts

@@ -63,7 +63,7 @@ export class UserMemorySourceBenchmarkLoCoMoModel {
     return { id };
   }
 
-  async replaceParts(sourceId: string, parts: BenchmarkLoCoMoPart[]) {
+  replaceParts(sourceId: string, parts: BenchmarkLoCoMoPart[]) {
     const store = this.getPartStore();
     store.delete(sourceId);
     if (!parts.length) return;

package/packages/memory-user-memory/package.json

@@ -20,8 +20,8 @@
     "@lobechat/context-engine": "workspace:*",
     "@lobechat/model-runtime": "workspace:*",
     "@lobechat/prompts": "workspace:*",
-    "dotenv": "^17.2.3",
     "dayjs": "^1.11.11",
+    "dotenv": "^17.2.3",
     "ora": "^9.0.0",
     "unist-builder": "^4.0.0",
     "xast-util-to-xml": "^4.0.0",
@@ -30,6 +30,7 @@
   },
   "devDependencies": {
     "@lobechat/types": "workspace:*",
+    "@types/json-schema": "^7.0.15",
     "@types/xast": "^2.0.4",
     "promptfoo": "^0.118.17",
     "tsx": "^4.20.6"

package/packages/memory-user-memory/promptfoo/evals/activity/basic/buildMessages.ts

@@ -0,0 +1,40 @@
+import { renderPlaceholderTemplate } from '@lobechat/context-engine';
+
+import { activityPrompt } from '../../../../src/prompts';
+import type { ExtractorTemplateProps } from '../../../../src/types';
+
+export interface PromptVars extends ExtractorTemplateProps {
+  conversation: string;
+}
+
+export const buildActivityMessages = (vars: PromptVars) => {
+  const retrievedContext =
+    Array.isArray(vars.retrievedContexts) && vars.retrievedContexts.length > 0
+      ? vars.retrievedContexts.join('\n\n')
+      : typeof vars.retrievedContexts === 'string'
+        ? vars.retrievedContexts
+        : 'No similar memories retrieved.';
+
+  const rendered = renderPlaceholderTemplate(activityPrompt, {
+    availableCategories: vars.availableCategories,
+    language: vars.language || 'English',
+    retrievedContext,
+    sessionDate: vars.sessionDate || new Date().toISOString(),
+    topK: vars.topK ?? 5,
+    username: vars.username || 'User',
+  });
+
+  const messages = [
+    { content: rendered, role: 'system' as const },
+    { content: rendered, role: 'user' as const },
+  ];
+
+  if (vars.conversation) {
+    messages.push({
+      content: `Conversation:\n${vars.conversation}`,
+      role: 'user' as const,
+    });
+  }
+
+  return messages;
+};

package/packages/memory-user-memory/promptfoo/evals/activity/basic/eval.yaml

@@ -0,0 +1,13 @@
+description: Regression benchmark for activity layer structured extraction
+
+providers:
+  - id: openai:chat:gpt-5-mini
+    config:
+      response_format: file://../../../response-formats/activity.json
+      temperature: 0
+
+prompts:
+  - file://./prompt.ts
+
+tests:
+  - file://./tests/cases.ts

package/packages/memory-user-memory/promptfoo/evals/activity/basic/prompt.ts

@@ -0,0 +1,5 @@
+import { buildActivityMessages, PromptVars } from './buildMessages';
+
+export default function generatePrompt({ vars }: { vars: PromptVars }) {
+  return buildActivityMessages(vars);
+}

package/packages/memory-user-memory/promptfoo/evals/activity/basic/tests/cases.ts

@@ -0,0 +1,106 @@
+type PromptfooAssert =
+  | { type: 'javascript'; value: string }
+  | { provider?: string; type: 'llm-rubric'; value: string };
+
+interface PromptfooTestCase {
+  assert: PromptfooAssert[];
+  description?: string;
+  vars: Record<string, unknown>;
+}
+
+const baseSchemaAssert: PromptfooAssert = {
+  type: 'javascript',
+  value: `
+    let parsed;
+    try {
+      parsed = JSON.parse(output);
+    } catch (error) {
+      console.error('Failed to parse JSON output', error);
+      return false;
+    }
+
+    if (!parsed || !Array.isArray(parsed.memories)) return false;
+
+    return parsed.memories.every((memory) => {
+      return (
+        memory.memoryType === 'activity' &&
+        memory.title &&
+        memory.summary &&
+        memory.withActivity?.type &&
+        memory.withActivity?.narrative
+      );
+    });
+  `,
+};
+
+const baseVars = {
+  availableCategories: ['work', 'health', 'personal'],
+  language: 'English',
+  topK: 5,
+  username: 'User',
+};
+
+const testCases: PromptfooTestCase[] = [
+  {
+    assert: [
+      baseSchemaAssert,
+      {
+        type: 'javascript',
+        value: `
+          const data = JSON.parse(output);
+          const first = data.memories?.[0];
+          if (!first) return false;
+
+          const activity = first.withActivity || {};
+          return Boolean(activity.startsAt && activity.endsAt && activity.timezone && activity.associatedLocations?.[0]?.name);
+        `,
+      },
+      {
+        provider: 'openai:gpt-5-mini',
+        type: 'llm-rubric',
+        value:
+          'Should extract a meeting activity including timing (start/end/timezone), location name ACME HQ, status completed when implied, and feedback reflecting the positive tone.',
+      },
+    ],
+    description: 'Meeting with explicit time and location',
+    vars: {
+      ...baseVars,
+      conversation:
+        'User: I met with Alice at ACME HQ on 2024-05-03 from 14:00-15:00 America/New_York. We reviewed Q2 renewal scope and agreed to send revised pricing next week. I felt positive and collaborative about the call.',
+      retrievedContexts: ['Previous similar memory: met with Alice about renewal last month.'],
+      sessionDate: '2024-05-03',
+    },
+  },
+  {
+    assert: [
+      baseSchemaAssert,
+      {
+        type: 'javascript',
+        value: `
+          const data = JSON.parse(output);
+          const first = data.memories?.[0];
+          if (!first) return false;
+
+          const activity = first.withActivity || {};
+          return Boolean(activity.narrative && activity.feedback);
+        `,
+      },
+      {
+        provider: 'openai:gpt-5-mini',
+        type: 'llm-rubric',
+        value:
+          'Should capture an exercise activity without inventing exact timestamps or timezones; keep the narrative and feedback about the yoga session at home and omit temporal fields that were not provided.',
+      },
+    ],
+    description: 'Exercise without explicit time or timezone',
+    vars: {
+      ...baseVars,
+      conversation:
+        'User: Over the weekend I did a 30-minute yoga session at home with my roommate. No specific time was set, it was just a casual stretch and it left me feeling calm.',
+      retrievedContexts: [],
+      sessionDate: '2025-05-05 10:02:00',
+    },
+  },
+];
+
+export default testCases;

package/packages/memory-user-memory/promptfoo/evals/activity/locomo/buildMessages.ts

@@ -0,0 +1,104 @@
+import { renderPlaceholderTemplate } from '@lobechat/context-engine';
+import { MemorySourceType } from '@lobechat/types';
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+
+import { BenchmarkLocomoContextProvider, BenchmarkLocomoPart } from '../../../../src/providers';
+import type { IngestPayload } from '../../../../src/converters/locomo';
+import { activityPrompt } from '../../../../src/prompts';
+import type { ExtractorTemplateProps, MemoryExtractionJob } from '../../../../src/types';
+
+export interface PromptVars extends ExtractorTemplateProps {
+  payloadPath: string;
+  sessionId?: string;
+  userId?: string;
+}
+
+const resolvePath = (payloadPath: string) =>
+  isAbsolute(payloadPath) ? payloadPath : join(process.cwd(), payloadPath);
+
+const buildParts = (payload: IngestPayload, sessionId?: string): BenchmarkLocomoPart[] => {
+  let partIndex = 0;
+  const sessions = payload.sessions.filter(
+    (session) => !sessionId || session.sessionId === sessionId,
+  );
+
+  return sessions.flatMap((session) =>
+    session.turns.map((turn) => {
+      const metadata = {
+        diaId: turn.diaId,
+        imageCaption: turn.imageCaption,
+        imageUrls: turn.imageUrls,
+        sessionId: session.sessionId,
+      };
+
+      return {
+        content: turn.text,
+        createdAt: turn.createdAt || session.timestamp,
+        metadata,
+        partIndex: partIndex++,
+        sessionId: session.sessionId,
+        speaker: turn.speaker,
+      };
+    }),
+  );
+};
+
+const resolveSessionDate = (payload: IngestPayload, parts: BenchmarkLocomoPart[], sessionId?: string) => {
+  const sessionDate =
+    payload.sessions.find((session) => session.sessionId === sessionId)?.timestamp ||
+    payload.sessions[0]?.timestamp;
+
+  if (sessionDate) return sessionDate;
+
+  const latestCreatedAt = parts
+    .map((part) => (part.createdAt ? new Date(part.createdAt) : null))
+    .filter(Boolean)
+    .sort((a, b) => (a!.getTime() > b!.getTime() ? 1 : -1))
+    .at(-1);
+
+  return latestCreatedAt ? latestCreatedAt.toISOString() : new Date().toISOString();
+};
+
+export const buildLocomoActivityMessages = async (vars: PromptVars) => {
+  const payloadPath = resolvePath(vars.payloadPath);
+  const payloadRaw = await readFile(payloadPath, 'utf8');
+  const payload = JSON.parse(payloadRaw) as IngestPayload;
+
+  const parts = buildParts(payload, vars.sessionId);
+  if (parts.length === 0) {
+    throw new Error(`No matching parts found in ${payload.sampleId} for session ${vars.sessionId || 'all'}`);
+  }
+  const userId = vars.userId || `locomo-user-${payload.sampleId}`;
+  const sourceId = payload.topicId || `sample_${payload.sampleId}`;
+  const sessionDate = vars.sessionDate || resolveSessionDate(payload, parts, vars.sessionId);
+
+  const provider = new BenchmarkLocomoContextProvider({
+    parts,
+    sampleId: payload.sampleId,
+    sourceId,
+    userId,
+  });
+
+  const extractionJob: MemoryExtractionJob = {
+    source: MemorySourceType.BenchmarkLocomo,
+    sourceId,
+    userId,
+  };
+
+  const { context } = await provider.buildContext(extractionJob);
+
+  const rendered = renderPlaceholderTemplate(activityPrompt, {
+    availableCategories: vars.availableCategories,
+    language: vars.language || 'English',
+    retrievedContext: context || 'No similar memories retrieved.',
+    sessionDate,
+    topK: vars.topK ?? 5,
+    username: vars.username || 'User',
+  });
+
+  return [
+    { content: rendered, role: 'system' as const },
+    { content: rendered, role: 'user' as const },
+  ];
+};

package/packages/memory-user-memory/promptfoo/evals/activity/locomo/eval.yaml

@@ -0,0 +1,13 @@
+description: LoCoMo regression for activity layer with relative time resolution
+
+providers:
+  - id: openai:chat:gpt-5-mini
+    config:
+      response_format: file://../../../response-formats/activity.json
+      temperature: 0
+
+prompts:
+  - file://./prompt.ts
+
+tests:
+  - file://./tests/cases.ts

package/packages/memory-user-memory/promptfoo/evals/activity/locomo/prompt.ts

@@ -0,0 +1,5 @@
+import { buildLocomoActivityMessages, PromptVars } from './buildMessages';
+
+export default async function generatePrompt({ vars }: { vars: PromptVars }) {
+  return buildLocomoActivityMessages(vars);
+}