@lobehub/chat 1.99.6 → 1.100.1

package/src/server/globalConfig/genServerAiProviderConfig.ts

@@ -3,7 +3,7 @@ import { getLLMConfig } from '@/config/llm';
 import { ModelProvider } from '@/libs/model-runtime';
 import { AiFullModelCard } from '@/types/aiModel';
 import { ProviderConfig } from '@/types/user/settings';
-import { extractEnabledModels, transformToAiChatModelList } from '@/utils/parseModels';
+import { extractEnabledModels, transformToAiModelList } from '@/utils/parseModels';
 
 interface ProviderSpecificConfig {
   enabled?: boolean;
@@ -19,19 +19,17 @@ export const genServerAiProvidersConfig = (specificConfig: Record<any, ProviderS
   return Object.values(ModelProvider).reduce(
     (config, provider) => {
       const providerUpperCase = provider.toUpperCase();
-      const providerCard = AiModels[provider] as AiFullModelCard[];
+      const aiModels = AiModels[provider] as AiFullModelCard[];
 
-      if (!providerCard)
+      if (!aiModels)
         throw new Error(
           `Provider [${provider}] not found in aiModels, please make sure you have exported the provider in the \`aiModels/index.ts\``,
         );
 
       const providerConfig = specificConfig[provider as keyof typeof specificConfig] || {};
-      const providerModelList =
+      const modelString =
         process.env[providerConfig.modelListKey ?? `${providerUpperCase}_MODEL_LIST`];
 
-      const defaultChatModels = providerCard.filter((c) => c.type === 'chat');
-
       config[provider] = {
         enabled:
           typeof providerConfig.enabled !== 'undefined'
@@ -39,12 +37,13 @@ export const genServerAiProvidersConfig = (specificConfig: Record<any, ProviderS
             : llmConfig[providerConfig.enabledKey || `ENABLED_${providerUpperCase}`],
 
         enabledModels: extractEnabledModels(
-          providerModelList,
+          provider,
+          modelString,
           providerConfig.withDeploymentName || false,
         ),
-        serverModelLists: transformToAiChatModelList({
-          defaultChatModels: defaultChatModels || [],
-          modelString: providerModelList,
+        serverModelLists: transformToAiModelList({
+          defaultModels: aiModels || [],
+          modelString,
           providerId: provider,
           withDeploymentName: providerConfig.withDeploymentName || false,
         }),

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

@@ -1,4 +1,3 @@
-import { TRPCError } from '@trpc/server';
 import debug from 'debug';
 
 import { createContextForInteractionDetails } from '@/libs/oidc-provider/http-adapter';
@@ -20,76 +19,6 @@ export class OIDCService {
     return new OIDCService(provider);
   }
 
-  /**
-   * 验证 OIDC Bearer Token 并返回用户信息
-   * 使用 oidc-provider 实例的 AccessToken.find 方法验证 token
-   *
-   * @param token - Bearer Token
-   * @returns 包含用户ID和Token数据的对象
-   * @throws 如果token无效或OIDC未启用则抛出 TRPCError
-   */
-  async validateToken(token: string) {
-    try {
-      log('Validating access token using AccessToken.find');
-
-      // 使用 oidc-provider 的 AccessToken 查找和验证方法
-      const accessToken = await this.provider.AccessToken.find(token);
-
-      if (!accessToken) {
-        log('Access token not found, expired, or consumed');
-        throw new TRPCError({
-          code: 'UNAUTHORIZED',
-          message: 'Access token 无效、已过期或已被使用',
-        });
-      }
-
-      // 从 accessToken 实例中获取必要的数据
-      // 注意：accessToken 没有 payload() 方法，而是直接访问其属性
-      const userId = accessToken.accountId; // 用户 ID 通常存储在 accountId 属性中
-      const clientId = accessToken.clientId;
-
-      // 如果需要更多的声明信息，可以从 accessToken 的其他属性中获取
-      // 例如，scopes、claims、exp 等
-      const tokenData = {
-        client_id: clientId,
-        exp: accessToken.exp,
-        iat: accessToken.iat,
-        jti: accessToken.jti,
-        scope: accessToken.scope,
-        // OIDC 标准中，sub 字段表示用户 ID
-        sub: userId,
-      };
-
-      if (!userId) {
-        log('Access token does not contain user ID (accountId)');
-        throw new TRPCError({
-          code: 'UNAUTHORIZED',
-          message: 'Access token 中未包含用户 ID',
-        });
-      }
-
-      log('Access token validated successfully for user: %s', userId);
-      return {
-        // 包含 token 原始数据，可用于获取更多信息
-        accessToken,
-        // 构建的 token 数据对象
-        tokenData,
-        // 用户 ID
-        userId,
-      };
-    } catch (error) {
-      if (error instanceof TRPCError) throw error;
-
-      // AccessToken.find 可能抛出特定错误
-      log('Error validating access token with AccessToken.find: %O', error);
-      console.error('OIDC 令牌验证错误:', error);
-      throw new TRPCError({
-        code: 'UNAUTHORIZED',
-        message: `OIDC 认证失败: ${(error as Error).message}`,
-      });
-    }
-  }
-
   async getInteractionDetails(uid: string) {
     const { req, res } = await createContextForInteractionDetails(uid);
     return this.provider.interactionDetails(req, res);

package/src/services/chat.ts

@@ -40,6 +40,7 @@ import { ChatImageItem, ChatMessage, MessageToolCall } from '@/types/message';
 import type { ChatStreamPayload, OpenAIChatMessage } from '@/types/openai/chat';
 import { UserMessageContentPart } from '@/types/openai/chat';
 import { parsePlaceholderVariablesMessages } from '@/utils/client/parserPlaceholder';
+import { fetchWithInvokeStream } from '@/utils/electron/desktopRemoteRPCFetch';
 import { createErrorResponse } from '@/utils/errorResponse';
 import {
   FetchSSEOptions,
@@ -361,7 +362,10 @@ class ChatService {
 
     let fetcher: typeof fetch | undefined = undefined;
 
-    if (enableFetchOnClient) {
+    // Add desktop remote RPC fetch support
+    if (isDesktop) {
+      fetcher = fetchWithInvokeStream;
+    } else if (enableFetchOnClient) {
       /**
        * Notes:
        * 1. Browser agent runtime will skip auth check if a key and endpoint provided by

package/src/services/electron/remoteServer.ts

@@ -28,13 +28,6 @@ class RemoteServerService {
   requestAuthorization = async (config: DataSyncConfig) => {
     return dispatch('requestAuthorization', config);
   };
-
-  /**
-   * 刷新访问令牌
-   */
-  refreshAccessToken = async () => {
-    return dispatch('refreshAccessToken');
-  };
 }
 
 export const remoteServerService = new RemoteServerService();

package/src/store/aiInfra/slices/aiProvider/action.ts

@@ -19,6 +19,7 @@ import {
   UpdateAiProviderConfigParams,
   UpdateAiProviderParams,
 } from '@/types/aiProvider';
+import { getModelPropertyWithFallback } from '@/utils/getFallbackModelProperty';
 
 enum AiProviderSwrKey {
   fetchAiProviderItem = 'FETCH_AI_PROVIDER_ITEM',
@@ -216,7 +217,7 @@ export const createAiProviderSlice: StateCreator<
                 ...(model.type === 'image' && {
                   parameters:
                     (model as AIImageModelCard).parameters ||
-                    LOBE_DEFAULT_MODEL_LIST.find((m) => m.id === model.id)?.parameters,
+                    getModelPropertyWithFallback(model.id, 'parameters'),
                 }),
               }));
 

package/src/{libs/trpc/client/helpers → utils/electron}/desktopRemoteRPCFetch.ts

@@ -1,4 +1,4 @@
-import { ProxyTRPCRequestParams, dispatch } from '@lobechat/electron-client-ipc';
+import { ProxyTRPCRequestParams, dispatch, streamInvoke } from '@lobechat/electron-client-ipc';
 import debug from 'debug';
 
 import { isDesktop } from '@/const/version';
@@ -6,7 +6,7 @@ import { getElectronStoreState } from '@/store/electron';
 import { electronSyncSelectors } from '@/store/electron/selectors';
 import { getRequestBody, headersToRecord } from '@/utils/fetch';
 
-const log = debug('lobe-lambda:desktopRemoteRPCFetch');
+const log = debug('utils:desktopRemoteRPCFetch');
 
 // eslint-disable-next-line no-undef
 export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) => {
@@ -15,8 +15,8 @@ export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) =
 
   if (isSyncActive) {
     log('Using IPC proxy for tRPC request');
+    const url = input as string;
     try {
-      const url = input as string;
       const parsedUrl = new URL(url, window.location.origin);
       const urlPath = parsedUrl.pathname + parsedUrl.search;
       const method = init?.method?.toUpperCase() || 'GET';
@@ -32,7 +32,7 @@ export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) =
 
       const ipcResult = await dispatch('proxyTRPCRequest', params);
 
-      log('Received IPC proxy response:', { status: ipcResult.status });
+      log(`Received ${url} IPC proxy response:`, { status: ipcResult.status });
       const response = new Response(ipcResult.body, {
         headers: ipcResult.headers,
         status: ipcResult.status,
@@ -41,7 +41,7 @@ export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) =
 
       if (!response.ok) {
         console.warn(
-          '[lambda] IPC proxy response indicates an error:',
+          `[lambda] ${url} IPC proxy response indicates an error:`,
           response.status,
           response.statusText,
         );
@@ -49,7 +49,7 @@ export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) =
 
       return response;
     } catch (error) {
-      console.error('[lambda] Error during IPC proxy call:', error);
+      console.error(`[lambda] Error during ${url} IPC proxy call:`, error);
       return new Response(
         `IPC Proxy Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
         {
@@ -62,11 +62,26 @@ export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) =
 };
 
 // eslint-disable-next-line no-undef
-export const fetchWithDesktopRemoteRPC = async (input: string, init?: RequestInit) => {
+export const fetchWithDesktopRemoteRPC = (async (input: RequestInfo | URL, init?: RequestInit) => {
   if (isDesktop) {
     const res = await desktopRemoteRPCFetch(input as string, init);
     if (res) return res;
   }
 
+  return fetch(input, init);
+}) as typeof fetch;
+
+// eslint-disable-next-line no-undef
+export const fetchWithInvokeStream = async (input: RequestInfo | URL, init?: RequestInit) => {
+  if (isDesktop) {
+    const isSyncActive = electronSyncSelectors.isSyncActive(getElectronStoreState());
+    log('isSyncActive:', isSyncActive);
+    if (isSyncActive) {
+      log('Using IPC stream proxy for request to:', input);
+
+      return streamInvoke(input, init);
+    }
+  }
+
   return fetch(input, init);
 };

package/src/utils/getFallbackModelProperty.test.ts

@@ -0,0 +1,193 @@
+import { vi } from 'vitest';
+
+import { getModelPropertyWithFallback } from './getFallbackModelProperty';
+
+// Mock LOBE_DEFAULT_MODEL_LIST for testing
+vi.mock('@/config/aiModels', () => ({
+  LOBE_DEFAULT_MODEL_LIST: [
+    {
+      id: 'gpt-4',
+      providerId: 'openai',
+      type: 'chat',
+      displayName: 'GPT-4',
+      contextWindowTokens: 8192,
+      enabled: true,
+      abilities: {
+        functionCall: true,
+        vision: true,
+      },
+      parameters: {
+        temperature: 0.7,
+        maxTokens: 4096,
+      },
+    },
+    {
+      id: 'gpt-4',
+      providerId: 'azure',
+      type: 'chat',
+      displayName: 'GPT-4 Azure',
+      contextWindowTokens: 8192,
+      enabled: true,
+      abilities: {
+        functionCall: true,
+      },
+    },
+    {
+      id: 'claude-3',
+      providerId: 'anthropic',
+      type: 'chat',
+      displayName: 'Claude 3',
+      contextWindowTokens: 200000,
+      enabled: false,
+    },
+    {
+      id: 'dall-e-3',
+      providerId: 'openai',
+      type: 'image',
+      displayName: 'DALL-E 3',
+      enabled: true,
+      parameters: {
+        size: '1024x1024',
+        quality: 'standard',
+      },
+    },
+  ],
+}));
+
+describe('getModelPropertyWithFallback', () => {
+  describe('when providerId is specified', () => {
+    it('should return exact match value when model exists with specified provider', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'displayName', 'openai');
+      expect(result).toBe('GPT-4');
+    });
+
+    it('should return exact match type when model exists with specified provider', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'type', 'openai');
+      expect(result).toBe('chat');
+    });
+
+    it('should return exact match contextWindowTokens when model exists with specified provider', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'contextWindowTokens', 'azure');
+      expect(result).toBe(8192);
+    });
+
+    it('should fall back to other provider when exact provider match not found', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'displayName', 'fake-provider');
+      expect(result).toBe('GPT-4'); // Falls back to openai provider
+    });
+
+    it('should return nested property like abilities', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'abilities', 'openai');
+      expect(result).toEqual({
+        functionCall: true,
+        vision: true,
+      });
+    });
+
+    it('should return parameters property correctly', () => {
+      const result = getModelPropertyWithFallback('dall-e-3', 'parameters', 'openai');
+      expect(result).toEqual({
+        size: '1024x1024',
+        quality: 'standard',
+      });
+    });
+  });
+
+  describe('when providerId is not specified', () => {
+    it('should return fallback match value when model exists', () => {
+      const result = getModelPropertyWithFallback('claude-3', 'displayName');
+      expect(result).toBe('Claude 3');
+    });
+
+    it('should return fallback match type when model exists', () => {
+      const result = getModelPropertyWithFallback('claude-3', 'type');
+      expect(result).toBe('chat');
+    });
+
+    it('should return fallback match enabled property', () => {
+      const result = getModelPropertyWithFallback('claude-3', 'enabled');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('when model is not found', () => {
+    it('should return default value "chat" for type property', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'type');
+      expect(result).toBe('chat');
+    });
+
+    it('should return default value "chat" for type property even with providerId', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'type', 'fake-provider');
+      expect(result).toBe('chat');
+    });
+
+    it('should return undefined for non-type properties when model not found', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'displayName');
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for contextWindowTokens when model not found', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'contextWindowTokens');
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for enabled property when model not found', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'enabled');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('provider precedence logic', () => {
+    it('should prioritize exact provider match over general match', () => {
+      // gpt-4 exists in both openai and azure providers with different displayNames
+      const openaiResult = getModelPropertyWithFallback('gpt-4', 'displayName', 'openai');
+      const azureResult = getModelPropertyWithFallback('gpt-4', 'displayName', 'azure');
+
+      expect(openaiResult).toBe('GPT-4');
+      expect(azureResult).toBe('GPT-4 Azure');
+    });
+
+    it('should fall back to first match when specified provider not found', () => {
+      // When asking for 'fake-provider', should fall back to first match (openai)
+      const result = getModelPropertyWithFallback('gpt-4', 'displayName', 'fake-provider');
+      expect(result).toBe('GPT-4');
+    });
+  });
+
+  describe('property existence handling', () => {
+    it('should handle undefined properties gracefully', () => {
+      // claude-3 doesn't have abilities property defined
+      const result = getModelPropertyWithFallback('claude-3', 'abilities');
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle properties that exist but have falsy values', () => {
+      // claude-3 has enabled: false
+      const result = getModelPropertyWithFallback('claude-3', 'enabled');
+      expect(result).toBe(false);
+    });
+
+    it('should distinguish between undefined and null values', () => {
+      // Testing that we check for undefined specifically, not just falsy values
+      const result = getModelPropertyWithFallback('claude-3', 'contextWindowTokens');
+      expect(result).toBe(200000); // Should find the defined value
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty string modelId', () => {
+      const result = getModelPropertyWithFallback('', 'type');
+      expect(result).toBe('chat'); // Should fall back to default
+    });
+
+    it('should handle empty string providerId', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'type', '');
+      expect(result).toBe('chat'); // Should still find the model via fallback
+    });
+
+    it('should handle case-sensitive modelId correctly', () => {
+      const result = getModelPropertyWithFallback('GPT-4', 'type'); // Wrong case
+      expect(result).toBe('chat'); // Should fall back to default since no match
+    });
+  });
+});

package/src/utils/getFallbackModelProperty.ts

@@ -0,0 +1,36 @@
+import { LOBE_DEFAULT_MODEL_LIST } from '@/config/aiModels';
+import { AiFullModelCard } from '@/types/aiModel';
+
+/**
+ * Get the model property value, first from the specified provider, and then from other providers as a fallback.
+ * @param modelId The ID of the model.
+ * @param propertyName The name of the property.
+ * @param providerId Optional provider ID for an exact match.
+ * @returns The property value or a default value.
+ */
+export const getModelPropertyWithFallback = <T>(
+  modelId: string,
+  propertyName: keyof AiFullModelCard,
+  providerId?: string,
+): T => {
+  // Step 1: If providerId is provided, prioritize an exact match (same provider + same id)
+  if (providerId) {
+    const exactMatch = LOBE_DEFAULT_MODEL_LIST.find(
+      (m) => m.id === modelId && m.providerId === providerId,
+    );
+
+    if (exactMatch && exactMatch[propertyName] !== undefined) {
+      return exactMatch[propertyName] as T;
+    }
+  }
+
+  // Step 2: Fallback to a match ignoring the provider (match id only)
+  const fallbackMatch = LOBE_DEFAULT_MODEL_LIST.find((m) => m.id === modelId);
+
+  if (fallbackMatch && fallbackMatch[propertyName] !== undefined) {
+    return fallbackMatch[propertyName] as T;
+  }
+
+  // Step 3: Return a default value
+  return (propertyName === 'type' ? 'chat' : undefined) as T;
+};