@lobehub/lobehub 2.0.0-next.47 → 2.0.0-next.49

package/src/services/_url.ts

@@ -1,6 +1,5 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix */
 
-
 export const API_ENDPOINTS = {
   oauth: '/api/auth',
 
@@ -30,3 +29,18 @@ export const API_ENDPOINTS = {
   edge: '/webapi/tts/edge',
   microsoft: '/webapi/tts/microsoft',
 };
+
+export const MARKET_OIDC_ENDPOINTS = {
+  auth: '/lobehub-oidc/auth',
+  token: '/market/oidc/token',
+  userinfo: '/market/oidc/userinfo',
+  handoff: '/market/oidc/handoff',
+  desktopCallback: '/lobehub-oidc/callback/desktop',
+};
+
+export const MARKET_ENDPOINTS = {
+  base: '/market',
+  createAgent: '/market/agent/create',
+  getAgentDetail: (identifier: string) => `/market/agent/${encodeURIComponent(identifier)}`,
+  createAgentVersion: '/market/agent/versions/create',
+};

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

@@ -27,7 +27,7 @@ vi.stubGlobal(
 );
 
 // Mock image processing utilities
-vi.mock('@/utils/fetch', async (importOriginal) => {
+vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
   const module = await importOriginal();
 
   return { ...(module as any), getMessageError: vi.fn() };
@@ -988,7 +988,7 @@ describe('ChatService', () => {
 
     beforeEach(async () => {
       // Setup common fetchSSE mock for getChatCompletion tests
-      const { fetchSSE } = await import('@/utils/fetch');
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
       mockFetchSSE = vi.fn().mockResolvedValue(new Response('mock response'));
       vi.mocked(fetchSSE).mockImplementation(mockFetchSSE);
     });
@@ -1049,7 +1049,7 @@ describe('ChatService', () => {
 
     it('should return InvalidAccessCode error when enableFetchOnClient is true and auth is enabled but user is not signed in', async () => {
       // Mock fetchSSE to call onErrorHandle with the error
-      const { fetchSSE } = await import('@/utils/fetch');
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
 
       const mockFetchSSEWithError = vi.fn().mockImplementation((url, options) => {
         // Simulate the error being caught and passed to onErrorHandle
@@ -1211,8 +1211,8 @@ vi.mock('../_auth', async (importOriginal) => {
 describe('ChatService private methods', () => {
   describe('getChatCompletion', () => {
     it('should merge responseAnimation styles correctly', async () => {
-      const { fetchSSE } = await import('@/utils/fetch');
-      vi.mock('@/utils/fetch', async (importOriginal) => {
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
+      vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
         const module = await importOriginal();
         return {
           ...(module as any),

package/src/services/chat/clientModelRuntime.test.ts

@@ -38,7 +38,7 @@ vi.stubGlobal(
   vi.fn(() => Promise.resolve(new Response(JSON.stringify({ some: 'data' })))),
 );
 
-vi.mock('@/utils/fetch', async (importOriginal) => {
+vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
   const module = await importOriginal();
 
   return { ...(module as any), getMessageError: vi.fn() };

package/src/services/chat/index.ts

@@ -1,3 +1,9 @@
+import {
+  FetchSSEOptions,
+  fetchSSE,
+  getMessageError,
+  standardizeAnimationStyle,
+} from '@lobechat/fetch-sse';
 import { AgentRuntimeError, ChatCompletionErrorPayload } from '@lobechat/model-runtime';
 import { ChatErrorType, TracePayload, TraceTagMap, UIChatMessage } from '@lobechat/types';
 import { PluginRequestPayload, createHeadersWithPluginSettings } from '@lobehub/chat-plugin-sdk';
@@ -25,12 +31,6 @@ import {
 import type { ChatStreamPayload, OpenAIChatMessage } from '@/types/openai/chat';
 import { fetchWithInvokeStream } from '@/utils/electron/desktopRemoteRPCFetch';
 import { createErrorResponse } from '@/utils/errorResponse';
-import {
-  FetchSSEOptions,
-  fetchSSE,
-  getMessageError,
-  standardizeAnimationStyle,
-} from '@/utils/fetch';
 import { createTraceHeader, getTraceId } from '@/utils/trace';
 
 import { createHeaderWithAuth } from '../_auth';

package/src/services/chat/types.ts

@@ -1,7 +1,6 @@
+import { FetchSSEOptions } from '@lobechat/fetch-sse';
 import { TracePayload } from '@lobechat/types';
 
-import { FetchSSEOptions } from '@/utils/fetch';
-
 export interface FetchOptions extends FetchSSEOptions {
   historySummary?: string;
   signal?: AbortSignal | undefined;

package/src/services/discover.ts

@@ -7,6 +7,7 @@ import { useUserStore } from '@/store/user';
 import { preferenceSelectors } from '@/store/user/selectors';
 import {
   AssistantListResponse,
+  AssistantMarketSource,
   AssistantQueryParams,
   DiscoverAssistantDetail,
   DiscoverMcpDetail,
@@ -30,27 +31,37 @@ class DiscoverService {
   private _isRetrying = false;
 
   // ============================== Assistant Market ==============================
-  getAssistantCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+  getAssistantCategories = async (
+    params: CategoryListQuery & { source?: AssistantMarketSource } = {},
+  ): Promise<CategoryItem[]> => {
     const locale = globalHelpers.getCurrentLanguage();
+    const { source, ...rest } = params;
     return lambdaClient.market.getAssistantCategories.query({
-      ...params,
+      ...rest,
       locale,
+      source,
     });
   };
 
   getAssistantDetail = async (params: {
     identifier: string;
     locale?: string;
+    source?: AssistantMarketSource;
+    version?: string;
   }): Promise<DiscoverAssistantDetail | undefined> => {
     const locale = globalHelpers.getCurrentLanguage();
     return lambdaClient.market.getAssistantDetail.query({
-      ...params,
+      identifier: params.identifier,
       locale,
+      source: params.source,
+      version: params.version,
     });
   };
 
-  getAssistantIdentifiers = async (): Promise<IdentifiersResponse> => {
-    return lambdaClient.market.getAssistantIdentifiers.query();
+  getAssistantIdentifiers = async (
+    params: { source?: AssistantMarketSource } = {},
+  ): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getAssistantIdentifiers.query(params);
   };
 
   getAssistantList = async (params: AssistantQueryParams = {}): Promise<AssistantListResponse> => {

package/src/services/electron/remoteServer.ts

@@ -1,4 +1,4 @@
-import { DataSyncConfig, dispatch } from '@lobechat/electron-client-ipc';
+import { DataSyncConfig, MarketAuthorizationParams, dispatch } from '@lobechat/electron-client-ipc';
 
 class RemoteServerService {
   /**
@@ -28,6 +28,13 @@ class RemoteServerService {
   requestAuthorization = async (config: DataSyncConfig) => {
     return dispatch('requestAuthorization', config);
   };
+
+  /**
+   * 请求 Market 授权
+   */
+  requestMarketAuthorization = async (params: MarketAuthorizationParams) => {
+    return dispatch('requestMarketAuthorization', params);
+  };
 }
 
 export const remoteServerService = new RemoteServerService();

package/src/services/marketApi.ts

@@ -0,0 +1,124 @@
+import { AgentItemDetail } from '@lobehub/market-sdk';
+
+import { MARKET_ENDPOINTS } from '@/services/_url';
+
+export class MarketApiService {
+  private accessToken?: string;
+
+  // eslint-disable-next-line no-undef
+  private async request<T>(endpoint: string, init?: RequestInit): Promise<T> {
+    const headers = new Headers(init?.headers);
+
+    if (init?.body && !headers.has('content-type')) {
+      headers.set('content-type', 'application/json');
+    }
+
+    if (this.accessToken && !headers.has('authorization')) {
+      headers.set('authorization', `Bearer ${this.accessToken}`);
+    }
+
+    const response = await fetch(endpoint, {
+      ...init,
+      credentials: init?.credentials ?? 'same-origin',
+      headers,
+    });
+
+    if (!response.ok) {
+      let message = 'Unknown error';
+
+      try {
+        const errorBody = await response.json();
+        message = errorBody?.message ?? message;
+      } catch {
+        message = await response.text();
+      }
+
+      throw new Error(message || 'Market request failed');
+    }
+
+    if (response.status === 204) {
+      return undefined as T;
+    }
+
+    return (await response.json()) as T;
+  }
+
+  setAccessToken(token: string) {
+    this.accessToken = token;
+  }
+  // Create new agent
+  async createAgent(agentData: {
+    homepage?: string;
+    identifier: string;
+    isFeatured?: boolean;
+    name: string;
+    status?: 'published' | 'unpublished' | 'archived' | 'deprecated';
+    tokenUsage?: number;
+    visibility?: 'public' | 'private' | 'internal';
+  }): Promise<AgentItemDetail> {
+    return this.request(MARKET_ENDPOINTS.createAgent, {
+      body: JSON.stringify(agentData),
+      method: 'POST',
+    });
+  }
+
+  // Get agent detail by identifier
+  async getAgentDetail(identifier: string): Promise<AgentItemDetail> {
+    return this.request(MARKET_ENDPOINTS.getAgentDetail(identifier), {
+      method: 'GET',
+    });
+  }
+
+  // Check if agent exists (returns true if exists, false if not)
+  async checkAgentExists(identifier: string): Promise<boolean> {
+    try {
+      await this.getAgentDetail(identifier);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Create agent version
+  async createAgentVersion(versionData: {
+    a2aProtocolVersion?: string;
+    avatar?: string;
+    category?: string;
+    changelog?: string;
+    config?: Record<string, any>;
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+    description?: string;
+    documentationUrl?: string;
+    extensions?: Record<string, any>[];
+    hasPushNotifications?: boolean;
+    hasStateTransitionHistory?: boolean;
+    hasStreaming?: boolean;
+    identifier: string;
+    interfaces?: Record<string, any>[];
+    name?: string;
+    preferredTransport?: string;
+    providerId?: number;
+    securityRequirements?: Record<string, any>[];
+    securitySchemes?: Record<string, any>;
+    setAsCurrent?: boolean;
+    summary?: string;
+    supportsAuthenticatedExtendedCard?: boolean;
+    tokenUsage?: number;
+    url?: string;
+  }): Promise<AgentItemDetail> {
+    const { identifier, ...rest } = versionData;
+    const targetIdentifier = identifier;
+    if (!targetIdentifier) throw new Error('Identifier is required');
+
+    return this.request(MARKET_ENDPOINTS.createAgentVersion, {
+      body: JSON.stringify({
+        identifier: targetIdentifier,
+        ...rest,
+      }),
+      method: 'POST',
+    });
+  }
+}
+
+export const marketApiService = new MarketApiService();

package/src/services/message/index.ts

@@ -6,6 +6,7 @@ import {
   CreateMessageParams,
   CreateMessageResult,
   MessageMetadata,
+  MessagePluginItem,
   ModelRankItem,
   UIChatMessage,
   UpdateMessageParams,
@@ -77,8 +78,9 @@ export class MessageService {
   };
 
   updateMessageError = async (id: string, value: ChatMessageError) => {
-    const error = value.type ? value : { body: value, message: value.message, type: 'ApplicationRuntimeError' };
-
+    const error = value.type
+      ? value
+      : { body: value, message: value.message, type: 'ApplicationRuntimeError' };
 
     return lambdaClient.message.update.mutate({ id, value: { error } });
   };
@@ -153,6 +155,19 @@ export class MessageService {
     });
   };
 
+  updateMessagePlugin = async (
+    id: string,
+    value: Partial<Omit<MessagePluginItem, 'id'>>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.updateMessagePlugin.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      value,
+    });
+  };
+
   updateMessageRAG = async (
     id: string,
     data: UpdateMessageRAGParams,

package/src/services/models.ts

@@ -1,7 +1,8 @@
+import { getMessageError } from '@lobechat/fetch-sse';
+
 import { createHeaderWithAuth } from '@/services/_auth';
 import { aiProviderSelectors, getAiInfraStoreState } from '@/store/aiInfra';
 import { ChatModelCard } from '@/types/llm';
-import { getMessageError } from '@/utils/fetch';
 
 import { API_ENDPOINTS } from './_url';
 import { initializeWithClientStore } from './chat/clientModelRuntime';

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

@@ -9,20 +9,22 @@ import {
   GeneralAgentCallToolsBatchInstructionPayload,
   GeneralAgentCallingToolInstructionPayload,
   GeneralAgentConfig,
+  InterventionChecker,
 } from '@lobechat/agent-runtime';
+import type { ChatToolPayload, HumanInterventionConfig } from '@lobechat/types';
 
 /**
  * ChatAgent - The "Brain" of the chat agent
  *
  * This agent implements a simple but powerful decision loop:
  * 1. user_input → call_llm (with optional RAG/Search preprocessing)
- * 2. llm_result → check for tool_calls
- *    - If has tool_calls → call_tools_batch (parallel execution)
- *    - If no tool_calls → finish
+ * 2. llm_result → check for tool_calls and intervention requirements
+ *    - Tools not requiring intervention → call_tools_batch (execute immediately)
+ *    - Tools requiring intervention → request_human_approve (wait for approval)
+ *    - Mixed (both types) → [call_tools_batch, request_human_approve] (execute safe ones first, then request approval)
+ *    - No tool_calls → finish
  * 3. tools_batch_result → call_llm (process tool results)
  *
- * Note: RAG and Search workflow preprocessing are handled externally
- * before creating the agent runtime, keeping the agent logic simple.
  */
 export class GeneralChatAgent implements Agent {
   private config: GeneralAgentConfig;
@@ -31,6 +33,63 @@ export class GeneralChatAgent implements Agent {
     this.config = config;
   }
 
+  /**
+   * Get intervention configuration for a specific tool call
+   */
+  private getToolInterventionConfig(
+    toolCalling: ChatToolPayload,
+    state: AgentState,
+  ): HumanInterventionConfig | undefined {
+    const { identifier, apiName } = toolCalling;
+    const manifest = state.toolManifestMap[identifier];
+
+    if (!manifest) return undefined;
+
+    // Find the specific API in the manifest
+    const api = manifest.api?.find((a: any) => a.name === apiName);
+
+    // API-level config takes precedence over tool-level config
+    return api?.humanIntervention ?? manifest.humanIntervention;
+  }
+
+  /**
+   * Check if tool calls need human intervention
+   * Returns [toolsNeedingIntervention, toolsToExecute]
+   */
+  private checkInterventionNeeded(
+    toolsCalling: ChatToolPayload[],
+    state: AgentState,
+  ): [ChatToolPayload[], ChatToolPayload[]] {
+    const toolsNeedingIntervention: ChatToolPayload[] = [];
+    const toolsToExecute: ChatToolPayload[] = [];
+
+    for (const toolCalling of toolsCalling) {
+      const config = this.getToolInterventionConfig(toolCalling, state);
+
+      // Parse arguments for intervention checking
+      let toolArgs: Record<string, any> = {};
+      try {
+        toolArgs = JSON.parse(toolCalling.arguments || '{}');
+      } catch {
+        // Invalid JSON, treat as empty args
+      }
+
+      const policy = InterventionChecker.shouldIntervene({
+        config,
+        toolArgs,
+      });
+
+      if (policy === 'never') {
+        toolsToExecute.push(toolCalling);
+      } else {
+        // 'require' or 'first' (when not confirmed) requires intervention
+        toolsNeedingIntervention.push(toolCalling);
+      }
+    }
+
+    return [toolsNeedingIntervention, toolsToExecute];
+  }
+
   async runner(
     context: AgentRuntimeContext,
     state: AgentState,
@@ -55,26 +114,47 @@ export class GeneralChatAgent implements Agent {
           context.payload as GeneralAgentCallLLMResultPayload;
 
         if (hasToolsCalling && toolsCalling && toolsCalling.length > 0) {
-          // No intervention needed, proceed with tool execution
-          // Use batch execution for multiple tool calls to improve performance
-          if (toolsCalling.length > 1) {
-            return {
-              payload: {
-                parentMessageId,
-                toolsCalling,
-              } as GeneralAgentCallToolsBatchInstructionPayload,
-              type: 'call_tools_batch',
-            };
-          } else if (toolsCalling.length === 1) {
-            // Single tool executes directly
-            return {
-              payload: {
-                parentMessageId,
-                toolCalling: toolsCalling[0],
-              } as GeneralAgentCallingToolInstructionPayload,
-              type: 'call_tool',
-            };
+          // Check which tools need human intervention
+          const [toolsNeedingIntervention, toolsToExecute] = this.checkInterventionNeeded(
+            toolsCalling,
+            state,
+          );
+
+          const instructions: AgentInstruction[] = [];
+
+          // Execute tools that don't need intervention first
+          // These will run immediately before any approval requests
+          if (toolsToExecute.length > 0) {
+            if (toolsToExecute.length > 1) {
+              instructions.push({
+                payload: {
+                  parentMessageId,
+                  toolsCalling: toolsToExecute,
+                } as GeneralAgentCallToolsBatchInstructionPayload,
+                type: 'call_tools_batch',
+              });
+            } else {
+              instructions.push({
+                payload: {
+                  parentMessageId,
+                  toolCalling: toolsToExecute[0],
+                } as GeneralAgentCallingToolInstructionPayload,
+                type: 'call_tool',
+              });
+            }
+          }
+
+          // Request approval for tools that need intervention
+          // Runtime will execute this after safe tools and pause with status='waiting_for_human'
+          if (toolsNeedingIntervention.length > 0) {
+            instructions.push({
+              pendingToolsCalling: toolsNeedingIntervention,
+              reason: 'human_intervention_required',
+              type: 'request_human_approve',
+            });
           }
+
+          return instructions;
         }
 
         // No tool calls, conversation is complete
@@ -88,6 +168,24 @@ export class GeneralChatAgent implements Agent {
       case 'tool_result': {
         const { parentMessageId } = context.payload as GeneralAgentCallToolResultPayload;
 
+        // Check if there are still pending tool messages waiting for approval
+        const pendingToolMessages = state.messages.filter(
+          (m: any) => m.role === 'tool' && m.pluginIntervention?.status === 'pending',
+        );
+
+        // If there are pending tools, wait for human approval
+        if (pendingToolMessages.length > 0) {
+          const pendingTools = pendingToolMessages.map((m: any) => m.plugin).filter(Boolean);
+
+          return {
+            pendingToolsCalling: pendingTools,
+            reason: 'Some tools still pending approval',
+            skipCreateToolMessage: true,
+            type: 'request_human_approve',
+          };
+        }
+
+        // No pending tools, continue to call LLM with tool results
         return {
           payload: {
             messages: state.messages,
@@ -102,6 +200,25 @@ export class GeneralChatAgent implements Agent {
 
       case 'tools_batch_result': {
         const { parentMessageId } = context.payload as GeneralAgentCallToolResultPayload;
+
+        // Check if there are still pending tool messages waiting for approval
+        const pendingToolMessages = state.messages.filter(
+          (m: any) => m.role === 'tool' && m.pluginIntervention?.status === 'pending',
+        );
+
+        // If there are pending tools, wait for human approval
+        if (pendingToolMessages.length > 0) {
+          const pendingTools = pendingToolMessages.map((m: any) => m.plugin).filter(Boolean);
+
+          return {
+            pendingToolsCalling: pendingTools,
+            reason: 'Some tools still pending approval',
+            skipCreateToolMessage: true,
+            type: 'request_human_approve',
+          };
+        }
+
+        // No pending tools, continue to call LLM with tool results
         return {
           payload: {
             messages: state.messages,