@lobehub/lobehub 2.0.0-next.308 → 2.0.0-next.309

package/packages/types/src/userMemory/layers.ts

@@ -10,19 +10,33 @@ export enum UserMemoryContextObjectType {
   Knowledge = 'knowledge',
   Other = 'other',
   Person = 'person',
-  Place = 'place'
+  Place = 'place',
 }
+export const CONTEXT_OBJECT_TYPES = Object.values(UserMemoryContextObjectType);
 
 export enum UserMemoryContextSubjectType {
   Item = 'item',
   Other = 'other',
   Person = 'person',
-  Pet = 'pet'
+  Pet = 'pet',
 }
+export const CONTEXT_SUBJECT_TYPES = Object.values(UserMemoryContextSubjectType);
 
 export interface UserMemoryContext extends UserMemoryTimestamps {
-  associatedObjects: { extra?: Record<string, unknown> | null, name?: string, type?: UserMemoryContextObjectType }[] | null;
-  associatedSubjects: { extra?: Record<string, unknown> | null, name?: string, type?: UserMemoryContextSubjectType }[] | null;
+  associatedObjects:
+    | {
+        extra?: Record<string, unknown> | null;
+        name?: string;
+        type?: UserMemoryContextObjectType;
+      }[]
+    | null;
+  associatedSubjects:
+    | {
+        extra?: Record<string, unknown> | null;
+        name?: string;
+        type?: UserMemoryContextSubjectType;
+      }[]
+    | null;
   currentStatus: string | null;
   description: string | null;
   descriptionVector: number[] | null;
@@ -97,7 +111,4 @@ export type UserMemoryPreferenceWithoutVectors = Omit<
   'conclusionDirectivesVector'
 >;
 
-export type UserMemoryPreferencesListItem = Omit<
-  UserMemoryPreferenceWithoutVectors,
-  'suggestions'
->;
+export type UserMemoryPreferencesListItem = Omit<UserMemoryPreferenceWithoutVectors, 'suggestions'>;

package/packages/types/src/userMemory/shared.ts

@@ -30,17 +30,20 @@ export enum RelationshipEnum {
   Uncle = 'uncle',
   Wife = 'wife',
 }
+export const RELATIONSHIPS = Object.values(RelationshipEnum);
 
 export enum MergeStrategyEnum {
   Merge = 'merge',
   Replace = 'replace',
 }
+export const MERGE_STRATEGIES = Object.values(MergeStrategyEnum);
 
 export enum IdentityTypeEnum {
   Demographic = 'demographic',
   Personal = 'personal',
   Professional = 'professional',
 }
+export const IDENTITY_TYPES = Object.values(IdentityTypeEnum);
 
 export enum LayersEnum {
   Context = 'context',
@@ -48,6 +51,7 @@ export enum LayersEnum {
   Identity = 'identity',
   Preference = 'preference',
 }
+export const MEMORY_LAYERS = Object.values(LayersEnum);
 
 export enum TypesEnum {
   Activity = 'activity',
@@ -61,6 +65,7 @@ export enum TypesEnum {
   Technology = 'technology',
   Topic = 'topic',
 }
+export const MEMORY_TYPES = Object.values(TypesEnum);
 
 export enum ContextStatusEnum {
   Aborted = 'aborted',
@@ -68,5 +73,6 @@ export enum ContextStatusEnum {
   Completed = 'completed',
   OnHold = 'on_hold',
   Ongoing = 'ongoing',
-  Planned = 'planned'
+  Planned = 'planned',
 }
+export const CONTEXT_STATUS = Object.values(ContextStatusEnum);

package/src/locales/default/plugin.ts

@@ -40,6 +40,7 @@ export default {
   'builtins.lobe-cloud-sandbox.title': 'Cloud Sandbox',
   'builtins.lobe-group-agent-builder.apiName.batchCreateAgents': 'Batch create agents',
   'builtins.lobe-group-agent-builder.apiName.createAgent': 'Create agent',
+  'builtins.lobe-group-agent-builder.apiName.getAgentInfo': 'Get member info',
   'builtins.lobe-group-agent-builder.apiName.getAvailableModels': 'Get available models',
   'builtins.lobe-group-agent-builder.apiName.installPlugin': 'Install Skill',
   'builtins.lobe-group-agent-builder.apiName.inviteAgent': 'Invite member',

package/src/server/modules/AgentRuntime/RuntimeExecutors.ts

@@ -55,6 +55,8 @@ export const createRuntimeExecutors = (
     // Fallback to state's modelRuntimeConfig if not in payload
     const model = llmPayload.model || state.modelRuntimeConfig?.model;
     const provider = llmPayload.provider || state.modelRuntimeConfig?.provider;
+    // Fallback to state's tools if not in payload
+    const tools = llmPayload.tools || state.tools;
 
     if (!model || !provider) {
       throw new Error('Model and provider are required for call_llm instruction');
@@ -128,14 +130,14 @@ export const createRuntimeExecutors = (
       const chatPayload = {
         messages: llmPayload.messages,
         model,
-        tools: llmPayload.tools,
+        tools,
       };
 
       log(
         `${stagePrefix} calling model-runtime chat (model: %s, messages: %d, tools: %d)`,
         model,
         llmPayload.messages.length,
-        llmPayload.tools?.length ?? 0,
+        tools?.length ?? 0,
       );
 
       // Buffer: accumulate text and reasoning, send every 50ms
@@ -261,7 +263,12 @@ export const createRuntimeExecutors = (
             }
           },
           onToolsCalling: async ({ toolsCalling: raw }) => {
-            const payload = new ToolNameResolver().resolve(raw, state.toolManifestMap);
+            const resolved = new ToolNameResolver().resolve(raw, state.toolManifestMap);
+            // Add source field from toolSourceMap for routing tool execution
+            const payload = resolved.map((p) => ({
+              ...p,
+              source: state.toolSourceMap?.[p.identifier],
+            }));
             // log(`[${operationLogId}][toolsCalling]`, payload);
             toolsCalling = payload;
             tool_calls = raw;
@@ -466,6 +473,7 @@ export const createRuntimeExecutors = (
       // Execute tool using ToolExecutionService
       log(`[${operationLogId}] Executing tool ${toolName} ...`);
       const executionResult = await toolExecutionService.executeTool(chatToolPayload, {
+        serverDB: ctx.serverDB,
         toolManifestMap: state.toolManifestMap,
         userId: ctx.userId,
       });

package/src/server/modules/Mecha/AgentToolsEngine/index.ts

@@ -12,8 +12,7 @@
 import { KnowledgeBaseManifest } from '@lobechat/builtin-tool-knowledge-base';
 import { LocalSystemManifest } from '@lobechat/builtin-tool-local-system';
 import { WebBrowsingManifest } from '@lobechat/builtin-tool-web-browsing';
-import { ToolsEngine } from '@lobechat/context-engine';
-import type { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+import { type LobeToolManifest, ToolsEngine } from '@lobechat/context-engine';
 import debug from 'debug';
 
 import { builtinTools } from '@/tools';
@@ -50,11 +49,11 @@ export const createServerToolsEngine = (
 
   // Get plugin manifests from installed plugins (from database)
   const pluginManifests = context.installedPlugins
-    .map((plugin) => plugin.manifest as LobeChatPluginManifest)
+    .map((plugin) => plugin.manifest as LobeToolManifest)
     .filter(Boolean);
 
   // Get all builtin tool manifests
-  const builtinManifests = builtinTools.map((tool) => tool.manifest as LobeChatPluginManifest);
+  const builtinManifests = builtinTools.map((tool) => tool.manifest as LobeToolManifest);
 
   // Combine all manifests
   const allManifests = [...pluginManifests, ...builtinManifests, ...additionalManifests];
@@ -87,18 +86,27 @@ export const createServerAgentToolsEngine = (
   context: ServerAgentToolsContext,
   params: ServerCreateAgentToolsEngineParams,
 ): ToolsEngine => {
-  const { agentConfig, model, provider, hasEnabledKnowledgeBases = false } = params;
+  const {
+    additionalManifests,
+    agentConfig,
+    hasEnabledKnowledgeBases = false,
+    model,
+    provider,
+  } = params;
   const searchMode = agentConfig.chatConfig?.searchMode ?? 'off';
   const isSearchEnabled = searchMode !== 'off';
 
   log(
-    'Creating agent tools engine for model=%s, provider=%s, searchMode=%s',
+    'Creating agent tools engine for model=%s, provider=%s, searchMode=%s, additionalManifests=%d',
     model,
     provider,
     searchMode,
+    additionalManifests?.length ?? 0,
   );
 
   return createServerToolsEngine(context, {
+    // Pass additional manifests (e.g., LobeHub Skills)
+    additionalManifests,
     // Add default tools based on configuration
     defaultToolIds: [WebBrowsingManifest.identifier, KnowledgeBaseManifest.identifier],
     // Create search-aware enableChecker for this request

package/src/server/modules/Mecha/AgentToolsEngine/types.ts

@@ -1,6 +1,5 @@
-import type { PluginEnableChecker } from '@lobechat/context-engine';
+import type { LobeToolManifest, PluginEnableChecker } from '@lobechat/context-engine';
 import type { LobeTool } from '@lobechat/types';
-import type { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 
 /**
  * Installed plugin with manifest
@@ -22,7 +21,7 @@ export interface ServerAgentToolsContext {
  */
 export interface ServerAgentToolsEngineConfig {
   /** Additional manifests to include (e.g., Klavis tools) */
-  additionalManifests?: LobeChatPluginManifest[];
+  additionalManifests?: LobeToolManifest[];
   /** Default tool IDs that will always be added */
   defaultToolIds?: string[];
   /** Custom enable checker for plugins */
@@ -33,6 +32,8 @@ export interface ServerAgentToolsEngineConfig {
  * Parameters for createServerAgentToolsEngine
  */
 export interface ServerCreateAgentToolsEngineParams {
+  /** Additional manifests to include (e.g., LobeHub Skills) */
+  additionalManifests?: LobeToolManifest[];
   /** Agent configuration containing plugins array */
   agentConfig: {
     /** Optional agent chat config with searchMode */

package/src/server/routers/lambda/aiAgent.ts

@@ -642,6 +642,16 @@ export const aiAgentRouter = router({
       const updatedStatus = updatedThread?.status ?? thread.status;
       const updatedTaskStatus = threadStatusToTaskStatus[updatedStatus] || 'processing';
 
+      // DEBUG: Log metadata for failed tasks
+      if (updatedTaskStatus === 'failed') {
+        console.log('[DEBUG] getSubAgentTaskStatus - failed task metadata:', {
+          threadId,
+          updatedMetadata,
+          'updatedMetadata?.error': updatedMetadata?.error,
+          updatedStatus,
+        });
+      }
+
       // 6. Query thread messages for result content or current activity
       const threadMessages = await ctx.messageModel.query({ threadId });
       const sortedMessages = threadMessages.sort(

package/src/server/services/agent/index.test.ts

@@ -216,6 +216,161 @@ describe('AgentService', () => {
     });
   });
 
+  describe('getAgentConfig', () => {
+    it('should return null if agent does not exist', async () => {
+      const mockAgentModel = {
+        getAgentConfig: vi.fn().mockResolvedValue(null),
+      };
+
+      (AgentModel as any).mockImplementation(() => mockAgentModel);
+      (parseAgentConfig as any).mockReturnValue({});
+
+      const newService = new AgentService(mockDb, mockUserId);
+      const result = await newService.getAgentConfig('non-existent');
+
+      expect(result).toBeNull();
+    });
+
+    it('should support lookup by agent id', async () => {
+      const mockAgent = {
+        id: 'agent-123',
+        model: 'gpt-4',
+        systemRole: 'Test role',
+      };
+
+      const mockAgentModel = {
+        getAgentConfig: vi.fn().mockResolvedValue(mockAgent),
+      };
+
+      (AgentModel as any).mockImplementation(() => mockAgentModel);
+      (parseAgentConfig as any).mockReturnValue({});
+
+      const newService = new AgentService(mockDb, mockUserId);
+      const result = await newService.getAgentConfig('agent-123');
+
+      expect(mockAgentModel.getAgentConfig).toHaveBeenCalledWith('agent-123');
+      expect(result?.id).toBe('agent-123');
+      expect(result?.model).toBe('gpt-4');
+    });
+
+    it('should support lookup by slug', async () => {
+      const mockAgent = {
+        id: 'agent-123',
+        model: 'claude-3',
+        slug: 'my-agent',
+      };
+
+      const mockAgentModel = {
+        getAgentConfig: vi.fn().mockResolvedValue(mockAgent),
+      };
+
+      (AgentModel as any).mockImplementation(() => mockAgentModel);
+      (parseAgentConfig as any).mockReturnValue({});
+
+      const newService = new AgentService(mockDb, mockUserId);
+      const result = await newService.getAgentConfig('my-agent');
+
+      expect(mockAgentModel.getAgentConfig).toHaveBeenCalledWith('my-agent');
+      expect(result?.id).toBe('agent-123');
+    });
+
+    it('should merge DEFAULT_AGENT_CONFIG and serverDefaultAgentConfig with agent config', async () => {
+      const mockAgent = {
+        id: 'agent-1',
+        systemRole: 'Custom system role',
+      };
+      const serverDefaultConfig = { model: 'gpt-4', params: { temperature: 0.7 } };
+
+      const mockAgentModel = {
+        getAgentConfig: vi.fn().mockResolvedValue(mockAgent),
+      };
+
+      (AgentModel as any).mockImplementation(() => mockAgentModel);
+      (parseAgentConfig as any).mockReturnValue(serverDefaultConfig);
+
+      const newService = new AgentService(mockDb, mockUserId);
+      const result = await newService.getAgentConfig('agent-1');
+
+      expect(result).toMatchObject({
+        chatConfig: DEFAULT_AGENT_CONFIG.chatConfig,
+        plugins: DEFAULT_AGENT_CONFIG.plugins,
+        tts: DEFAULT_AGENT_CONFIG.tts,
+        model: 'gpt-4',
+        params: { temperature: 0.7 },
+        id: 'agent-1',
+        systemRole: 'Custom system role',
+      });
+    });
+
+    it('should use default model/provider when agent has none', async () => {
+      const mockAgent = {
+        id: 'agent-1',
+        systemRole: 'Test',
+        // No model or provider set
+      };
+
+      const mockAgentModel = {
+        getAgentConfig: vi.fn().mockResolvedValue(mockAgent),
+      };
+
+      (AgentModel as any).mockImplementation(() => mockAgentModel);
+      (parseAgentConfig as any).mockReturnValue({});
+
+      const newService = new AgentService(mockDb, mockUserId);
+      const result = await newService.getAgentConfig('agent-1');
+
+      // Should have default model/provider from DEFAULT_AGENT_CONFIG
+      expect(result?.model).toBe(DEFAULT_AGENT_CONFIG.model);
+      expect(result?.provider).toBe(DEFAULT_AGENT_CONFIG.provider);
+    });
+
+    it('should prioritize agent model/provider over defaults', async () => {
+      const mockAgent = {
+        id: 'agent-1',
+        model: 'claude-3-opus',
+        provider: 'anthropic',
+      };
+      const serverDefaultConfig = { model: 'gpt-4', provider: 'openai' };
+
+      const mockAgentModel = {
+        getAgentConfig: vi.fn().mockResolvedValue(mockAgent),
+      };
+
+      (AgentModel as any).mockImplementation(() => mockAgentModel);
+      (parseAgentConfig as any).mockReturnValue(serverDefaultConfig);
+
+      const newService = new AgentService(mockDb, mockUserId);
+      const result = await newService.getAgentConfig('agent-1');
+
+      // Agent config should override server default
+      expect(result?.model).toBe('claude-3-opus');
+      expect(result?.provider).toBe('anthropic');
+    });
+
+    it('should merge user default agent config', async () => {
+      const mockAgent = {
+        id: 'agent-1',
+      };
+      const userDefaultConfig = { model: 'user-preferred-model', provider: 'user-provider' };
+
+      const mockAgentModel = {
+        getAgentConfig: vi.fn().mockResolvedValue(mockAgent),
+      };
+
+      (AgentModel as any).mockImplementation(() => mockAgentModel);
+      (parseAgentConfig as any).mockReturnValue({});
+      // Use mockResolvedValueOnce to avoid affecting subsequent tests
+      mockUserModel.getUserSettingsDefaultAgentConfig.mockResolvedValueOnce({ config: userDefaultConfig });
+
+      const newService = new AgentService(mockDb, mockUserId);
+      const result = await newService.getAgentConfig('agent-1');
+
+      // User default config should be applied
+      expect(result?.model).toBe('user-preferred-model');
+      expect(result?.provider).toBe('user-provider');
+    });
+  });
+
   describe('getAgentConfigById', () => {
     it('should return null if agent does not exist', async () => {
       const mockAgentModel = {

package/src/server/services/agent/index.ts

@@ -17,6 +17,12 @@ import { type UpdateAgentResult } from './type';
 
 const log = debug('lobe-agent:service');
 
+/**
+ * Agent config with required id field.
+ * Used when returning agent config from database (id is always present).
+ */
+export type AgentConfigWithId = LobeAgentConfig & { id: string };
+
 interface AgentWelcomeData {
   openQuestions: string[];
   welcomeMessage: string;
@@ -78,6 +84,25 @@ export class AgentService {
     return mergedConfig;
   }
 
+  /**
+   * Get agent config by ID or slug with default config merged.
+   * Supports both agentId and slug lookup.
+   *
+   * The returned agent config is merged with:
+   * 1. DEFAULT_AGENT_CONFIG (hardcoded defaults)
+   * 2. Server's globalDefaultAgentConfig (from environment variable DEFAULT_AGENT_CONFIG)
+   * 3. User's defaultAgentConfig (from user settings)
+   * 4. The actual agent config from database
+   */
+  async getAgentConfig(idOrSlug: string): Promise<AgentConfigWithId | null> {
+    const [agent, defaultAgentConfig] = await Promise.all([
+      this.agentModel.getAgentConfig(idOrSlug),
+      this.userModel.getUserSettingsDefaultAgentConfig(),
+    ]);
+
+    return this.mergeDefaultConfig(agent, defaultAgentConfig) as AgentConfigWithId | null;
+  }
+
   /**
    * Get agent config by ID with default config merged.
    *

package/src/server/services/agentRuntime/AgentRuntimeService.ts

@@ -231,6 +231,7 @@ export class AgentRuntimeService {
       initialMessages = [],
       appContext,
       toolManifestMap,
+      toolSourceMap,
       stepCallbacks,
     } = params;
 
@@ -258,6 +259,7 @@ export class AgentRuntimeService {
         status: 'idle',
         stepCount: 0,
         toolManifestMap,
+        toolSourceMap,
         tools,
       } as Partial<AgentState>;
 

package/src/server/services/agentRuntime/types.ts

@@ -87,6 +87,7 @@ export interface OperationCreationParams {
    */
   stepCallbacks?: StepLifecycleCallbacks;
   toolManifestMap: Record<string, LobeToolManifest>;
+  toolSourceMap?: Record<string, 'builtin' | 'plugin' | 'mcp' | 'klavis' | 'lobehubSkill'>;
   tools?: any[];
   userId?: string;
 }

package/src/server/services/aiAgent/__tests__/execAgent.threadId.test.ts

@@ -29,6 +29,22 @@ vi.mock('@/database/models/agent', () => ({
   })),
 }));
 
+// Mock AgentService
+vi.mock('@/server/services/agent', () => ({
+  AgentService: vi.fn().mockImplementation(() => ({
+    getAgentConfig: vi.fn().mockResolvedValue({
+      chatConfig: {},
+      files: [],
+      id: 'agent-1',
+      knowledgeBases: [],
+      model: 'gpt-4',
+      plugins: [],
+      provider: 'openai',
+      systemRole: 'You are a helpful assistant',
+    }),
+  })),
+}));
+
 // Mock PluginModel
 vi.mock('@/database/models/plugin', () => ({
   PluginModel: vi.fn().mockImplementation(() => ({
@@ -74,15 +90,19 @@ vi.mock('@/server/modules/Mecha', () => ({
 }));
 
 // Mock model-bank
-vi.mock('model-bank', () => ({
-  LOBE_DEFAULT_MODEL_LIST: [
-    {
-      abilities: { functionCall: true, video: false, vision: true },
-      id: 'gpt-4',
-      providerId: 'openai',
-    },
-  ],
-}));
+vi.mock('model-bank', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('model-bank')>();
+  return {
+    ...actual,
+    LOBE_DEFAULT_MODEL_LIST: [
+      {
+        abilities: { functionCall: true, video: false, vision: true },
+        id: 'gpt-4',
+        providerId: 'openai',
+      },
+    ],
+  };
+});
 
 describe('AiAgentService.execAgent - threadId handling', () => {
   let service: AiAgentService;