@lobehub/lobehub 2.0.0-next.46 → 2.0.0-next.48

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/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/services/session/index.ts

@@ -4,14 +4,12 @@ import type { PartialDeep } from 'type-fest';
 import { lambdaClient } from '@/libs/trpc/client';
 import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
 import { MetaData } from '@/types/meta';
-import { BatchTaskResult } from '@/types/service';
 import {
   ChatSessionList,
   LobeAgentSession,
   LobeSessionType,
   LobeSessions,
   SessionGroupItem,
-  SessionGroups,
   SessionRankItem,
   UpdateSessionParams,
 } from '@/types/session';
@@ -114,18 +112,6 @@ export class SessionService {
     return lambdaClient.sessionGroup.createSessionGroup.mutate({ name, sort });
   };
 
-  getSessionGroups = (): Promise<SessionGroupItem[]> => {
-    return lambdaClient.sessionGroup.getSessionGroup.query();
-  };
-
-  /**
-   * 需要废弃
-   * @deprecated
-   */
-  batchCreateSessionGroups = (groups: SessionGroups): Promise<BatchTaskResult> => {
-    return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
-  };
-
   removeSessionGroup = (id: string, removeChildren?: boolean) => {
     return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
   };

package/src/store/discover/slices/assistant/action.ts

@@ -7,17 +7,24 @@ import { DiscoverStore } from '@/store/discover';
 import { globalHelpers } from '@/store/global/helpers';
 import {
   AssistantListResponse,
+  AssistantMarketSource,
   AssistantQueryParams,
   DiscoverAssistantDetail,
   IdentifiersResponse,
 } from '@/types/discover';
 
 export interface AssistantAction {
-  useAssistantCategories: (params: CategoryListQuery) => SWRResponse<CategoryItem[]>;
+  useAssistantCategories: (
+    params: CategoryListQuery & { source?: AssistantMarketSource },
+  ) => SWRResponse<CategoryItem[]>;
   useAssistantDetail: (params: {
     identifier: string;
+    source?: AssistantMarketSource;
+    version?: string;
   }) => SWRResponse<DiscoverAssistantDetail | undefined>;
-  useAssistantIdentifiers: () => SWRResponse<IdentifiersResponse>;
+  useAssistantIdentifiers: (params?: {
+    source?: AssistantMarketSource;
+  }) => SWRResponse<IdentifiersResponse>;
   useAssistantList: (params?: AssistantQueryParams) => SWRResponse<AssistantListResponse>;
 }
 
