@lobehub/lobehub 2.0.0-next.232 → 2.0.0-next.234

package/src/store/tool/slices/lobehubSkillStore/action.ts

@@ -0,0 +1,361 @@
+import { getLobehubSkillProviderById } from '@lobechat/const';
+import { enableMapSet, produce } from 'immer';
+import useSWR, { type SWRResponse } from 'swr';
+import { type StateCreator } from 'zustand/vanilla';
+
+import { toolsClient } from '@/libs/trpc/client';
+import { setNamespace } from '@/utils/storeDebug';
+
+import { type ToolStore } from '../../store';
+import { type LobehubSkillStoreState } from './initialState';
+import {
+  type CallLobehubSkillToolParams,
+  type CallLobehubSkillToolResult,
+  type LobehubSkillServer,
+  LobehubSkillStatus,
+  type LobehubSkillTool,
+} from './types';
+
+enableMapSet();
+
+const n = setNamespace('lobehubSkillStore');
+
+/**
+ * LobeHub Skill Store Actions
+ */
+export interface LobehubSkillStoreAction {
+  /**
+   * 调用 LobeHub Skill 工具
+   */
+  callLobehubSkillTool: (params: CallLobehubSkillToolParams) => Promise<CallLobehubSkillToolResult>;
+
+  /**
+   * 获取单个 Provider 的连接状态
+   * @param provider - Provider ID (如 'linear')
+   */
+  checkLobehubSkillStatus: (provider: string) => Promise<LobehubSkillServer | undefined>;
+
+  /**
+   * 获取 Provider 的授权信息（URL、code、过期时间）
+   * @param provider - Provider ID (如 'linear')
+   * @param options - 可选的 scopes 和 redirectUri
+   * @returns 授权 URL 和相关信息
+   */
+  getLobehubSkillAuthorizeUrl: (
+    provider: string,
+    options?: { redirectUri?: string; scopes?: string[] },
+  ) => Promise<{ authorizeUrl: string; code: string; expiresIn: number }>;
+
+  /**
+   * 内部方法: 更新 Server 状态
+   */
+  internal_updateLobehubSkillServer: (
+    provider: string,
+    update: Partial<LobehubSkillServer>,
+  ) => void;
+
+  /**
+   * 刷新 Provider 的 Token (如果支持)
+   * @param provider - Provider ID
+   */
+  refreshLobehubSkillToken: (provider: string) => Promise<boolean>;
+
+  /**
+   * 刷新 Provider 的工具列表
+   * @param provider - Provider ID
+   */
+  refreshLobehubSkillTools: (provider: string) => Promise<void>;
+
+  /**
+   * 断开 Provider 连接
+   * @param provider - Provider ID
+   */
+  revokeLobehubSkill: (provider: string) => Promise<void>;
+
+  /**
+   * 使用 SWR 获取用户的所有连接状态
+   * @param enabled - 是否启用获取
+   */
+  useFetchLobehubSkillConnections: (enabled: boolean) => SWRResponse<LobehubSkillServer[]>;
+}
+
+export const createLobehubSkillStoreSlice: StateCreator<
+  ToolStore,
+  [['zustand/devtools', never]],
+  [],
+  LobehubSkillStoreAction
+> = (set, get) => ({
+  callLobehubSkillTool: async (params) => {
+    const { provider, toolName, args } = params;
+    const toolId = `${provider}:${toolName}`;
+
+    set(
+      produce((draft: LobehubSkillStoreState) => {
+        draft.lobehubSkillExecutingToolIds.add(toolId);
+      }),
+      false,
+      n('callLobehubSkillTool/start'),
+    );
+
+    try {
+      const response = await toolsClient.market.connectCallTool.mutate({
+        args,
+        provider,
+        toolName,
+      });
+
+      set(
+        produce((draft: LobehubSkillStoreState) => {
+          draft.lobehubSkillExecutingToolIds.delete(toolId);
+        }),
+        false,
+        n('callLobehubSkillTool/success'),
+      );
+
+      return { data: response.data, success: true };
+    } catch (error) {
+      console.error('[LobehubSkill] Failed to call tool:', error);
+
+      set(
+        produce((draft: LobehubSkillStoreState) => {
+          draft.lobehubSkillExecutingToolIds.delete(toolId);
+        }),
+        false,
+        n('callLobehubSkillTool/error'),
+      );
+
+      const errorMessage = error instanceof Error ? error.message : String(error);
+
+      if (errorMessage.includes('NOT_CONNECTED') || errorMessage.includes('TOKEN_EXPIRED')) {
+        return {
+          error: errorMessage,
+          errorCode: 'NOT_CONNECTED',
+          success: false,
+        };
+      }
+
+      return {
+        error: errorMessage,
+        success: false,
+      };
+    }
+  },
+
+  checkLobehubSkillStatus: async (provider) => {
+    set(
+      produce((draft: LobehubSkillStoreState) => {
+        draft.lobehubSkillLoadingIds.add(provider);
+      }),
+      false,
+      n('checkLobehubSkillStatus/start'),
+    );
+
+    try {
+      const response = await toolsClient.market.connectGetStatus.query({ provider });
+      // Get provider config from local definition for correct display name
+      const providerConfig = getLobehubSkillProviderById(provider);
+
+      const server: LobehubSkillServer = {
+        cachedAt: Date.now(),
+        icon: response.icon,
+        identifier: provider,
+        isConnected: response.connected,
+        // Use local config label (e.g., "Linear") instead of API's providerName
+        name: providerConfig?.label || provider,
+        providerUsername: response.connection?.providerUsername,
+        scopes: response.connection?.scopes,
+        status: response.connected
+          ? LobehubSkillStatus.CONNECTED
+          : LobehubSkillStatus.NOT_CONNECTED,
+        tokenExpiresAt: response.connection?.tokenExpiresAt,
+      };
+
+      set(
+        produce((draft: LobehubSkillStoreState) => {
+          const existingIndex = draft.lobehubSkillServers.findIndex(
+            (s) => s.identifier === provider,
+          );
+          if (existingIndex >= 0) {
+            draft.lobehubSkillServers[existingIndex] = server;
+          } else {
+            draft.lobehubSkillServers.push(server);
+          }
+          draft.lobehubSkillLoadingIds.delete(provider);
+        }),
+        false,
+        n('checkLobehubSkillStatus/success'),
+      );
+
+      if (server.isConnected) {
+        get().refreshLobehubSkillTools(provider);
+      }
+
+      return server;
+    } catch (error) {
+      console.error('[LobehubSkill] Failed to check status:', error);
+
+      set(
+        produce((draft: LobehubSkillStoreState) => {
+          draft.lobehubSkillLoadingIds.delete(provider);
+        }),
+        false,
+        n('checkLobehubSkillStatus/error'),
+      );
+
+      return undefined;
+    }
+  },
+
+  getLobehubSkillAuthorizeUrl: async (provider, options) => {
+    const response = await toolsClient.market.connectGetAuthorizeUrl.query({
+      provider,
+      redirectUri: options?.redirectUri,
+      scopes: options?.scopes,
+    });
+
+    return {
+      authorizeUrl: response.authorizeUrl,
+      code: response.code,
+      expiresIn: response.expiresIn,
+    };
+  },
+
+  internal_updateLobehubSkillServer: (provider, update) => {
+    set(
+      produce((draft: LobehubSkillStoreState) => {
+        const serverIndex = draft.lobehubSkillServers.findIndex((s) => s.identifier === provider);
+        if (serverIndex >= 0) {
+          draft.lobehubSkillServers[serverIndex] = {
+            ...draft.lobehubSkillServers[serverIndex],
+            ...update,
+          };
+        }
+      }),
+      false,
+      n('internal_updateLobehubSkillServer'),
+    );
+  },
+
+  refreshLobehubSkillToken: async (provider) => {
+    try {
+      const response = await toolsClient.market.connectRefresh.mutate({ provider });
+
+      if (response.refreshed) {
+        get().internal_updateLobehubSkillServer(provider, {
+          status: LobehubSkillStatus.CONNECTED,
+          tokenExpiresAt: response.connection?.tokenExpiresAt,
+        });
+      }
+
+      return response.refreshed;
+    } catch (error) {
+      console.error('[LobehubSkill] Failed to refresh token:', error);
+      return false;
+    }
+  },
+
+  refreshLobehubSkillTools: async (provider) => {
+    try {
+      const response = await toolsClient.market.connectListTools.query({ provider });
+
+      set(
+        produce((draft: LobehubSkillStoreState) => {
+          const serverIndex = draft.lobehubSkillServers.findIndex((s) => s.identifier === provider);
+          if (serverIndex >= 0) {
+            draft.lobehubSkillServers[serverIndex].tools = response.tools as LobehubSkillTool[];
+          }
+        }),
+        false,
+        n('refreshLobehubSkillTools/success'),
+      );
+    } catch (error) {
+      console.error('[LobehubSkill] Failed to refresh tools:', error);
+    }
+  },
+
+  revokeLobehubSkill: async (provider) => {
+    set(
+      produce((draft: LobehubSkillStoreState) => {
+        draft.lobehubSkillLoadingIds.add(provider);
+      }),
+      false,
+      n('revokeLobehubSkill/start'),
+    );
+
+    try {
+      await toolsClient.market.connectRevoke.mutate({ provider });
+
+      set(
+        produce((draft: LobehubSkillStoreState) => {
+          draft.lobehubSkillServers = draft.lobehubSkillServers.filter(
+            (s) => s.identifier !== provider,
+          );
+          draft.lobehubSkillLoadingIds.delete(provider);
+        }),
+        false,
+        n('revokeLobehubSkill/success'),
+      );
+    } catch (error) {
+      console.error('[LobehubSkill] Failed to revoke:', error);
+
+      set(
+        produce((draft: LobehubSkillStoreState) => {
+          draft.lobehubSkillLoadingIds.delete(provider);
+        }),
+        false,
+        n('revokeLobehubSkill/error'),
+      );
+    }
+  },
+
+  useFetchLobehubSkillConnections: (enabled) =>
+    useSWR<LobehubSkillServer[]>(
+      enabled ? 'fetchLobehubSkillConnections' : null,
+      async () => {
+        const response = await toolsClient.market.connectListConnections.query();
+
+        // Debug logging
+        console.log('[useFetchLobehubSkillConnections] raw response:', response);
+
+        return response.connections.map((conn: any) => {
+          // Debug logging for each connection
+          console.log('[useFetchLobehubSkillConnections] connection:', conn);
+          // Get provider config from local definition for correct display name
+          const providerConfig = getLobehubSkillProviderById(conn.providerId);
+          return {
+            cachedAt: Date.now(),
+            icon: conn.icon,
+            identifier: conn.providerId,
+            isConnected: true,
+            // Use local config label (e.g., "Linear") instead of API's providerName (which is user's name on that service)
+            name: providerConfig?.label || conn.providerId,
+            providerUsername: conn.providerUsername,
+            scopes: conn.scopes,
+            status: LobehubSkillStatus.CONNECTED,
+            tokenExpiresAt: conn.tokenExpiresAt,
+          };
+        });
+      },
+      {
+        fallbackData: [],
+        onSuccess: (data) => {
+          if (data.length > 0) {
+            set(
+              produce((draft: LobehubSkillStoreState) => {
+                const existingIds = new Set(draft.lobehubSkillServers.map((s) => s.identifier));
+                const newServers = data.filter((s) => !existingIds.has(s.identifier));
+                draft.lobehubSkillServers = [...draft.lobehubSkillServers, ...newServers];
+              }),
+              false,
+              n('useFetchLobehubSkillConnections'),
+            );
+
+            for (const server of data) {
+              get().refreshLobehubSkillTools(server.identifier);
+            }
+          }
+        },
+        revalidateOnFocus: false,
+      },
+    ),
+});

