@lobehub/lobehub 2.0.0-next.335 → 2.0.0-next.337

package/packages/context-engine/src/engine/tools/__tests__/ToolArgumentsRepairer.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, it } from 'vitest';
+
+import { ToolArgumentsRepairer } from '../ToolArgumentsRepairer';
+import type { LobeToolManifest } from '../types';
+
+describe('ToolArgumentsRepairer', () => {
+  describe('repair - basic functionality', () => {
+    it('should return original parsed data when no schema provided', () => {
+      const repairer = new ToolArgumentsRepairer();
+      const parsed = { foo: 'bar' };
+
+      const result = repairer.repair(parsed);
+
+      expect(result).toEqual(parsed);
+    });
+
+    it('should return original parsed data when schema has no required fields', () => {
+      const repairer = new ToolArgumentsRepairer();
+      const parsed = { foo: 'bar' };
+      const schema = { type: 'object', properties: { foo: { type: 'string' } } };
+
+      const result = repairer.repair(parsed, schema);
+
+      expect(result).toEqual(parsed);
+    });
+
+    it('should return original parsed data when all required fields are present', () => {
+      const repairer = new ToolArgumentsRepairer();
+      const parsed = { description: 'test', instruction: 'do something' };
+      const schema = {
+        type: 'object',
+        required: ['description', 'instruction'],
+        properties: {
+          description: { type: 'string' },
+          instruction: { type: 'string' },
+        },
+      };
+
+      const result = repairer.repair(parsed, schema);
+
+      expect(result).toEqual(parsed);
+    });
+  });
+
+  describe('repair - malformed JSON from LLM', () => {
+    it('should repair malformed JSON with escaped string issue', () => {
+      const repairer = new ToolArgumentsRepairer();
+
+      // This is the malformed data from haiku-4.5 model
+      // The entire JSON got stuffed into the "description" field with escaped quotes
+      const malformedParsed = {
+        description:
+          'Synthesize all 10 batch analyses into 10 most important themes for product builders", "instruction": "You have access to 10 batch analysis files", "runInClient": true, "timeout": 120000}',
+      };
+
+      const schema = {
+        type: 'object',
+        required: ['description', 'instruction'],
+        properties: {
+          description: { type: 'string' },
+          instruction: { type: 'string' },
+          runInClient: { type: 'boolean' },
+          timeout: { type: 'number' },
+        },
+      };
+
+      const result = repairer.repair(malformedParsed, schema);
+
+      expect(result).toHaveProperty('description');
+      expect(result).toHaveProperty('instruction');
+      expect(result).toHaveProperty('runInClient', true);
+      expect(result).toHaveProperty('timeout', 120000);
+      expect(result.description).toBe(
+        'Synthesize all 10 batch analyses into 10 most important themes for product builders',
+      );
+      expect(result.instruction).toBe('You have access to 10 batch analysis files');
+    });
+
+    it('should return original data if repair fails', () => {
+      const repairer = new ToolArgumentsRepairer();
+
+      // Invalid malformed data that cannot be repaired
+      const malformedParsed = {
+        description: 'some text without proper escape pattern',
+      };
+
+      const schema = {
+        type: 'object',
+        required: ['description', 'instruction'],
+        properties: {
+          description: { type: 'string' },
+          instruction: { type: 'string' },
+        },
+      };
+
+      const result = repairer.repair(malformedParsed, schema);
+
+      // Should return original since pattern doesn't match
+      expect(result).toEqual(malformedParsed);
+    });
+  });
+
+  describe('parse - integrated parsing and repair', () => {
+    it('should parse and repair arguments using manifest schema', () => {
+      const manifest: LobeToolManifest = {
+        identifier: 'lobe-gtd',
+        api: [
+          {
+            name: 'execTask',
+            description: 'Execute async task',
+            parameters: {
+              type: 'object',
+              required: ['description', 'instruction'],
+              properties: {
+                description: { type: 'string' },
+                instruction: { type: 'string' },
+                runInClient: { type: 'boolean' },
+                timeout: { type: 'number' },
+              },
+            },
+          },
+        ],
+        type: 'builtin',
+      } as unknown as LobeToolManifest;
+
+      const repairer = new ToolArgumentsRepairer(manifest);
+
+      // Malformed arguments string
+      const malformedArguments = JSON.stringify({
+        description:
+          'Test task", "instruction": "Do something important", "runInClient": true, "timeout": 60000}',
+      });
+
+      const result = repairer.parse('execTask', malformedArguments);
+
+      expect(result).toHaveProperty('description', 'Test task');
+      expect(result).toHaveProperty('instruction', 'Do something important');
+      expect(result).toHaveProperty('runInClient', true);
+      expect(result).toHaveProperty('timeout', 60000);
+    });
+
+    it('should handle normal arguments without repair needed', () => {
+      const manifest: LobeToolManifest = {
+        identifier: 'test-tool',
+        api: [
+          {
+            name: 'testApi',
+            description: 'Test API',
+            parameters: {
+              type: 'object',
+              required: ['name'],
+              properties: {
+                name: { type: 'string' },
+              },
+            },
+          },
+        ],
+        type: 'default',
+      } as unknown as LobeToolManifest;
+
+      const repairer = new ToolArgumentsRepairer(manifest);
+      const normalArguments = JSON.stringify({ name: 'test value' });
+
+      const result = repairer.parse('testApi', normalArguments);
+
+      expect(result).toEqual({ name: 'test value' });
+    });
+
+    it('should handle no manifest gracefully', () => {
+      const repairer = new ToolArgumentsRepairer();
+      const arguments_ = JSON.stringify({ foo: 'bar' });
+
+      const result = repairer.parse('unknownApi', arguments_);
+
+      expect(result).toEqual({ foo: 'bar' });
+    });
+
+    it('should handle invalid JSON gracefully', () => {
+      const repairer = new ToolArgumentsRepairer();
+
+      const result = repairer.parse('test', 'invalid json');
+
+      expect(result).toEqual({});
+    });
+  });
+});