@@ -41,7 +48,9 @@ export const createAssistantSlice: StateCreator<
   useAssistantDetail: (params) => {
     const locale = globalHelpers.getCurrentLanguage();
     return useSWR(
-      ['assistant-details', locale, params.identifier].filter(Boolean).join('-'),
+      ['assistant-details', locale, params.identifier, params.version, params.source]
+        .filter(Boolean)
+        .join('-'),
       async () => discoverService.getAssistantDetail(params),
       {
         revalidateOnFocus: false,
@@ -49,10 +58,14 @@ export const createAssistantSlice: StateCreator<
     );
   },
 
-  useAssistantIdentifiers: () => {
-    return useSWR('assistant-identifiers', async () => discoverService.getAssistantIdentifiers(), {
-      revalidateOnFocus: false,
-    });
+  useAssistantIdentifiers: (params) => {
+    return useSWR(
+      ['assistant-identifiers', params?.source].filter(Boolean).join('-') || 'assistant-identifiers',
+      async () => discoverService.getAssistantIdentifiers(params),
+      {
+        revalidateOnFocus: false,
+      },
+    );
   },
 
   useAssistantList: (params = {}) => {

package/{packages/utils/src → src/utils}/electron/desktopRemoteRPCFetch.ts

@@ -1,10 +1,10 @@
 import { isDesktop } from '@lobechat/const';
 import { ProxyTRPCRequestParams, dispatch, streamInvoke } from '@lobechat/electron-client-ipc';
+import { getRequestBody, headersToRecord } from '@lobechat/fetch-sse';
 import debug from 'debug';
 
 import { getElectronStoreState } from '@/store/electron';
 import { electronSyncSelectors } from '@/store/electron/selectors';
-import { getRequestBody, headersToRecord } from '@/utils/fetch';
 
 const log = debug('utils:desktopRemoteRPCFetch');
 

package/{packages/utils/src → src/utils/server}/parseModels.ts

@@ -1,9 +1,8 @@
 import { getModelPropertyWithFallback } from '@lobechat/model-runtime';
+import { merge } from '@lobechat/utils';
 import { produce } from 'immer';
 import { AiFullModelCard, AiModelType } from 'model-bank';
 
-import { merge } from './merge';
-
 /**
  * Parse model string to add or remove models.
  */

package/src/utils/server/routeVariants.test.ts

@@ -0,0 +1,340 @@
+import { describe, expect, it } from 'vitest';
+
+import { DEFAULT_LANG } from '@/const/locale';
+import { DynamicLayoutProps } from '@/types/next';
+
+import { DEFAULT_VARIANTS, IRouteVariants, RouteVariants } from './routeVariants';
+
+describe('RouteVariants', () => {
+  describe('DEFAULT_VARIANTS', () => {
+    it('should have correct default values', () => {
+      expect(DEFAULT_VARIANTS).toEqual({
+        isMobile: false,
+        locale: DEFAULT_LANG,
+        theme: 'light',
+      });
+    });
+  });
+
+  describe('serializeVariants', () => {
+    it('should serialize variants with default values', () => {
+      const variants: IRouteVariants = {
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('en-US__0__light');
+    });
+
+    it('should serialize variants with mobile enabled', () => {
+      const variants: IRouteVariants = {
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('zh-CN__1__dark');
+    });
+
+    it('should serialize variants with different locales', () => {
+      const variants: IRouteVariants = {
+        isMobile: false,
+        locale: 'ja-JP',
+        theme: 'light',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('ja-JP__0__light');
+    });
+
+    it('should serialize variants with custom colors', () => {
+      const variants: IRouteVariants = {
+        isMobile: true,
+        locale: 'en-US',
+        neutralColor: '#cccccc',
+        primaryColor: '#ff0000',
+        theme: 'dark',
+      };
+      const result = RouteVariants.serializeVariants(variants);
+      expect(result).toBe('en-US__1__dark');
+    });
+  });
+
+  describe('deserializeVariants', () => {
+    it('should deserialize valid serialized string', () => {
+      const serialized = 'en-US__0__light';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      });
+    });
+
+    it('should deserialize mobile variants', () => {
+      const serialized = 'zh-CN__1__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      });
+    });
+
+    it('should return default values for invalid serialized string', () => {
+      const serialized = 'invalid';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should return default values for empty string', () => {
+      const serialized = '';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should handle invalid locale by falling back to default', () => {
+      const serialized = 'invalid-locale__0__light';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: DEFAULT_LANG,
+        theme: 'light',
+      });
+    });
+
+    it('should handle invalid theme by falling back to default', () => {
+      const serialized = 'en-US__0__invalid-theme';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      });
+    });
+
+    it('should handle malformed serialized string', () => {
+      const serialized = 'en-US';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should handle isMobile value correctly for "0"', () => {
+      const serialized = 'en-US__0__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result.isMobile).toBe(false);
+    });
+
+    it('should handle isMobile value correctly for "1"', () => {
+      const serialized = 'en-US__1__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result.isMobile).toBe(true);
+    });
+
+    it('should handle isMobile value correctly for other values', () => {
+      const serialized = 'en-US__2__dark';
+      const result = RouteVariants.deserializeVariants(serialized);
+      expect(result.isMobile).toBe(false);
+    });
+  });
+
+  describe('getVariantsFromProps', () => {
+    it('should extract and deserialize variants from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'en-US__0__light' }),
+      };
+      const result = await RouteVariants.getVariantsFromProps(props);
+      expect(result).toEqual({
+        isMobile: false,
+        locale: 'en-US',
+        theme: 'light',
+      });
+    });
+
+    it('should handle mobile variants from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'zh-CN__1__dark' }),
+      };
+      const result = await RouteVariants.getVariantsFromProps(props);
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      });
+    });
+
+    it('should handle invalid variants in props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid' }),
+      };
+      const result = await RouteVariants.getVariantsFromProps(props);
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+  });
+
+  describe('getIsMobile', () => {
+    it('should extract isMobile as false from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'en-US__0__light' }),
+      };
+      const result = await RouteVariants.getIsMobile(props);
+      expect(result).toBe(false);
+    });
+
+    it('should extract isMobile as true from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'en-US__1__dark' }),
+      };
+      const result = await RouteVariants.getIsMobile(props);
+      expect(result).toBe(true);
+    });
+
+    it('should return default isMobile for invalid props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid' }),
+      };
+      const result = await RouteVariants.getIsMobile(props);
+      expect(result).toBe(DEFAULT_VARIANTS.isMobile);
+    });
+  });
+
+  describe('getLocale', () => {
+    it('should extract locale from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'zh-CN__0__light' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe('zh-CN');
+    });
+
+    it('should extract different locale from props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'ja-JP__1__dark' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe('ja-JP');
+    });
+
+    it('should return default locale for invalid props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe(DEFAULT_LANG);
+    });
+
+    it('should return default locale for invalid locale in props', async () => {
+      const props: DynamicLayoutProps = {
+        params: Promise.resolve({ variants: 'invalid-locale__0__light' }),
+      };
+      const result = await RouteVariants.getLocale(props);
+      expect(result).toBe(DEFAULT_LANG);
+    });
+  });
+
+  describe('createVariants', () => {
+    it('should create variants with default values when no options provided', () => {
+      const result = RouteVariants.createVariants();
+      expect(result).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should create variants with custom isMobile', () => {
+      const result = RouteVariants.createVariants({ isMobile: true });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        isMobile: true,
+      });
+    });
+
+    it('should create variants with custom locale', () => {
+      const result = RouteVariants.createVariants({ locale: 'zh-CN' });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        locale: 'zh-CN',
+      });
+    });
+
+    it('should create variants with custom theme', () => {
+      const result = RouteVariants.createVariants({ theme: 'dark' });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        theme: 'dark',
+      });
+    });
+
+    it('should create variants with multiple custom options', () => {
+      const result = RouteVariants.createVariants({
+        isMobile: true,
+        locale: 'ja-JP',
+        theme: 'dark',
+      });
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'ja-JP',
+        theme: 'dark',
+      });
+    });
+
+    it('should create variants with custom colors', () => {
+      const result = RouteVariants.createVariants({
+        neutralColor: '#cccccc',
+        primaryColor: '#ff0000',
+      });
+      expect(result).toEqual({
+        ...DEFAULT_VARIANTS,
+        neutralColor: '#cccccc',
+        primaryColor: '#ff0000',
+      });
+    });
+
+    it('should create variants with all custom options', () => {
+      const result = RouteVariants.createVariants({
+        isMobile: true,
+        locale: 'zh-CN',
+        neutralColor: '#aaaaaa',
+        primaryColor: '#00ff00',
+        theme: 'dark',
+      });
+      expect(result).toEqual({
+        isMobile: true,
+        locale: 'zh-CN',
+        neutralColor: '#aaaaaa',
+        primaryColor: '#00ff00',
+        theme: 'dark',
+      });
+    });
+  });
+
+  describe('roundtrip serialization', () => {
+    it('should maintain data integrity through serialize and deserialize', () => {
+      const original: IRouteVariants = {
+        isMobile: true,
+        locale: 'zh-CN',
+        theme: 'dark',
+      };
+      const serialized = RouteVariants.serializeVariants(original);
+      const deserialized = RouteVariants.deserializeVariants(serialized);
+      expect(deserialized).toEqual(original);
+    });
+
+    it('should maintain data integrity for default variants', () => {
+      const serialized = RouteVariants.serializeVariants(DEFAULT_VARIANTS);
+      const deserialized = RouteVariants.deserializeVariants(serialized);
+      expect(deserialized).toEqual(DEFAULT_VARIANTS);
+    });
+
+    it('should maintain data integrity for various locales', () => {
+      const locales = ['en-US', 'zh-CN', 'ja-JP', 'ko-KR', 'fr-FR'];
+      locales.forEach((locale) => {
+        const original: IRouteVariants = {
+          isMobile: false,
+          locale: locale as any,
+          theme: 'light',
+        };
+        const serialized = RouteVariants.serializeVariants(original);
+        const deserialized = RouteVariants.deserializeVariants(serialized);
+        expect(deserialized).toEqual(original);
+      });
+    });
+  });
+});