package/src/store/tool/slices/lobehubSkillStore/index.ts

@@ -0,0 +1,4 @@
+export * from './action';
+export * from './initialState';
+export * from './selectors';
+export * from './types';

package/src/store/tool/slices/lobehubSkillStore/initialState.ts

@@ -0,0 +1,24 @@
+import { type LobehubSkillServer } from './types';
+
+/**
+ * LobeHub Skill Store 状态接口
+ *
+ * NOTE: 所有连接状态和工具数据都从 Market API 实时获取，不存储到本地数据库
+ */
+export interface LobehubSkillStoreState {
+  /** 正在执行的工具调用 ID 集合 */
+  lobehubSkillExecutingToolIds: Set<string>;
+  /** 正在加载的 Provider ID 集合 */
+  lobehubSkillLoadingIds: Set<string>;
+  /** 已连接的 LobeHub Skill Server 列表 */
+  lobehubSkillServers: LobehubSkillServer[];
+}
+
+/**
+ * LobeHub Skill Store 初始状态
+ */
+export const initialLobehubSkillStoreState: LobehubSkillStoreState = {
+  lobehubSkillExecutingToolIds: new Set(),
+  lobehubSkillLoadingIds: new Set(),
+  lobehubSkillServers: [],
+};

package/src/store/tool/slices/lobehubSkillStore/selectors.ts

