@lobehub/lobehub 2.0.0-next.334 → 2.0.0-next.336

package/src/services/chat/index.ts

@@ -27,7 +27,7 @@ import { ModelProvider } from 'model-bank';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { enableAuth } from '@/envs/auth';
 import { getSearchConfig } from '@/helpers/getSearchConfig';
-import { createAgentToolsEngine, createToolsEngine } from '@/helpers/toolEngineering';
+import { createAgentToolsEngine } from '@/helpers/toolEngineering';
 import { getAgentStoreState } from '@/store/agent';
 import {
   agentByIdSelectors,
@@ -58,10 +58,10 @@ import { createHeaderWithAuth } from '../_auth';
 import { API_ENDPOINTS } from '../_url';
 import { findDeploymentName, isEnableFetchOnClient, resolveRuntimeProvider } from './helper';
 import {
+  type ResolvedAgentConfig,
   contextEngineering,
   getTargetAgentId,
   initializeWithClientStore,
-  resolveAgentConfig,
   resolveModelExtendParams,
 } from './mecha';
 import { type FetchOptions } from './types';
@@ -70,6 +70,11 @@ interface GetChatCompletionPayload extends Partial<Omit<ChatStreamPayload, 'mess
   agentId?: string;
   groupId?: string;
   messages: UIChatMessage[];
+  /**
+   * Pre-resolved agent config from AgentRuntime layer.
+   * Required to ensure config consistency and proper isSubTask filtering.
+   */
+  resolvedAgentConfig: ResolvedAgentConfig;
   scope?: MessageMapScope;
   topicId?: string;
 }