package/vitest.config.mts

@@ -16,6 +16,8 @@ export default defineConfig({
       // TODO: after refactor the errorResponse, we can remove it
       '@/utils/errorResponse': resolve(__dirname, './src/utils/errorResponse'),
       '@/utils/unzipFile': resolve(__dirname, './src/utils/unzipFile'),
+      '@/utils/server': resolve(__dirname, './src/utils/server'),
+      '@/utils/electron': resolve(__dirname, './src/utils/electron'),
       '@/utils': resolve(__dirname, './packages/utils/src'),
       '@/types': resolve(__dirname, './packages/types/src'),
       '@/const': resolve(__dirname, './packages/const/src'),

package/packages/model-runtime/src/utils/imageToBase64.test.ts

@@ -1,91 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { imageToBase64, imageUrlToBase64 } from './imageToBase64';
-
-describe('imageToBase64', () => {
-  let mockImage: HTMLImageElement;
-  let mockCanvas: HTMLCanvasElement;
-  let mockContext: CanvasRenderingContext2D;
-
-  beforeEach(() => {
-    mockImage = {
-      width: 200,
-      height: 100,
-    } as HTMLImageElement;
-
-    mockContext = {
-      drawImage: vi.fn(),
-    } as unknown as CanvasRenderingContext2D;
-
-    mockCanvas = {
-      width: 0,
-      height: 0,
-      getContext: vi.fn().mockReturnValue(mockContext),
-      toDataURL: vi.fn().mockReturnValue('data:image/webp;base64,mockBase64Data'),
-    } as unknown as HTMLCanvasElement;
-
-    vi.spyOn(document, 'createElement').mockReturnValue(mockCanvas);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should convert image to base64 with correct size and type', () => {
-    const result = imageToBase64({ img: mockImage, size: 100, type: 'image/jpeg' });
-
-    expect(document.createElement).toHaveBeenCalledWith('canvas');
-    expect(mockCanvas.width).toBe(100);
-    expect(mockCanvas.height).toBe(100);
-    expect(mockCanvas.getContext).toHaveBeenCalledWith('2d');
-    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 50, 0, 100, 100, 0, 0, 100, 100);
-    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/jpeg');
-    expect(result).toBe('data:image/webp;base64,mockBase64Data');
-  });
-
-  it('should use default type when not specified', () => {
-    imageToBase64({ img: mockImage, size: 100 });
-    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/webp');
-  });
-
-  it('should handle taller images correctly', () => {
-    mockImage.width = 100;
-    mockImage.height = 200;
-    imageToBase64({ img: mockImage, size: 100 });
-    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 0, 50, 100, 100, 0, 0, 100, 100);
-  });
-});
-
-describe('imageUrlToBase64', () => {
-  const mockFetch = vi.fn();
-  const mockArrayBuffer = new ArrayBuffer(8);
-
-  beforeEach(() => {
-    global.fetch = mockFetch;
-    global.btoa = vi.fn().mockReturnValue('mockBase64String');
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should convert image URL to base64 string', async () => {
-    mockFetch.mockResolvedValue({
-      arrayBuffer: () => Promise.resolve(mockArrayBuffer),
-      blob: () => Promise.resolve(new Blob([mockArrayBuffer], { type: 'image/jpg' })),
-    });
-
-    const result = await imageUrlToBase64('https://example.com/image.jpg');
-
-    expect(mockFetch).toHaveBeenCalledWith('https://example.com/image.jpg');
-    expect(global.btoa).toHaveBeenCalled();
-    expect(result).toEqual({ base64: 'mockBase64String', mimeType: 'image/jpg' });
-  });
-
-  it('should throw an error when fetch fails', async () => {
-    const mockError = new Error('Fetch failed');
-    mockFetch.mockRejectedValue(mockError);
-
-    await expect(imageUrlToBase64('https://example.com/image.jpg')).rejects.toThrow('Fetch failed');
-  });
-});