@@ -0,0 +1,145 @@
+import { type ToolStoreState } from '../../initialState';
+import { type LobehubSkillServer, LobehubSkillStatus } from './types';
+
+/**
+ * LobeHub Skill Store Selectors
+ */
+export const lobehubSkillStoreSelectors = {
+  /**
+   * 获取所有 LobeHub Skill 服务器的 identifier 集合
+   */
+  getAllServerIdentifiers: (s: ToolStoreState): Set<string> => {
+    const servers = s.lobehubSkillServers || [];
+    return new Set(servers.map((server) => server.identifier));
+  },
+
+  /**
+   * 获取所有可用的工具（来自所有已连接的服务器）
+   */
+  getAllTools: (s: ToolStoreState) => {
+    const connectedServers = lobehubSkillStoreSelectors.getConnectedServers(s);
+    return connectedServers.flatMap((server) =>
+      (server.tools || []).map((tool) => ({
+        ...tool,
+        provider: server.identifier,
+      })),
+    );
+  },
+
+  /**
+   * 获取所有已连接的服务器
+   */
+  getConnectedServers: (s: ToolStoreState): LobehubSkillServer[] =>
+    (s.lobehubSkillServers || []).filter(
+      (server) => server.status === LobehubSkillStatus.CONNECTED,
+    ),
+
+  /**
+   * 根据 identifier 获取服务器
+   * @param identifier - Provider 标识符 (e.g., 'linear')
+   */
+  getServerByIdentifier: (identifier: string) => (s: ToolStoreState) =>
+    s.lobehubSkillServers?.find((server) => server.identifier === identifier),
+
+  /**
+   * 获取所有 LobeHub Skill 服务器
+   */
+  getServers: (s: ToolStoreState): LobehubSkillServer[] => s.lobehubSkillServers || [],
+
+  /**
+   * 检查给定的 identifier 是否是 LobeHub Skill 服务器
+   * @param identifier - Provider 标识符 (e.g., 'linear')
+   */
+  isLobehubSkillServer:
+    (identifier: string) =>
+    (s: ToolStoreState): boolean => {
+      const servers = s.lobehubSkillServers || [];
+      return servers.some((server) => server.identifier === identifier);
+    },
+
+  /**
+   * 检查服务器是否正在加载
+   * @param identifier - Provider 标识符 (e.g., 'linear')
+   */
+  isServerLoading: (identifier: string) => (s: ToolStoreState) =>
+    s.lobehubSkillLoadingIds?.has(identifier) || false,
+
+  /**
+   * 检查工具是否正在执行
+   */
+  isToolExecuting: (provider: string, toolName: string) => (s: ToolStoreState) => {
+    const toolId = `${provider}:${toolName}`;
+    return s.lobehubSkillExecutingToolIds?.has(toolId) || false;
+  },
+
+  /**
+   * Get all LobeHub Skill tools as LobeTool format for agent use
+   * Converts LobeHub Skill tools into the format expected by ToolNameResolver
+   */
+  lobehubSkillAsLobeTools: (s: ToolStoreState) => {
+    const servers = s.lobehubSkillServers || [];
+    const tools: any[] = [];
+
+    for (const server of servers) {
+      if (!server.tools || server.status !== LobehubSkillStatus.CONNECTED) continue;
+
+      const apis = server.tools.map((tool) => ({
+        description: tool.description || '',
+        name: tool.name,
+        parameters: tool.inputSchema || {},
+      }));
+
+      if (apis.length > 0) {
+        tools.push({
+          identifier: server.identifier,
+          manifest: {
+            api: apis,
+            author: 'LobeHub Market',
+            homepage: 'https://lobehub.com/market',
+            identifier: server.identifier,
+            meta: {
+              avatar: server.icon || '🔗',
+              description: `LobeHub Skill: ${server.name}`,
+              tags: ['lobehub-skill', server.identifier],
+              title: server.name,
+            },
+            type: 'builtin',
+            version: '1.0.0',
+          },
+          type: 'plugin',
+        });
+      }
+    }
+
+    return tools;
+  },
+
+  /**
+   * Get metadata list for all connected LobeHub Skill servers
+   * Used by toolSelectors.metaList for unified tool metadata resolution
+   */
+  metaList: (s: ToolStoreState) => {
+    const servers = s.lobehubSkillServers || [];
+    const result = servers
+      .filter((server) => server.status === LobehubSkillStatus.CONNECTED)
+      .map((server) => {
+        // Debug logging
+        console.log('[lobehubSkillStoreSelectors.metaList] server:', {
+          icon: server.icon,
+          identifier: server.identifier,
+          name: server.name,
+          status: server.status,
+        });
+        return {
+          identifier: server.identifier,
+          meta: {
+            avatar: server.icon || '🔗',
+            description: `LobeHub Skill: ${server.name}`,
+            title: server.name,
+          },
+        };
+      });
+    console.log('[lobehubSkillStoreSelectors.metaList] result:', result);
+    return result;
+  },
+};

