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

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,
+      };
+    }
+  }
+}

package/src/server/services/toolExecution/builtin.ts

@@ -4,6 +4,7 @@ import { type ChatToolPayload } from '@lobechat/types';
 import { safeParseJSON } from '@lobechat/utils';
 import debug from 'debug';
 
+import { LobehubSkillService } from '@/server/services/lobehubSkill';
 import { SearchService } from '@/server/services/search';
 
 import { type IToolExecutor, type ToolExecutionContext, type ToolExecutionResult } from './types';
@@ -19,11 +20,36 @@ export class BuiltinToolsExecutor implements IToolExecutor {
     payload: ChatToolPayload,
     context: ToolExecutionContext,
   ): Promise<ToolExecutionResult> {
-    const { identifier, apiName, arguments: argsStr } = payload;
+    const { identifier, apiName, arguments: argsStr, source } = payload;
     const args = safeParseJSON(argsStr) || {};
 
-    log('Executing builtin tool: %s:%s with args: %O', identifier, apiName, args, context);
+    log(
+      'Executing builtin tool: %s:%s (source: %s) with args: %O',
+      identifier,
+      apiName,
+      source,
+      args,
+    );
 
+    // Route LobeHub Skills to dedicated service
+    if (source === 'lobehubSkill') {
+      if (!context.serverDB || !context.userId) {
+        return {
+          content: 'Server context not available for LobeHub Skills execution.',
+          error: { code: 'CONTEXT_NOT_AVAILABLE' },
+          success: false,
+        };
+      }
+
+      const skillService = new LobehubSkillService(context.serverDB, context.userId);
+      return skillService.execute({
+        args,
+        provider: identifier,
+        toolName: apiName,
+      });
+    }
+
+    // Default: original builtin runtime logic
     const ServerRuntime = BuiltinToolServerRuntimes[identifier];
 
     if (!ServerRuntime) {

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

@@ -1,7 +1,10 @@
 import { type LobeToolManifest } from '@lobechat/context-engine';
+import { type LobeChatDatabase } from '@lobechat/database';
 import { type ChatToolPayload } from '@lobechat/types';
 
 export interface ToolExecutionContext {
+  /** Server database for LobeHub Skills execution */
+  serverDB?: LobeChatDatabase;
   toolManifestMap: Record<string, LobeToolManifest>;
   userId?: string;
 }

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

@@ -1087,12 +1087,14 @@ export const createAgentExecutors = (context: {
           }
 
           if (status.status === 'failed') {
-            log('[%s] Task failed: %s', taskLogId, status.error);
+            // Extract error message (error is always a string in TaskStatusResult)
+            const errorMessage = status.error || 'Unknown error';
+            log('[%s] Task failed: %s', taskLogId, errorMessage);
             await context
               .get()
               .optimisticUpdateMessageContent(
                 taskMessageId,
-                `Task failed: ${status.error}`,
+                `Task failed: ${errorMessage}`,
                 undefined,
                 { operationId: state.operationId },
               );