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

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;

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

@@ -1,4 +1,5 @@
 import type { AgentRuntimeContext, AgentState } from '@lobechat/agent-runtime';
+import type { LobeToolManifest } from '@lobechat/context-engine';
 import { type LobeChatDatabase } from '@lobechat/database';
 import type {
   ExecAgentParams,
@@ -10,6 +11,7 @@ import type {
 } from '@lobechat/types';
 import { ThreadStatus, ThreadType } from '@lobechat/types';
 import { nanoid } from '@lobechat/utils';
+import { MarketSDK } from '@lobehub/market-sdk';
 import debug from 'debug';
 
 import { LOADING_FLAT } from '@/const/message';
@@ -18,16 +20,43 @@ import { MessageModel } from '@/database/models/message';
 import { PluginModel } from '@/database/models/plugin';
 import { ThreadModel } from '@/database/models/thread';
 import { TopicModel } from '@/database/models/topic';
+import { UserModel } from '@/database/models/user';
+import { generateTrustedClientToken } from '@/libs/trusted-client';
 import {
   type ServerAgentToolsContext,
   createServerAgentToolsEngine,
   serverMessagesEngine,
 } from '@/server/modules/Mecha';
+import { AgentService } from '@/server/services/agent';
 import { AgentRuntimeService } from '@/server/services/agentRuntime';
 import type { StepLifecycleCallbacks } from '@/server/services/agentRuntime/types';
 
 const log = debug('lobe-server:ai-agent-service');
 
+/**
+ * Format error for storage in thread metadata
+ * Handles Error objects which don't serialize properly with JSON.stringify
+ */
+function formatErrorForMetadata(error: unknown): Record<string, any> | undefined {
+  if (!error) return undefined;
+
+  // Handle Error objects
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      name: error.name,
+    };
+  }
+
+  // Handle objects with message property (like ChatMessageError)
+  if (typeof error === 'object' && 'message' in error) {
+    return error as Record<string, any>;
+  }
+
+  // Fallback: wrap in object
+  return { message: String(error) };
+}
+
 /**
  * Internal params for execAgent with step lifecycle callbacks
  * This extends the public ExecAgentParams with server-side only options
@@ -53,6 +82,7 @@ export class AiAgentService {
   private readonly userId: string;
   private readonly db: LobeChatDatabase;
   private readonly agentModel: AgentModel;
+  private readonly agentService: AgentService;
   private readonly messageModel: MessageModel;
   private readonly pluginModel: PluginModel;
   private readonly threadModel: ThreadModel;
@@ -63,6 +93,7 @@ export class AiAgentService {
     this.userId = userId;
     this.db = db;
     this.agentModel = new AgentModel(db, userId);
+    this.agentService = new AgentService(db, userId);
     this.messageModel = new MessageModel(db, userId);
     this.pluginModel = new PluginModel(db, userId);
     this.threadModel = new ThreadModel(db, userId);
@@ -106,8 +137,8 @@ export class AiAgentService {
 
     log('execAgent: identifier=%s, prompt=%s', identifier, prompt.slice(0, 50));
 
-    // 1. Get agent configuration from database (supports both id and slug)
-    const agentConfig = await this.agentModel.getAgentConfig(identifier);
+    // 1. Get agent configuration with default config merged (supports both id and slug)
+    const agentConfig = await this.agentService.getAgentConfig(identifier);
     if (!agentConfig) {
       throw new Error(`Agent not found: ${identifier}`);
     }
@@ -158,7 +189,11 @@ export class AiAgentService {
       return info?.abilities?.functionCall ?? true;
     };
 
-    // 5. Create tools using Server AgentToolsEngine
+    // 5. Fetch LobeHub Skills manifests (temporary solution until LOBE-3517 is implemented)
+    const lobehubSkillManifests = await this.fetchLobehubSkillManifests();
+    log('execAgent: got %d lobehub skill manifests', lobehubSkillManifests.length);
+
+    // 6. Create tools using Server AgentToolsEngine
     const hasEnabledKnowledgeBases =
       agentConfig.knowledgeBases?.some((kb: { enabled?: boolean | null }) => kb.enabled === true) ??
       false;
@@ -169,6 +204,7 @@ export class AiAgentService {
     };
 
     const toolsEngine = createServerAgentToolsEngine(toolsContext, {
+      additionalManifests: lobehubSkillManifests,
       agentConfig: {
         chatConfig: agentConfig.chatConfig ?? undefined,
         plugins: agentConfig.plugins ?? undefined,
@@ -180,6 +216,8 @@ export class AiAgentService {
 
     // Generate tools and manifest map
     const pluginIds = agentConfig.plugins || [];
+    log('execAgent: agent configured plugins: %O', pluginIds);
+
     const toolsResult = toolsEngine.generateToolsDetailed({
       model,
       provider,
@@ -188,6 +226,12 @@ export class AiAgentService {
 
     const tools = toolsResult.tools;
 
+    // Log detailed tools generation result
+    if (toolsResult.filteredTools && toolsResult.filteredTools.length > 0) {
+      log('execAgent: filtered tools: %O', toolsResult.filteredTools);
+    }
+    log('execAgent: enabled tool ids: %O', toolsResult.enabledToolIds);
+
     // Get manifest map and convert from Map to Record
     const manifestMap = toolsEngine.getEnabledPluginManifests(pluginIds);
     const toolManifestMap: Record<string, any> = {};
@@ -195,7 +239,20 @@ export class AiAgentService {
       toolManifestMap[id] = manifest;
     });
 
-    log('execAgent: generated %d tools', tools?.length ?? 0);
+    // Build toolSourceMap for routing tool execution
+    const toolSourceMap: Record<string, 'builtin' | 'plugin' | 'mcp' | 'klavis' | 'lobehubSkill'> =
+      {};
+    // Mark lobehub skills
+    for (const manifest of lobehubSkillManifests) {
+      toolSourceMap[manifest.identifier] = 'lobehubSkill';
+    }
+
+    log(
+      'execAgent: generated %d tools from %d configured plugins, %d lobehub skills',
+      tools?.length ?? 0,
+      pluginIds.length,
+      lobehubSkillManifests.length,
+    );
 
     // 6. Get existing messages if provided
     let historyMessages: any[] = [];
@@ -301,7 +358,18 @@ export class AiAgentService {
       },
     };
 
-    // 12. Create operation using AgentRuntimeService
+    // 12. Log final operation parameters summary
+    log(
+      'execAgent: creating operation %s with params: model=%s, provider=%s, tools=%d, messages=%d, manifests=%d',
+      operationId,
+      model,
+      provider,
+      tools?.length ?? 0,
+      processedMessages.length,
+      Object.keys(toolManifestMap).length,
+    );
+
+    // 13. Create operation using AgentRuntimeService
     // Wrap in try-catch to handle operation startup failures (e.g., QStash unavailable)
     // If createOperation fails, we still have valid messages that need error info
     try {
@@ -320,6 +388,7 @@ export class AiAgentService {
         operationId,
         stepCallbacks,
         toolManifestMap,
+        toolSourceMap,
         tools,
         userId: this.userId,
       });
@@ -616,6 +685,11 @@ export class AiAgentService {
           }
         }
 
+        // Log error when task fails
+        if (reason === 'error' && finalState.error) {
+          console.error('execSubAgentTask: task failed for thread %s:', threadId, finalState.error);
+        }
+
         try {
           // Extract summary from last assistant message and update task message content
           const lastAssistantMessage = finalState.messages
@@ -630,12 +704,15 @@ export class AiAgentService {
             log('execSubAgentTask: updated task message %s with summary', sourceMessageId);
           }
 
+          // Format error for proper serialization (Error objects don't serialize with JSON.stringify)
+          const formattedError = formatErrorForMetadata(finalState.error);
+
           // Update Thread metadata
           await this.threadModel.update(threadId, {
             metadata: {
               completedAt,
               duration,
-              error: finalState.error,
+              error: formattedError,
               operationId: finalState.operationId,
               startedAt,
               totalCost: finalState.cost?.total,
@@ -659,6 +736,98 @@ export class AiAgentService {
     };
   }
 
+  /**
+   * Fetch LobeHub Skills manifests from Market API
+   * This is a temporary solution until LOBE-3517 is implemented (store skills in DB)
+   */
+  private async fetchLobehubSkillManifests(): Promise<LobeToolManifest[]> {
+    try {
+      // 1. Get user info for trusted client token
+      const user = await UserModel.findById(this.db, this.userId);
+      if (!user?.email) {
+        log('fetchLobehubSkillManifests: user email not found, skipping');
+        return [];
+      }
+
+      // 2. Generate trusted client token
+      const trustedClientToken = generateTrustedClientToken({
+        email: user.email,
+        name: user.fullName || user.firstName || undefined,
+        userId: this.userId,
+      });
+
+      if (!trustedClientToken) {
+        log('fetchLobehubSkillManifests: trusted client not configured, skipping');
+        return [];
+      }
+
+      // 3. Create MarketSDK instance
+      const marketSDK = new MarketSDK({
+        baseURL: process.env.NEXT_PUBLIC_MARKET_BASE_URL,
+        trustedClientToken,
+      });
+
+      // 4. Get user's connected skills
+      const { connections } = await marketSDK.connect.listConnections();
+      if (!connections || connections.length === 0) {
+        log('fetchLobehubSkillManifests: no connected skills found');
+        return [];
+      }
+
+      log('fetchLobehubSkillManifests: found %d connected skills', connections.length);
+
+      // 5. Fetch tools for each connection and build manifests
+      const manifests: LobeToolManifest[] = [];
+
+      for (const connection of connections) {
+        try {
+          // Connection returns providerId (e.g., 'twitter', 'linear'), not numeric id
+          const providerId = (connection as any).providerId;
+          if (!providerId) {
+            log('fetchLobehubSkillManifests: connection missing providerId: %O', connection);
+            continue;
+          }
+          const providerName =
+            (connection as any).providerName || (connection as any).name || providerId;
+          const icon = (connection as any).icon;
+
+          const { tools } = await marketSDK.skills.listTools(providerId);
+          if (!tools || tools.length === 0) continue;
+
+          const manifest: LobeToolManifest = {
+            api: tools.map((tool: any) => ({
+              description: tool.description || '',
+              name: tool.name,
+              parameters: tool.inputSchema || { properties: {}, type: 'object' },
+            })),
+            identifier: providerId,
+            meta: {
+              avatar: icon || '🔗',
+              description: `LobeHub Skill: ${providerName}`,
+              tags: ['lobehub-skill', providerId],
+              title: providerName,
+            },
+            type: 'builtin',
+          };
+
+          manifests.push(manifest);
+          log(
+            'fetchLobehubSkillManifests: built manifest for %s with %d tools',
+            providerId,
+            tools.length,
+          );
+        } catch (error) {
+          log('fetchLobehubSkillManifests: failed to fetch tools for connection: %O', error);
+        }
+      }
+
+      return manifests;
+    } catch (error) {
+      log('fetchLobehubSkillManifests: error fetching skills: %O', error);
+      return [];
+    }
+  }
+
   /**
    * Calculate total tokens from AgentState usage object
    * AgentState.usage is of type Usage from @lobechat/agent-runtime

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

@@ -0,0 +1,109 @@
+import { type LobeChatDatabase } from '@lobechat/database';
+import { MarketSDK } from '@lobehub/market-sdk';
+import debug from 'debug';
+
+import { UserModel } from '@/database/models/user';
+import { generateTrustedClientToken } from '@/libs/trusted-client';
+
+const log = debug('lobe-server:lobehub-skill-service');
+
+export interface LobehubSkillExecuteParams {
+  args: Record<string, any>;
+  provider: string;
+  toolName: string;
+}
+
+export interface LobehubSkillExecuteResult {
+  content: string;
+  error?: { code: string; message?: string };
+  success: boolean;
+}
+
+export class LobehubSkillService {
+  private db: LobeChatDatabase;
+  private userId: string;
+  private marketSDK?: MarketSDK;
+
+  constructor(db: LobeChatDatabase, userId: string) {
+    this.db = db;
+    this.userId = userId;
+  }
+
+  /**
+   * Initialize MarketSDK with trusted client token
+   */
+  private async getMarketSDK(): Promise<MarketSDK | null> {
+    if (this.marketSDK) return this.marketSDK;
+
+    try {
+      const user = await UserModel.findById(this.db, this.userId);
+      if (!user?.email) {
+        log('getMarketSDK: user email not found');
+        return null;
+      }
+
+      const trustedClientToken = generateTrustedClientToken({
+        email: user.email,
+        name: user.fullName || user.firstName || undefined,
+        userId: this.userId,
+      });
+
+      if (!trustedClientToken) {
+        log('getMarketSDK: trusted client not configured');
+        return null;
+      }
+
+      this.marketSDK = new MarketSDK({
+        baseURL: process.env.NEXT_PUBLIC_MARKET_BASE_URL,
+        trustedClientToken,
+      });
+
+      return this.marketSDK;
+    } catch (error) {
+      log('getMarketSDK: error creating SDK: %O', error);
+      return null;
+    }
+  }
+
+  /**
+   * Execute a LobeHub Skill tool
+   */
+  async execute(params: LobehubSkillExecuteParams): Promise<LobehubSkillExecuteResult> {
+    const { provider, toolName, args } = params;
+
+    log('execute: %s/%s with args: %O', provider, toolName, args);
+
+    const sdk = await this.getMarketSDK();
+    if (!sdk) {
+      return {
+        content:
+          'MarketSDK not available. Please ensure you are authenticated with LobeHub Market.',
+        error: { code: 'MARKET_SDK_NOT_AVAILABLE' },
+        success: false,
+      };
+    }
+
+    try {
+      const response = await sdk.skills.callTool(provider, {
+        args,
+        tool: toolName,
+      });
+
+      log('execute: response: %O', response);
+
+      return {
+        content: typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
+        success: response.success,
+      };
+    } catch (error) {
+      const err = error as Error;
+      console.error('LobehubSkillService.execute error %s/%s: %O', provider, toolName, err);
+
+      return {
+        content: err.message,
+        error: { code: 'LOBEHUB_SKILL_ERROR', message: err.message },
+        success: false,
+      };
+    }
+  }
+}