package/src/store/tool/slices/lobehubSkillStore/types.ts

@@ -0,0 +1,100 @@
+/**
+ * LobeHub Skill Server 连接状态
+ */
+export enum LobehubSkillStatus {
+  /** 已连接，可以使用 */
+  CONNECTED = 'connected',
+  /** 连接中 */
+  CONNECTING = 'connecting',
+  /** 连接失败或 Token 过期 */
+  ERROR = 'error',
+  /** 未连接 */
+  NOT_CONNECTED = 'not_connected',
+}
+
+/**
+ * LobeHub Skill Tool 定义 (来自 Market API)
+ */
+export interface LobehubSkillTool {
+  /** 工具描述 */
+  description?: string;
+  /** 工具输入的 JSON Schema */
+  inputSchema: {
+    additionalProperties?: boolean;
+    properties?: Record<string, any>;
+    required?: string[];
+    type: string;
+  };
+  /** 工具名称 */
+  name: string;
+}
+
+/**
+ * LobeHub Skill Provider 定义 (来自 Market API)
+ */
+export interface LobehubSkillProvider {
+  /** Provider 图标 URL */
+  icon?: string;
+  /** Provider ID (如 'linear', 'github') */
+  id: string;
+  /** 显示名称 */
+  name: string;
+  /** 是否支持刷新 Token */
+  refreshSupported?: boolean;
+  /** Provider 类型 */
+  type?: 'mcp' | 'rest';
+}
+
+/**
+ * LobeHub Skill Server 实例 (用户已连接的 provider)
+ */
+export interface LobehubSkillServer {
+  /** 缓存时间戳 */
+  cachedAt?: number;
+  /** 错误信息 */
+  errorMessage?: string;
+  /** Provider 图标 URL */
+  icon?: string;
+  /** Provider ID (如 'linear') */
+  identifier: string;
+  /** 是否已认证 */
+  isConnected: boolean;
+  /** Provider 显示名称 */
+  name: string;
+  /** Provider 用户名 (如 GitHub username) */
+  providerUsername?: string;
+  /** 授权的 scopes */
+  scopes?: string[];
+  /** 连接状态 */
+  status: LobehubSkillStatus;
+  /** Token 过期时间 */
+  tokenExpiresAt?: string;
+  /** 工具列表 (已连接后可用) */
+  tools?: LobehubSkillTool[];
+}
+
+/**
+ * 调用 LobeHub Skill 工具的参数
+ */
+export interface CallLobehubSkillToolParams {
+  /** 工具参数 */
+  args?: Record<string, unknown>;
+  /** Provider ID (如 'linear') */
+  provider: string;
+  /** 工具名称 */
+  toolName: string;
+}
+
+/**
+ * 调用 LobeHub Skill 工具的结果
+ */
+export interface CallLobehubSkillToolResult {
+  /** 返回数据 */
+  data?: any;
+  /** 错误信息 */
+  error?: string;
+  /** 错误代码 */
+  errorCode?: string;
+  /** 是否成功 */
+  success: boolean;
+}