@@ -107,12 +112,11 @@ interface CreateAssistantMessageStream extends FetchSSEOptions {
 class ChatService {
   createAssistantMessage = async (
     {
-      plugins: enabledPlugins,
       messages,
       agentId,
       groupId,
-      scope,
       topicId,
+      resolvedAgentConfig,
       ...params
     }: GetChatCompletionPayload,
     options?: FetchOptions,
@@ -126,24 +130,13 @@ class ChatService {
       params,
     );
 
-    // =================== 1. resolve agent config =================== //
+    // =================== 1. use pre-resolved agent config =================== //
+    // Config is resolved in AgentRuntime layer (internal_createAgentState)
+    // which handles isSubTask filtering and other runtime modifications
 
     const targetAgentId = getTargetAgentId(agentId);
 
-    // Resolve agent config with builtin agent runtime config merged
-    // plugins is already merged (runtime plugins > agent config plugins)
-    const {
-      agentConfig,
-      chatConfig,
-      plugins: pluginIds,
-    } = resolveAgentConfig({
-      agentId: targetAgentId,
-      groupId, // Pass groupId for supervisor detection
-      model: payload.model,
-      plugins: enabledPlugins,
-      provider: payload.provider,
-      scope, // Pass scope to preserve page-agent injection
-    });
+    const { agentConfig, chatConfig, plugins: pluginIds } = resolvedAgentConfig;
 
     // Get search config with agentId for agent-specific settings
     const searchConfig = getSearchConfig(payload.model, payload.provider!, targetAgentId);
@@ -495,26 +488,14 @@ class ChatService {
     onLoadingChange?.(true);
 
     try {
-      // Use simple tools engine without complex search logic
-      const toolsEngine = createToolsEngine();
-      const { tools, enabledManifests } = toolsEngine.generateToolsDetailed({
-        model: params.model!,
-        provider: params.provider!,
-        toolIds: params.plugins,
-      });
-
       const llmMessages = await contextEngineering({
-        manifests: enabledManifests,
         messages: params.messages as any,
         model: params.model!,
         provider: params.provider!,
-        tools: params.plugins,
       });
 
-      // remove plugins
-      delete params.plugins;
       await this.getChatCompletion(
-        { ...params, messages: llmMessages, tools },
+        { ...params, messages: llmMessages },
         {
           onErrorHandle: (error) => {
             errorHandle(new Error(error.message), error);

package/src/services/chat/mecha/agentConfigResolver.test.ts

@@ -800,4 +800,117 @@ describe('resolveAgentConfig', () => {
       expect(result.agentConfig.systemRole).toBe('Supervisor system role');
     });
   });
+
+  describe('sub-task filtering (isSubTask)', () => {
+    beforeEach(() => {
+      vi.spyOn(agentSelectors.agentSelectors, 'getAgentSlugById').mockReturnValue(() => undefined);
+    });
+
+    it('should filter out lobe-gtd when isSubTask is true for regular agent', () => {
+      vi.spyOn(agentSelectors.agentSelectors, 'getAgentConfigById').mockReturnValue(
+        () =>
+          ({
+            ...mockAgentConfig,
+            plugins: ['lobe-gtd', 'plugin-a', 'plugin-b'],
+          }) as any,
+      );
+
+      const result = resolveAgentConfig({
+        agentId: 'test-agent',
+        isSubTask: true,
+      });
+
+      expect(result.plugins).not.toContain('lobe-gtd');
+      expect(result.plugins).toEqual(['plugin-a', 'plugin-b']);
+    });
+
+    it('should keep lobe-gtd when isSubTask is false', () => {
+      vi.spyOn(agentSelectors.agentSelectors, 'getAgentConfigById').mockReturnValue(
+        () =>
+          ({
+            ...mockAgentConfig,
+            plugins: ['lobe-gtd', 'plugin-a', 'plugin-b'],
+          }) as any,
+      );
+
+      const result = resolveAgentConfig({
+        agentId: 'test-agent',
+        isSubTask: false,
+      });
+
+      expect(result.plugins).toContain('lobe-gtd');
+      expect(result.plugins).toEqual(['lobe-gtd', 'plugin-a', 'plugin-b']);
+    });
+
+    it('should keep lobe-gtd when isSubTask is undefined', () => {
+      vi.spyOn(agentSelectors.agentSelectors, 'getAgentConfigById').mockReturnValue(
+        () =>
+          ({
+            ...mockAgentConfig,
+            plugins: ['lobe-gtd', 'plugin-a'],
+          }) as any,
+      );
+
+      const result = resolveAgentConfig({ agentId: 'test-agent' });
+
+      expect(result.plugins).toContain('lobe-gtd');
+    });
+
+    it('should filter lobe-gtd in page scope when isSubTask is true', () => {
+      vi.spyOn(agentSelectors.agentSelectors, 'getAgentConfigById').mockReturnValue(
+        () =>
+          ({
+            ...mockAgentConfig,
+            plugins: ['lobe-gtd', 'plugin-a'],
+          }) as any,
+      );
+      vi.spyOn(builtinAgents, 'getAgentRuntimeConfig').mockReturnValue({
+        systemRole: 'Page agent system role',
+      });
+
+      const result = resolveAgentConfig({
+        agentId: 'test-agent',
+        scope: 'page',
+        isSubTask: true,
+      });
+
+      expect(result.plugins).not.toContain('lobe-gtd');
+      expect(result.plugins).toContain(PageAgentIdentifier);
+    });
+
+    it('should filter lobe-gtd for builtin agent when isSubTask is true', () => {
+      vi.spyOn(agentSelectors.agentSelectors, 'getAgentSlugById').mockReturnValue(
+        () => 'some-builtin-slug',
+      );
+      vi.spyOn(builtinAgents, 'getAgentRuntimeConfig').mockReturnValue({
+        plugins: ['lobe-gtd', 'runtime-plugin'],
+        systemRole: 'Runtime system role',
+      });
+
+      const result = resolveAgentConfig({
+        agentId: 'builtin-agent',
+        isSubTask: true,
+      });
+
+      expect(result.plugins).not.toContain('lobe-gtd');
+      expect(result.plugins).toContain('runtime-plugin');
+    });
+
+    it('should keep lobe-gtd for builtin agent when isSubTask is false', () => {
+      vi.spyOn(agentSelectors.agentSelectors, 'getAgentSlugById').mockReturnValue(
+        () => 'some-builtin-slug',
+      );
+      vi.spyOn(builtinAgents, 'getAgentRuntimeConfig').mockReturnValue({
+        plugins: ['lobe-gtd', 'runtime-plugin'],
+        systemRole: 'Runtime system role',
+      });
+
+      const result = resolveAgentConfig({
+        agentId: 'builtin-agent',
+        isSubTask: false,
+      });
+
+      expect(result.plugins).toContain('lobe-gtd');
+    });
+  });
 });

package/src/services/chat/mecha/agentConfigResolver.ts

@@ -61,6 +61,12 @@ export interface AgentConfigResolverContext {
    */
   groupId?: string;
 
+  /**
+   * Whether this is a sub-task execution.
+   * When true, filters out lobe-gtd tools to prevent nested sub-task creation.
+   */
+  isSubTask?: boolean;
+
   /** Current model being used (for template variables) */
   model?: string;
   /** Plugins enabled for the agent */
@@ -106,9 +112,13 @@ export interface ResolvedAgentConfig {
  * For regular agents, this simply returns the config from the store.
  */
 export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAgentConfig => {
-  const { agentId, model, documentContent, plugins, targetAgentConfig } = ctx;
+  const { agentId, model, documentContent, plugins, targetAgentConfig, isSubTask } = ctx;
+
+  log('resolveAgentConfig called with agentId: %s, scope: %s, isSubTask: %s', agentId, ctx.scope, isSubTask);
 
-  log('resolveAgentConfig called with agentId: %s, scope: %s', agentId, ctx.scope);
+  // Helper to filter out lobe-gtd in sub-task context to prevent nested sub-task creation
+  const applySubTaskFilter = (pluginIds: string[]) =>
+    isSubTask ? pluginIds.filter((id) => id !== 'lobe-gtd') : pluginIds;
 
   const agentStoreState = getAgentStoreState();
 
@@ -199,7 +209,7 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
         agentConfig: finalAgentConfig,
         chatConfig: finalChatConfig,
         isBuiltinAgent: false,
-        plugins: pageAgentPlugins,
+        plugins: applySubTaskFilter(pageAgentPlugins),
       };
     }
 
@@ -208,7 +218,7 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
       agentConfig: finalAgentConfig,
       chatConfig: finalChatConfig,
       isBuiltinAgent: false,
-      plugins: finalPlugins,
+      plugins: applySubTaskFilter(finalPlugins),
     };
   }
 
@@ -329,7 +339,7 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
     agentConfig: finalAgentConfig,
     chatConfig: resolvedChatConfig,
     isBuiltinAgent: true,
-    plugins: finalPlugins,
+    plugins: applySubTaskFilter(finalPlugins),
     slug,
   };
 };

package/src/services/marketApi.ts

@@ -146,6 +146,20 @@ export class MarketApiService {
     return lambdaClient.market.agent.getAgentForkSource.query({ identifier });
   }
 
+  // ==================== Agent Group Status Management ====================
+
+  async publishAgentGroup(identifier: string): Promise<void> {
+    await lambdaClient.market.agentGroup.publishAgentGroup.mutate({ identifier });
+  }
+
+  async unpublishAgentGroup(identifier: string): Promise<void> {
+    await lambdaClient.market.agentGroup.unpublishAgentGroup.mutate({ identifier });
+  }
+
+  async deprecateAgentGroup(identifier: string): Promise<void> {
+    await lambdaClient.market.agentGroup.deprecateAgentGroup.mutate({ identifier });
+  }
+
   // ==================== Fork Agent Group API ====================
 
   /**

package/src/store/chat/agents/__tests__/createAgentExecutors/helpers/testExecutor.ts

@@ -1,9 +1,21 @@
 import type { AgentInstruction, AgentState } from '@lobechat/agent-runtime';
 
+import { DEFAULT_AGENT_CHAT_CONFIG, DEFAULT_AGENT_CONFIG } from '@/const/settings';
+import type { ResolvedAgentConfig } from '@/services/chat/mecha';
 import { createAgentExecutors } from '@/store/chat/agents/createAgentExecutors';
 import type { OperationType } from '@/store/chat/slices/operation/types';
 import type { ChatStore } from '@/store/chat/store';
 
+/**
+ * Create a mock ResolvedAgentConfig for testing
+ */
+const createMockResolvedAgentConfig = (): ResolvedAgentConfig => ({
+  agentConfig: { ...DEFAULT_AGENT_CONFIG },
+  chatConfig: { ...DEFAULT_AGENT_CHAT_CONFIG },
+  isBuiltinAgent: false,
+  plugins: [],
+});
+
 /**
  * Execute an executor with mock context
  *
@@ -60,6 +72,7 @@ export const executeWithMockContext = async ({
 
   // Create executors with mock context
   const executors = createAgentExecutors({
+    agentConfig: createMockResolvedAgentConfig(),
     get: () => mockStore,
     messageKey: context.messageKey,
     operationId: context.operationId,

package/src/store/chat/agents/createAgentExecutors.ts

@@ -22,6 +22,8 @@ import type { ChatToolPayload, ConversationContext, CreateMessageParams } from '
 import debug from 'debug';
 import pMap from 'p-map';
 
+import type { ResolvedAgentConfig } from '@/services/chat/mecha';
+
 import { LOADING_FLAT } from '@/const/message';
 import { aiAgentService } from '@/services/aiAgent';
 import { agentByIdSelectors } from '@/store/agent/selectors';
@@ -49,6 +51,8 @@ const TOOL_PRICING: Record<string, number> = {
  * @param context.skipCreateFirstMessage - Skip first message creation
  */
 export const createAgentExecutors = (context: {
+  /** Pre-resolved agent config with isSubTask filtering applied */
+  agentConfig: ResolvedAgentConfig;
   get: () => ChatStore;
   messageKey: string;
   operationId: string;
@@ -169,6 +173,7 @@ export const createAgentExecutors = (context: {
         model: llmPayload.model,
         provider: llmPayload.provider,
         operationId: context.operationId,
+        agentConfig: context.agentConfig, // Pass pre-resolved config
         // Pass runtime context for page editor injection
         initialContext: runtimeContext?.initialContext,
         stepContext: runtimeContext?.stepContext,
@@ -1735,7 +1740,12 @@ export const createAgentExecutors = (context: {
         const { threadId, userMessageId, threadMessages, messages } = threadResult;
 
         // 3. Build sub-task ConversationContext (uses threadId for isolation)
-        const subContext: ConversationContext = { agentId, topicId, threadId, scope: 'thread' };
+        const subContext: ConversationContext = {
+          agentId,
+          topicId,
+          threadId,
+          scope: 'thread',
+        };
 
         // 4. Create a child operation for task execution (now with threadId)
         const { operationId: taskOperationId } = context.get().startOperation({
@@ -1784,6 +1794,7 @@ export const createAgentExecutors = (context: {
           parentMessageType: 'user',
           operationId: taskOperationId,
           parentOperationId: state.operationId,
+          isSubTask: true, // Disable lobe-gtd tools to prevent nested sub-tasks
         });
 
         log('[%s][exec_client_task] Client-side AgentRuntime execution completed', taskLogId);
@@ -2107,6 +2118,7 @@ export const createAgentExecutors = (context: {
               parentMessageType: 'user',
               operationId: taskOperationId,
               parentOperationId: state.operationId,
+              isSubTask: true, // Disable lobe-gtd tools to prevent nested sub-tasks
             });
 
             log('[%s] Client-side AgentRuntime execution completed', taskLogId);

package/src/store/chat/slices/aiChat/actions/__tests__/conversationControl.test.ts

@@ -4,7 +4,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { useChatStore } from '../../../../store';
 import { messageMapKey } from '../../../../utils/messageMapKey';
-import { TEST_IDS, createMockMessage } from './fixtures';
+import { TEST_IDS, createMockMessage, createMockResolvedAgentConfig } from './fixtures';
 import { resetTestEnvironment } from './helpers';
 
 // Keep zustand mock as it's needed globally
@@ -425,6 +425,7 @@ describe('ConversationControl actions', () => {
         .mockReturnValue({
           state: {} as any,
           context: { phase: 'init' } as any,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       const internal_execAgentRuntimeSpy = vi
         .spyOn(result.current, 'internal_execAgentRuntime')
@@ -497,6 +498,7 @@ describe('ConversationControl actions', () => {
         .mockReturnValue({
           state: {} as any,
           context: { phase: 'init' } as any,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       const internal_execAgentRuntimeSpy = vi
         .spyOn(result.current, 'internal_execAgentRuntime')
@@ -596,6 +598,7 @@ describe('ConversationControl actions', () => {
         .mockReturnValue({
           state: {} as any,
           context: { phase: 'init' } as any,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       const internal_execAgentRuntimeSpy = vi
         .spyOn(result.current, 'internal_execAgentRuntime')
@@ -669,6 +672,7 @@ describe('ConversationControl actions', () => {
         .mockReturnValue({
           state: {} as any,
           context: { phase: 'init' } as any,
+          agentConfig: createMockResolvedAgentConfig(),
         });
       const internal_execAgentRuntimeSpy = vi
         .spyOn(result.current, 'internal_execAgentRuntime')

package/src/store/chat/slices/aiChat/actions/__tests__/fixtures.ts

@@ -1,6 +1,7 @@
 import { type UIChatMessage } from '@lobechat/types';
 
 import { DEFAULT_AGENT_CHAT_CONFIG, DEFAULT_AGENT_CONFIG } from '@/const/settings';
+import type { ResolvedAgentConfig } from '@/services/chat/mecha';
 
 // Test Constants
 export const TEST_IDS = {
@@ -63,3 +64,16 @@ export const createMockStoreState = (overrides = {}) => ({
   toolCallingStreamIds: {},
   ...overrides,
 });
+
+/**
+ * Create a mock ResolvedAgentConfig for testing
+ */
+export const createMockResolvedAgentConfig = (
+  overrides: Partial<ResolvedAgentConfig> = {},
+): ResolvedAgentConfig => ({
+  agentConfig: createMockAgentConfig(),
+  chatConfig: createMockChatConfig(),
+  isBuiltinAgent: false,
+  plugins: [],
+  ...overrides,
+});