package/packages/context-engine/src/engine/tools/index.ts

@@ -4,6 +4,9 @@ export { ToolsEngine } from './ToolsEngine';
 // Tool Name Resolver
 export { ToolNameResolver } from './ToolNameResolver';
 
+// Tool Arguments Repairer
+export { ToolArgumentsRepairer, type ToolParameterSchema } from './ToolArgumentsRepairer';
+
 // Types and interfaces
 export type {
   FunctionCallChecker,

package/packages/conversation-flow/src/__tests__/fixtures/inputs/tasks/index.ts

@@ -1,10 +1,12 @@
 import type { Message } from '../../../../types';
 import multiTasksWithSummary from './multi-tasks-with-summary.json';
 import simple from './simple.json';
+import withAssistantGroup from './with-assistant-group.json';
 import withSummary from './with-summary.json';
 
 export const tasks = {
   multiTasksWithSummary: multiTasksWithSummary as Message[],
   simple: simple as Message[],
+  withAssistantGroup: withAssistantGroup as Message[],
   withSummary: withSummary as Message[],
 };

package/packages/conversation-flow/src/__tests__/fixtures/inputs/tasks/with-assistant-group.json

@@ -0,0 +1,156 @@
+[
+  {
+    "id": "msg-user-1",
+    "role": "user",
+    "content": "Create three parallel tasks to research AI topics.",
+    "parentId": null,
+    "createdAt": 1735526559382,
+    "updatedAt": 1735526559382
+  },
+  {
+    "id": "msg-assistant-1",
+    "role": "assistant",
+    "content": "Creating three parallel research tasks.",
+    "parentId": "msg-user-1",
+    "createdAt": 1735526560163,
+    "updatedAt": 1735526585550,
+    "model": "gpt-4",
+    "provider": "openai",
+    "tools": [
+      {
+        "id": "call_exec_tasks_1",
+        "type": "builtin",
+        "apiName": "execTasks",
+        "arguments": "{\"tasks\": [{\"description\": \"Research LLM architectures\"}, {\"description\": \"Research AI agents\"}, {\"description\": \"Research RAG systems\"}]}",
+        "identifier": "lobe-gtd"
+      }
+    ]
+  },
+  {
+    "id": "msg-tool-1",
+    "role": "tool",
+    "content": "Triggered 3 async tasks",
+    "parentId": "msg-assistant-1",
+    "tool_call_id": "call_exec_tasks_1",
+    "createdAt": 1735526588116,
+    "updatedAt": 1735526591337,
+    "pluginState": {
+      "type": "execTasks",
+      "tasks": [
+        { "description": "Research LLM architectures" },
+        { "description": "Research AI agents" },
+        { "description": "Research RAG systems" }
+      ],
+      "parentMessageId": "msg-tool-1"
+    }
+  },
+  {
+    "id": "msg-task-llm",
+    "role": "task",
+    "content": "# LLM Architectures\n\nTransformer-based models dominate...",
+    "parentId": "msg-tool-1",
+    "createdAt": 1735526594643,
+    "updatedAt": 1735526756262,
+    "taskDetail": {
+      "duration": 120000,
+      "status": "completed",
+      "threadId": "thd_llm",
+      "title": "Research LLM architectures",
+      "totalCost": 0.015,
+      "totalMessages": 15,
+      "totalTokens": 100000
+    }
+  },
+  {
+    "id": "msg-task-agents",
+    "role": "task",
+    "content": "# AI Agents\n\nAutonomous agents using LLMs...",
+    "parentId": "msg-tool-1",
+    "createdAt": 1735526595647,
+    "updatedAt": 1735526792430,
+    "taskDetail": {
+      "duration": 150000,
+      "status": "completed",
+      "threadId": "thd_agents",
+      "title": "Research AI agents",
+      "totalCost": 0.018,
+      "totalMessages": 20,
+      "totalTokens": 120000
+    }
+  },
+  {
+    "id": "msg-task-rag",
+    "role": "task",
+    "content": "# RAG Systems\n\nRetrieval Augmented Generation combines...",
+    "parentId": "msg-tool-1",
+    "createdAt": 1735526596000,
+    "updatedAt": 1735526800000,
+    "taskDetail": {
+      "duration": 130000,
+      "status": "completed",
+      "threadId": "thd_rag",
+      "title": "Research RAG systems",
+      "totalCost": 0.016,
+      "totalMessages": 18,
+      "totalTokens": 110000
+    }
+  },
+  {
+    "id": "msg-assistant-after-task",
+    "role": "assistant",
+    "content": "All tasks completed. Let me check the analysis files created.",
+    "parentId": "msg-task-rag",
+    "createdAt": 1735526810000,
+    "updatedAt": 1735526815000,
+    "agentId": "agent-main",
+    "model": "gpt-4",
+    "provider": "openai",
+    "tools": [
+      {
+        "id": "call_list_files",
+        "type": "builtin",
+        "apiName": "listFiles",
+        "arguments": "{\"path\": \"/analysis\"}",
+        "identifier": "lobe-local-system"
+      }
+    ],
+    "metadata": {
+      "totalInputTokens": 100,
+      "totalOutputTokens": 50,
+      "totalTokens": 150,
+      "cost": 0.001
+    }
+  },
+  {
+    "id": "msg-tool-list-files",
+    "role": "tool",
+    "content": "./ANALYSIS_1.md\n./ANALYSIS_2.md\n./ANALYSIS_3.md",
+    "parentId": "msg-assistant-after-task",
+    "tool_call_id": "call_list_files",
+    "createdAt": 1735526816000,
+    "updatedAt": 1735526817000,
+    "pluginState": {
+      "result": {
+        "output": "./ANALYSIS_1.md\n./ANALYSIS_2.md\n./ANALYSIS_3.md",
+        "success": true
+      }
+    }
+  },
+  {
+    "id": "msg-assistant-final",
+    "role": "assistant",
+    "content": "I found 3 analysis files. Let me summarize the findings for you.",
+    "parentId": "msg-tool-list-files",
+    "createdAt": 1735526820000,
+    "updatedAt": 1735526825000,
+    "agentId": "agent-main",
+    "model": "gpt-4",
+    "provider": "openai",
+    "metadata": {
+      "totalInputTokens": 200,
+      "totalOutputTokens": 80,
+      "totalTokens": 280,
+      "cost": 0.002
+    }
+  }
+]

package/packages/conversation-flow/src/__tests__/parse.test.ts

@@ -219,6 +219,28 @@ describe('parse', () => {
       expect(result.flatList[3].id).toBe('msg-assistant-summary');
       expect(result.flatList[3].content).toContain('All 10 tasks completed');
     });
+
+    it('should merge assistant with tools after task into AssistantGroup', () => {
+      const result = parse(inputs.tasks.withAssistantGroup);
+
+      // The critical assertions:
+      // 1. flatList should have 4 items: user, assistantGroup(+tool), tasks(3 tasks), assistantGroup(with tool chain)
+      expect(result.flatList).toHaveLength(4);
+      expect(result.flatList[0].role).toBe('user');
+      expect(result.flatList[1].role).toBe('assistantGroup');
+      expect(result.flatList[2].role).toBe('tasks');
+      expect(result.flatList[3].role).toBe('assistantGroup');
+
+      // 2. The last assistantGroup should contain the full chain:
+      //    - msg-assistant-after-task (with tool)
+      //    - msg-assistant-final (without tool)
+      const lastGroup = result.flatList[3] as any;
+      expect(lastGroup.children).toHaveLength(2);
+      expect(lastGroup.children[0].id).toBe('msg-assistant-after-task');
+      expect(lastGroup.children[0].tools).toBeDefined();
+      expect(lastGroup.children[0].tools[0].result_msg_id).toBe('msg-tool-list-files');
+      expect(lastGroup.children[1].id).toBe('msg-assistant-final');
+    });
   });
 
   describe('Performance', () => {

package/packages/conversation-flow/src/transformation/FlatListBuilder.ts

@@ -107,9 +107,18 @@ export class FlatListBuilder {
             if (!processedIds.has(nonTaskChildId)) {
               const nonTaskChild = this.messageMap.get(nonTaskChildId);
               if (nonTaskChild) {
-                flatList.push(nonTaskChild);
-                processedIds.add(nonTaskChildId);
-                this.buildFlatListRecursive(nonTaskChildId, flatList, processedIds, allMessages);
+                // Check if it's an AssistantGroup (assistant with tools)
+                if (
+                  nonTaskChild.role === 'assistant' &&
+                  nonTaskChild.tools &&
+                  nonTaskChild.tools.length > 0
+                ) {
+                  this.processAssistantGroup(nonTaskChild, flatList, processedIds, allMessages);
+                } else {
+                  flatList.push(nonTaskChild);
+                  processedIds.add(nonTaskChildId);
+                  this.buildFlatListRecursive(nonTaskChildId, flatList, processedIds, allMessages);
+                }
               }
             }
           }
@@ -121,14 +130,28 @@ export class FlatListBuilder {
               if (!processedIds.has(taskGrandchildId)) {
                 const taskGrandchild = this.messageMap.get(taskGrandchildId);
                 if (taskGrandchild && taskGrandchild.role !== 'task') {
-                  flatList.push(taskGrandchild);
-                  processedIds.add(taskGrandchildId);
-                  this.buildFlatListRecursive(
-                    taskGrandchildId,
-                    flatList,
-                    processedIds,
-                    allMessages,
-                  );
+                  // Check if it's an AssistantGroup (assistant with tools)
+                  if (
+                    taskGrandchild.role === 'assistant' &&
+                    taskGrandchild.tools &&
+                    taskGrandchild.tools.length > 0
+                  ) {
+                    this.processAssistantGroup(
+                      taskGrandchild,
+                      flatList,
+                      processedIds,
+                      allMessages,
+                    );
+                  } else {
+                    flatList.push(taskGrandchild);
+                    processedIds.add(taskGrandchildId);
+                    this.buildFlatListRecursive(
+                      taskGrandchildId,
+                      flatList,
+                      processedIds,
+                      allMessages,
+                    );
+                  }
                 }
               }
             }
@@ -427,6 +450,60 @@ export class FlatListBuilder {
     }
   }
 
+  /**
+   * Process an assistant message with tools into an AssistantGroup
+   * Extracted to avoid code duplication in task children handling
+   */
+  private processAssistantGroup(
+    message: Message,
+    flatList: Message[],
+    processedIds: Set<string>,
+    allMessages: Message[],
+  ): void {
+    // Collect the entire assistant group chain
+    const assistantChain: Message[] = [];
+    const allToolMessages: Message[] = [];
+    this.messageCollector.collectAssistantChain(
+      message,
+      allMessages,
+      assistantChain,
+      allToolMessages,
+      processedIds,
+    );
+
+    // Create assistantGroup virtual message
+    const groupMessage = this.createAssistantGroupMessage(
+      assistantChain[0],
+      assistantChain,
+      allToolMessages,
+    );
+    flatList.push(groupMessage);
+
+    // Mark all as processed
+    assistantChain.forEach((m) => processedIds.add(m.id));
+    allToolMessages.forEach((m) => processedIds.add(m.id));
+
+    // Continue after the assistant chain
+    // Priority 1: If last assistant has non-tool children, continue from it
+    // Priority 2: Otherwise continue from tools (for cases where user replies to tool)
+    const lastAssistant = assistantChain.at(-1);
+    const toolIds = new Set(allToolMessages.map((t) => t.id));
+
+    const lastAssistantNonToolChildren = lastAssistant
+      ? this.childrenMap.get(lastAssistant.id)?.filter((childId) => !toolIds.has(childId))
+      : undefined;
+
+    if (lastAssistantNonToolChildren && lastAssistantNonToolChildren.length > 0 && lastAssistant) {
+      // Follow-up messages exist after the last assistant (not tools)
+      this.buildFlatListRecursive(lastAssistant.id, flatList, processedIds, allMessages);
+    } else {
+      // No non-tool children of last assistant, check tools for children
+      for (const toolMsg of allToolMessages) {
+        this.buildFlatListRecursive(toolMsg.id, flatList, processedIds, allMessages);
+      }
+    }
+  }
+
   /**
    * Check if message has compare mode in metadata
    */

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

@@ -86,7 +86,7 @@ export interface BaseCreateUserMemoryParams {
   details: string;
   detailsEmbedding?: number[];
   memoryCategory: string;
-  memoryLayer: LayersEnum;
+  memoryLayer?: LayersEnum;
   memoryType: TypesEnum;
   summary: string;
   summaryEmbedding?: number[];

package/packages/memory-user-memory/src/extractors/context.test.ts

@@ -39,7 +39,6 @@ describe('ContextExtractor', () => {
     const memoryItem = memories.items;
 
     expect(memories.type).toBe('array');
-    expect(memoryItem.properties.memoryLayer.const).toBe('context');
     // memoryCategory is a plain string in schema, not an enum
     expect(memoryItem.properties.memoryCategory.type).toBe('string');
     expect(memoryItem.properties.memoryType.enum).toEqual(memoryTypeValues);

package/packages/memory-user-memory/src/extractors/experience.test.ts

@@ -39,7 +39,6 @@ describe('ExperienceExtractor', () => {
     const memoryItem = memories.items;
 
     expect(memories.type).toBe('array');
-    expect(memoryItem.properties.memoryLayer.const).toBe('experience');
     // memoryCategory is a plain string in schema, not an enum
     expect(memoryItem.properties.memoryCategory.type).toBe('string');
     expect(memoryItem.properties.memoryType.enum).toEqual(memoryTypeValues);

package/packages/memory-user-memory/src/extractors/identity.test.ts

@@ -46,7 +46,6 @@ describe('IdentityExtractor', () => {
         {
           details: null,
           memoryCategory: 'personal',
-          memoryLayer: 'identity',
           memoryType: 'fact',
           summary: 'New identity summary',
           tags: ['tag'],

package/packages/memory-user-memory/src/extractors/preference.test.ts

@@ -39,7 +39,6 @@ describe('PreferenceExtractor', () => {
     const memoryItem = memories.items;
 
     expect(memories.type).toBe('array');
-    expect(memoryItem.properties.memoryLayer.const).toBe('preference');
     // memoryCategory is a plain string in schema, not an enum
     expect(memoryItem.properties.memoryCategory.type).toBe('string');
     expect(memoryItem.properties.memoryType.enum).toEqual(memoryTypeValues);

package/packages/memory-user-memory/src/schemas/context.ts

@@ -1,6 +1,5 @@
 import {
   ContextStatusEnum,
-  LayersEnum,
   UserMemoryContextObjectType,
   UserMemoryContextSubjectType,
 } from '@lobechat/types';
@@ -79,7 +78,6 @@ export const WithContextSchema = z.object({
 export const ContextMemoryItemSchema = z.object({
   details: z.string().describe('Optional detailed information'),
   memoryCategory: z.string().describe('Memory category'),
-  memoryLayer: z.literal(LayersEnum.Context).describe('Memory layer'),
   memoryType: MemoryTypeSchema.describe('Memory type'),
   summary: z.string().describe('Concise overview of this specific memory'),
   tags: z.array(z.string()).describe('User defined tags that summarize the context facets'),

package/packages/memory-user-memory/src/schemas/experience.ts

@@ -1,4 +1,3 @@
-import { LayersEnum } from '@lobechat/types';
 import { z } from 'zod';
 
 import { MemoryTypeSchema } from './common';
@@ -37,7 +36,6 @@ export const WithExperienceSchema = z.object({
 export const ExperienceMemoryItemSchema = z.object({
   details: z.string().describe('Optional detailed information'),
   memoryCategory: z.string().describe('Memory category'),
-  memoryLayer: z.literal(LayersEnum.Experience).describe('Memory layer'),
   memoryType: MemoryTypeSchema.describe('Memory type'),
   summary: z.string().describe('Concise overview of this specific memory'),
   tags: z.array(z.string()).describe('Model generated tags that summarize the experience facets'),

package/packages/memory-user-memory/src/schemas/identity.ts

@@ -1,4 +1,4 @@
-import { LayersEnum, MergeStrategyEnum } from '@lobechat/types';
+import { MergeStrategyEnum } from '@lobechat/types';
 import { z } from 'zod';
 
 import { MemoryTypeSchema } from './common';
@@ -43,7 +43,6 @@ export const AddIdentityActionSchema = z
   .object({
     details: z.union([z.string(), z.null()]).describe('Optional detailed information'),
     memoryCategory: z.string().describe('Memory category'),
-    memoryLayer: z.literal(LayersEnum.Identity).describe('Memory layer'),
     memoryType: MemoryTypeSchema.describe('Memory type'),
     summary: z.string().describe('Concise overview of this specific memory'),
     tags: z.array(z.string()).describe('Model generated tags that summarize the identity facets'),

package/packages/memory-user-memory/src/schemas/preference.ts

@@ -1,4 +1,3 @@
-import { LayersEnum } from '@lobechat/types';
 import { z } from 'zod';
 
 import { MemoryTypeSchema } from './common';
@@ -66,7 +65,6 @@ export const WithPreferenceSchema = z.object({
 export const PreferenceMemoryItemSchema = z.object({
   details: z.string().describe('Optional detailed information'),
   memoryCategory: z.string().describe('Memory category'),
-  memoryLayer: z.literal(LayersEnum.Preference).describe('Memory layer'),
   memoryType: MemoryTypeSchema.describe('Memory type'),
   summary: z.string().describe('Concise overview of this specific memory'),
   tags: z.array(z.string()).describe('Model generated tags that summarize the preference facets'),

package/packages/types/src/openai/chat.ts

@@ -86,10 +86,6 @@ export interface ChatStreamPayload {
    * @title Number of texts to return
    */
   n?: number;
-  /**
-   * List of enabled plugins
-   */
-  plugins?: string[];
   /**
    * @title Penalty coefficient in generated text to reduce topic changes
    * @default 0

package/src/app/[variants]/(main)/community/(detail)/user/features/DetailProvider.tsx

@@ -19,7 +19,11 @@ export interface UserDetailContextConfig {
   isOwner: boolean;
   mobile?: boolean;
   onEditProfile?: (onSuccess?: (profile: MarketUserProfile) => void) => void;
-  onStatusChange?: (identifier: string, action: 'publish' | 'unpublish' | 'deprecate') => void;
+  onStatusChange?: (
+    identifier: string,
+    action: 'publish' | 'unpublish' | 'deprecate',
+    type?: 'agent' | 'group',
+  ) => void;
   totalInstalls: number;
   user: DiscoverUserInfo;
 }