package/src/store/tool/store.ts

@@ -7,9 +7,13 @@ import { type ToolStoreState, initialState } from './initialState';
 import { type BuiltinToolAction, createBuiltinToolSlice } from './slices/builtin';
 import { type CustomPluginAction, createCustomPluginSlice } from './slices/customPlugin';
 import { type KlavisStoreAction, createKlavisStoreSlice } from './slices/klavisStore';
+import {
+  type LobehubSkillStoreAction,
+  createLobehubSkillStoreSlice,
+} from './slices/lobehubSkillStore';
 import { type PluginMCPStoreAction, createMCPPluginStoreSlice } from './slices/mcpStore';
-import { type PluginAction, createPluginSlice } from './slices/plugin';
 import { type PluginStoreAction, createPluginStoreSlice } from './slices/oldStore';
+import { type PluginAction, createPluginSlice } from './slices/plugin';
 
 //  ===============  Aggregate createStoreFn ============ //
 
@@ -19,7 +23,8 @@ export type ToolStore = ToolStoreState &
   PluginStoreAction &
   BuiltinToolAction &
   PluginMCPStoreAction &
-  KlavisStoreAction;
+  KlavisStoreAction &
+  LobehubSkillStoreAction;
 
 const createStore: StateCreator<ToolStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
@@ -29,6 +34,7 @@ const createStore: StateCreator<ToolStore, [['zustand/devtools', never]]> = (...
   ...createBuiltinToolSlice(...parameters),
   ...createMCPPluginStoreSlice(...parameters),
   ...createKlavisStoreSlice(...parameters),
+  ...createLobehubSkillStoreSlice(...parameters),
 });
 
 //  ===============  Implement useStore ============ //