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

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 # Changelog
 
+## [Version 2.0.0-next.337](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.336...v2.0.0-next.337)
+
+<sup>Released on **2026-01-22**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix memory schema, update the agentbuilder tools not always use humanIntervention.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix memory schema, closes [#11645](https://github.com/lobehub/lobe-chat/issues/11645) ([3baf780](https://github.com/lobehub/lobe-chat/commit/3baf780))
+- **misc**: Update the agentbuilder tools not always use humanIntervention, closes [#11696](https://github.com/lobehub/lobe-chat/issues/11696) ([0d3017b](https://github.com/lobehub/lobe-chat/commit/0d3017b))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 2.0.0-next.336](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.335...v2.0.0-next.336)
+
+<sup>Released on **2026-01-22**</sup>
+
+#### ✨ Features
+
+- **misc**: Support agent group unpublish agents.
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix tool argument scape and improve multi task run.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Support agent group unpublish agents, closes [#11687](https://github.com/lobehub/lobe-chat/issues/11687) ([4e060be](https://github.com/lobehub/lobe-chat/commit/4e060be))
+
+#### What's fixed
+
+- **misc**: Fix tool argument scape and improve multi task run, closes [#11691](https://github.com/lobehub/lobe-chat/issues/11691) ([b13bb8a](https://github.com/lobehub/lobe-chat/commit/b13bb8a))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.335](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.334...v2.0.0-next.335)
 
 <sup>Released on **2026-01-22**</sup>

package/changelog/v1.json

@@ -1,4 +1,25 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fix memory schema, update the agentbuilder tools not always use humanIntervention."
+      ]
+    },
+    "date": "2026-01-22",
+    "version": "2.0.0-next.337"
+  },
+  {
+    "children": {
+      "features": [
+        "Support agent group unpublish agents."
+      ],
+      "fixes": [
+        "Fix tool argument scape and improve multi task run."
+      ]
+    },
+    "date": "2026-01-22",
+    "version": "2.0.0-next.336"
+  },
   {
     "children": {},
     "date": "2026-01-22",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.335",
+  "version": "2.0.0-next.337",
   "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/builtin-tool-agent-builder/src/manifest.ts

@@ -27,7 +27,6 @@ export const AgentBuilderManifest: BuiltinToolManifest = {
     {
       description:
         'Search for tools (MCP plugins) in the marketplace. Users can browse and install tools directly from the search results. Use this when users want to find new tools or capabilities.',
-      humanIntervention: 'always',
       name: AgentBuilderApiName.searchMarketTools,
       parameters: {
         properties: {
@@ -57,7 +56,6 @@ export const AgentBuilderManifest: BuiltinToolManifest = {
     {
       description:
         'Install a plugin for the agent. This tool ALWAYS REQUIRES user approval before installation, even in auto-run mode. For MCP marketplace plugins, it will install and enable the plugin. For Klavis tools and LobehubSkill providers that need OAuth, it will initiate the connection flow and wait for user to complete authorization.',
-      humanIntervention: 'always',
       name: AgentBuilderApiName.installPlugin,
       parameters: {
         properties: {

package/packages/builtin-tool-group-management/src/manifest.ts

@@ -84,43 +84,44 @@ export const GroupManagementManifest: BuiltinToolManifest = {
     // },
 
     // ==================== Task Execution ====================
-    {
-      description:
-        'Assign an asynchronous task to an agent. The task runs in the background and results are returned to the conversation context upon completion. Ideal for longer operations.',
-      name: GroupManagementApiName.executeAgentTask,
-      humanIntervention: 'required',
-      parameters: {
-        properties: {
-          agentId: {
-            description: 'The ID of the agent to execute the task.',
-            type: 'string',
-          },
-          title: {
-            description: 'Brief title describing what this task does (shown in UI).',
-            type: 'string',
-          },
-          task: {
-            description:
-              'Clear description of the task to perform. Be specific about expected deliverables.',
-            type: 'string',
-          },
-          timeout: {
-            default: 1_800_000,
-            description:
-              'Maximum time in milliseconds to wait for task completion (default: 1800000, 30 minutes).',
-            type: 'number',
-          },
-          skipCallSupervisor: {
-            default: false,
-            description:
-              'If true, the orchestration will end after the task completes, without calling the supervisor again. Use this when the task is the final action needed.',
-            type: 'boolean',
-          },
-        },
-        required: ['agentId', 'title', 'task'],
-        type: 'object',
-      },
-    },
+    // TODO: Enable executeAgentTask when ready
+    // {
+    //   description:
+    //     'Assign an asynchronous task to an agent. The task runs in the background and results are returned to the conversation context upon completion. Ideal for longer operations.',
+    //   name: GroupManagementApiName.executeAgentTask,
+    //   humanIntervention: 'required',
+    //   parameters: {
+    //     properties: {
+    //       agentId: {
+    //         description: 'The ID of the agent to execute the task.',
+    //         type: 'string',
+    //       },
+    //       title: {
+    //         description: 'Brief title describing what this task does (shown in UI).',
+    //         type: 'string',
+    //       },
+    //       task: {
+    //         description:
+    //           'Clear description of the task to perform. Be specific about expected deliverables.',
+    //         type: 'string',
+    //       },
+    //       timeout: {
+    //         default: 1_800_000,
+    //         description:
+    //           'Maximum time in milliseconds to wait for task completion (default: 1800000, 30 minutes).',
+    //         type: 'number',
+    //       },
+    //       skipCallSupervisor: {
+    //         default: false,
+    //         description:
+    //           'If true, the orchestration will end after the task completes, without calling the supervisor again. Use this when the task is the final action needed.',
+    //         type: 'boolean',
+    //       },
+    //     },
+    //     required: ['agentId', 'title', 'task'],
+    //     type: 'object',
+    //   },
+    // },
     // TODO: Enable executeAgentTasks when ready
     // {
     //   description:
@@ -168,22 +169,22 @@ export const GroupManagementManifest: BuiltinToolManifest = {
     //     type: 'object',
     //   },
     // },
-    {
-      description:
-        'Interrupt a running agent task. Use this to stop a task that is taking too long or is no longer needed.',
-      humanIntervention: 'always',
-      name: GroupManagementApiName.interrupt,
-      parameters: {
-        properties: {
-          taskId: {
-            description: 'The ID of the task to interrupt (returned by executeTask).',
-            type: 'string',
-          },
-        },
-        required: ['taskId'],
-        type: 'object',
-      },
-    },
+    // {
+    //   description:
+    //     'Interrupt a running agent task. Use this to stop a task that is taking too long or is no longer needed.',
+    //   humanIntervention: 'always',
+    //   name: GroupManagementApiName.interrupt,
+    //   parameters: {
+    //     properties: {
+    //       taskId: {
+    //         description: 'The ID of the task to interrupt (returned by executeTask).',
+    //         type: 'string',
+    //       },
+    //     },
+    //     required: ['taskId'],
+    //     type: 'object',
+    //   },
+    // },
 
     // ==================== Context Management ====================
     // {

package/packages/builtin-tool-group-management/src/systemRole.ts

@@ -7,45 +7,38 @@
 export const systemPrompt = `You are a Group Supervisor with tools to orchestrate multi-agent collaboration. Your primary responsibility is to coordinate agents effectively by choosing the right mode of interaction.
 
 <core_decision_framework>
-## The Critical Choice: Speaking vs Task Execution
+## Communication Mode Selection
 
-Before involving any agent, you MUST determine which mode is appropriate:
+Before involving any agent, determine the best communication approach:
 
-### 🗣️ Speaking Mode (speak/broadcast)
-**Use when agents DON'T need to use tools** - agents share the group's conversation context.
+### 🗣️ Single Agent (speak)
+**Use when one agent's expertise is sufficient** - the agent shares the group's conversation context.
 
 Characteristics:
 - Agent responds based on their expertise and knowledge
 - Agent sees the group conversation history
 - Response is immediate and synchronous
-- No tool/plugin invocation needed
-- Lightweight, quick interactions
+- Focused, single-perspective response
 
 Best for:
-- Sharing opinions, perspectives, or advice
-- Answering questions from knowledge
-- Brainstorming and ideation
-- Reviewing/critiquing content presented in conversation
-- Quick consultations
-- Discussion and debate
+- Follow-up questions to a specific agent
+- Tasks clearly matching one agent's expertise
+- When user explicitly requests a specific agent
 
-### ⚡ Task Execution Mode (executeAgentTask)
-**Use when agents NEED to use tools** - each agent gets an independent context window to complete their task autonomously.
+### 📢 Multiple Agents (broadcast)
+**Use when diverse perspectives are valuable** - all agents share the group's conversation context.
 
 Characteristics:
-- Agent operates in isolated context (fresh conversation)
-- Agent CAN use their configured tools/plugins (web search, code execution, file operations, etc.)
-- Asynchronous execution - multiple agents can work in parallel
-- Each agent completes their task independently
-- Results are returned to the group when done
+- Multiple agents respond in parallel
+- All agents see the same conversation history
+- Quick gathering of multiple viewpoints
 
 Best for:
-- Web research and information gathering
-- Code writing, analysis, or execution
-- File processing or generation
-- API calls or external service interactions
-- Complex multi-step tasks requiring tool usage
-- Any task where the agent needs to "do something" not just "say something"
+- Sharing opinions, perspectives, or advice
+- Answering questions from knowledge
+- Brainstorming and ideation
+- Reviewing/critiquing content presented in conversation
+- Discussion and debate
 
 ## Decision Flowchart
 
@@ -53,36 +46,23 @@ Best for:
 User Request
      │
      ▼
-Does the task require agents to USE TOOLS?
-(search web, write code, call APIs, process files, etc.)
+Does the task need multiple perspectives?
      │
-     ├─── YES ──→ executeAgentTask (independent context per agent)
+     ├─── YES ──→ broadcast (parallel speaking)
      │
-     └─── NO ───→ Does the task need multiple perspectives?
-                       │
-                       ├─── YES ──→ broadcast (parallel speaking)
-                       │
-                       └─── NO ───→ speak (single agent)
+     └─── NO ───→ speak (single agent)
 \`\`\`
 </core_decision_framework>
 
 <user_intent_analysis>
 Before responding, analyze the user's intent:
 
-**Signals for Task Execution (executeAgentTask):**
-- "Search for...", "Find information about...", "Research..."
-- "Write code to...", "Create a script that...", "Implement..."
-- "Analyze this file...", "Process this data..."
-- "Generate a report...", "Create documentation..."
-- Tasks that clearly require external tools or multi-step operations
-- When multiple agents need to work on different parts independently
-
-**Signals for Speaking (speak/broadcast):**
+**Signals for Multiple Agents (broadcast):**
 - "What do you think about...", "Any ideas for...", "How should we..."
 - "Review this...", "Give me feedback on...", "Critique..."
 - "Explain...", "Compare...", "Summarize..."
 - Requests for opinions, perspectives, or expertise-based answers
-- Questions that can be answered from knowledge alone
+- Questions that benefit from diverse viewpoints
 
 **Signals for Single Agent (speak):**
 - Explicit request: "Ask [Agent Name] to...", "Let [Agent Name] answer..."
@@ -90,7 +70,6 @@ Before responding, analyze the user's intent:
 - Task clearly matches only one agent's expertise
 
 **Default Behavior:**
-- When in doubt about tool usage → Ask yourself: "Can this be answered with knowledge alone, or does it require the agent to DO something?"
 - When in doubt about single vs multiple agents → Lean towards broadcast for diverse perspectives
 </user_intent_analysis>
 
@@ -150,115 +129,68 @@ When a user's request is broad or unclear, ask 1-2 focused questions to understa
 <core_capabilities>
 ## Tool Categories
 
-**Speaking (Shared Context, No Tools):**
+**Communication:**
 - **speak**: Single agent responds synchronously in group context
 - **broadcast**: Multiple agents respond in parallel in group context
 
-**Task Execution (Independent Context, With Tools):**
-- **executeAgentTask**: Assign a task to one agent in isolated context
-- **interrupt**: Stop a running task
-
 **Flow Control:**
-- **summarize**: Compress conversation context
 - **vote**: Initiate voting among agents
 </core_capabilities>
 
 <workflow_patterns>
 ## Pattern Selection Guide
 
-### Pattern 1: Discussion/Consultation (Speaking)
-When you need opinions, feedback, or knowledge-based responses.
+### Pattern 1: Discussion/Consultation (Broadcast)
+When you need opinions, feedback, or knowledge-based responses from multiple agents.
 
 \`\`\`
 User: "What do you think about using microservices for this project?"
-Analysis: Opinion-based, no tools needed
+Analysis: Opinion-based, benefits from diverse perspectives
 Action: broadcast to [Architect, DevOps, Backend] - share perspectives
 \`\`\`
 
-### Pattern 2: Independent Research (Task)
-When an agent needs to research/work independently using their tools.
-
-\`\`\`
-User: "Research the pros and cons of React"
-Analysis: Requires web search, agent works independently
-Action: executeAgentTask to frontend expert
-executeAgentTask({
-  agentId: "frontend-expert",
-  title: "Research React",
-  task: "Research React ecosystem, performance benchmarks, community size, and typical use cases. Provide pros and cons."
-})
-\`\`\`
-
-### Pattern 3: Sequential Discussion (Speaking Chain)
+### Pattern 2: Sequential Discussion (Speaking Chain)
 When each response should build on previous ones.
 
 \`\`\`
 User: "Design a notification system architecture"
-Analysis: Build-upon discussion, no tools needed per step
+Analysis: Build-upon discussion, each agent adds to previous response
 Action:
 1. speak to Architect: "Propose high-level architecture"
 2. speak to Backend: "Evaluate and add implementation details"
 3. speak to DevOps: "Add deployment and scaling considerations"
 \`\`\`
 
-### Pattern 4: Research then Discuss (Hybrid)
-When you need facts first, then discussion.
+### Pattern 3: Focused Consultation (Speak)
+When a specific agent's expertise is needed.
 
 \`\`\`
-User: "Should we migrate to Kubernetes? Research and discuss."
-Analysis: First gather facts (tools), then discuss (no tools)
-Action:
-1. executeAgentTask({
-     agentId: "devops",
-     title: "K8s Adoption Research",
-     task: "Research Kubernetes adoption best practices for our scale. Include migration complexity, resource requirements, operational overhead, and security considerations."
-   })
-2. [Wait for results]
-3. broadcast: "Based on the research, share your recommendations"
-\`\`\`
-
-### Pattern 5: Implementation Task
-When an agent needs to create deliverables using their tools.
-
-\`\`\`
-User: "Write the landing page copy"
-Analysis: Agent produces artifacts using their tools
-Action: executeAgentTask({
-  agentId: "copywriter",
-  title: "Write Copy",
-  task: "Write compelling landing page copy for [product]. Include headline, subheadline, feature descriptions, and CTA text."
-})
+User: "Ask the frontend expert about React performance"
+Analysis: User explicitly requested specific agent
+Action: speak to frontend expert with the question
 \`\`\`
 </workflow_patterns>
 
 <tool_usage_guidelines>
-**Speaking:**
+**Communication:**
 - speak: \`agentId\`, \`instruction\` (optional guidance)
 - broadcast: \`agentIds\` (array), \`instruction\` (optional shared guidance)
 
-**Task Execution:**
-- executeAgentTask: \`agentId\`, \`title\`, \`task\` (clear deliverable description), \`timeout\` (optional, default 30min)
-- interrupt: \`taskId\`
-
 **Flow Control:**
-- summarize: \`focus\` (optional), \`preserveRecent\` (messages to keep, default 5)
 - vote: \`question\`, \`options\` (array of {id, label, description}), \`voterAgentIds\` (optional), \`requireReasoning\` (default true)
 </tool_usage_guidelines>
 
 <best_practices>
-1. **Don't over-engineer**: Simple questions → speak; Complex tasks requiring tools → executeAgentTask
-3. **Parallel when possible**: Use broadcast for opinions, parallel executeAgentTask for independent work
-4. **Sequential when dependent**: Use speak chain when each response builds on previous
-5. **Be explicit with task instructions**: For executeAgentTask, clearly describe expected deliverables
-6. **Monitor long tasks**: Use interrupt if tasks run too long or go off-track
-7. **Summarize proactively**: Compress context before it grows too large
-8. **Explain your choices**: Tell users why you chose speaking vs task execution
+1. **Keep it simple**: Use speak for single agent, broadcast for multiple perspectives
+2. **Parallel when possible**: Use broadcast to gather diverse viewpoints quickly
+3. **Sequential when dependent**: Use speak chain when each response builds on previous
+4. **Be clear with instructions**: Provide context to help agents give better responses
+5. **Explain your choices**: Tell users why you chose speak vs broadcast
 </best_practices>
 
 <response_format>
 When orchestrating:
-1. Briefly explain your mode choice: "This requires [speaking/task execution] because..."
-2. For tasks, clearly state what each agent will do
-3. After completion, synthesize results and provide actionable conclusions
-4. Reference agents clearly: "Agent [Name] suggests..." or "Task [taskId] completed with..."
+1. Briefly explain your mode choice: "I'll ask [agent] because..." or "I'll gather perspectives from multiple agents because..."
+2. After agents respond, synthesize results and provide actionable conclusions
+3. Reference agents clearly: "Agent [Name] suggests..."
 </response_format>`;

package/packages/builtin-tool-memory/src/client/Render/AddPreferenceMemory/index.tsx

@@ -0,0 +1,17 @@
+'use client';
+
+import type { BuiltinRenderProps } from '@lobechat/types';
+import { memo } from 'react';
+
+import type { AddPreferenceMemoryParams, AddPreferenceMemoryState } from '../../../types';
+import { PreferenceMemoryCard } from '../../components';
+
+const AddPreferenceMemoryRender = memo<
+  BuiltinRenderProps<AddPreferenceMemoryParams, AddPreferenceMemoryState>
+>(({ args }) => {
+  return <PreferenceMemoryCard data={args} />;
+});
+
+AddPreferenceMemoryRender.displayName = 'AddPreferenceMemoryRender';
+
+export default AddPreferenceMemoryRender;

package/packages/builtin-tool-memory/src/client/Render/index.ts

@@ -2,6 +2,7 @@ import type { BuiltinRender } from '@lobechat/types';
 
 import { MemoryApiName } from '../../types';
 import AddExperienceMemoryRender from './AddExperienceMemory';
+import AddPreferenceMemoryRender from './AddPreferenceMemory';
 import SearchUserMemoryRender from './SearchUserMemory';
 
 /**
@@ -11,5 +12,6 @@ import SearchUserMemoryRender from './SearchUserMemory';
  */
 export const MemoryRenders: Record<string, BuiltinRender> = {
   [MemoryApiName.addExperienceMemory]: AddExperienceMemoryRender as BuiltinRender,
+  [MemoryApiName.addPreferenceMemory]: AddPreferenceMemoryRender as BuiltinRender,
   [MemoryApiName.searchUserMemory]: SearchUserMemoryRender as BuiltinRender,
 };

package/packages/builtin-tool-memory/src/client/Streaming/AddPreferenceMemory/index.tsx

@@ -0,0 +1,17 @@
+'use client';
+
+import type { BuiltinStreamingProps } from '@lobechat/types';
+import { memo } from 'react';
+
+import type { AddPreferenceMemoryParams } from '../../../types';
+import { PreferenceMemoryCard } from '../../components';
+
+export const AddPreferenceMemoryStreaming = memo<BuiltinStreamingProps<AddPreferenceMemoryParams>>(
+  ({ args }) => {
+    return <PreferenceMemoryCard data={args} loading />;
+  },
+);
+
+AddPreferenceMemoryStreaming.displayName = 'AddPreferenceMemoryStreaming';
+
+export default AddPreferenceMemoryStreaming;

package/packages/builtin-tool-memory/src/client/Streaming/index.ts

@@ -2,6 +2,7 @@ import { type BuiltinStreaming } from '@lobechat/types';
 
 import { MemoryApiName } from '../../types';
 import { AddExperienceMemoryStreaming } from './AddExperienceMemory';
+import { AddPreferenceMemoryStreaming } from './AddPreferenceMemory';
 
 /**
  * Memory Streaming Components Registry
@@ -11,8 +12,8 @@ import { AddExperienceMemoryStreaming } from './AddExperienceMemory';
  */
 export const MemoryStreamings: Record<string, BuiltinStreaming> = {
   [MemoryApiName.addExperienceMemory]: AddExperienceMemoryStreaming as BuiltinStreaming,
+  [MemoryApiName.addPreferenceMemory]: AddPreferenceMemoryStreaming as BuiltinStreaming,
 };
 
-
-
-export {AddExperienceMemoryStreaming} from './AddExperienceMemory';
+export { AddExperienceMemoryStreaming } from './AddExperienceMemory';
+export { AddPreferenceMemoryStreaming } from './AddPreferenceMemory';