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

package/src/hooks/useFetchAiImageConfig.ts

@@ -1,12 +1,26 @@
-import { useEffect } from 'react';
+import { useEffect, useMemo } from 'react';
 
 import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useGlobalStore } from '@/store/global';
 import { systemStatusSelectors } from '@/store/global/selectors';
 import { useImageStore } from '@/store/image';
+import {
+  DEFAULT_AI_IMAGE_MODEL,
+  DEFAULT_AI_IMAGE_PROVIDER,
+} from '@/store/image/slices/generationConfig/initialState';
 import { useUserStore } from '@/store/user';
 import { authSelectors } from '@/store/user/selectors';
 
+const checkModelEnabled = (
+  enabledImageModelList: ReturnType<typeof aiProviderSelectors.enabledImageModelList>,
+  provider: string,
+  model: string,
+) => {
+  return enabledImageModelList.some(
+    (p) => p.id === provider && p.children.some((m) => m.id === model),
+  );
+};
+
 export const useFetchAiImageConfig = () => {
   const isStatusInit = useGlobalStore(systemStatusSelectors.isStatusInit);
   const isInitAiProviderRuntimeState = useAiInfraStore(
@@ -29,16 +43,46 @@ export const useFetchAiImageConfig = () => {
   const isInitializedImageConfig = useImageStore((s) => s.isInit);
   const initializeImageConfig = useImageStore((s) => s.initializeImageConfig);
 
+  const enabledImageModelList = useAiInfraStore(aiProviderSelectors.enabledImageModelList);
+
+  // Determine which model/provider to use for initialization
+  const initParams = useMemo(() => {
+    // 1. Try lastSelected if enabled
+    if (
+      lastSelectedImageModel &&
+      lastSelectedImageProvider &&
+      checkModelEnabled(enabledImageModelList, lastSelectedImageProvider, lastSelectedImageModel)
+    ) {
+      return { model: lastSelectedImageModel, provider: lastSelectedImageProvider };
+    }
+
+    // 2. Try default model from any enabled provider (prefer default provider first)
+    if (
+      checkModelEnabled(enabledImageModelList, DEFAULT_AI_IMAGE_PROVIDER, DEFAULT_AI_IMAGE_MODEL)
+    ) {
+      return { model: undefined, provider: undefined }; // Use initialState defaults
+    }
+    const providerWithDefaultModel = enabledImageModelList.find((p) =>
+      p.children.some((m) => m.id === DEFAULT_AI_IMAGE_MODEL),
+    );
+    if (providerWithDefaultModel) {
+      return { model: DEFAULT_AI_IMAGE_MODEL, provider: providerWithDefaultModel.id };
+    }
+
+    // 3. Fallback to first enabled model
+    const firstProvider = enabledImageModelList[0];
+    const firstModel = firstProvider?.children[0];
+    if (firstProvider && firstModel) {
+      return { model: firstModel.id, provider: firstProvider.id };
+    }
+
+    // No enabled models
+    return { model: undefined, provider: undefined };
+  }, [lastSelectedImageModel, lastSelectedImageProvider, enabledImageModelList]);
+
   useEffect(() => {
     if (!isInitializedImageConfig && isReadyForInit) {
-      initializeImageConfig(isLogin, lastSelectedImageModel, lastSelectedImageProvider);
+      initializeImageConfig(isLogin, initParams.model, initParams.provider);
     }
-  }, [
-    isReadyForInit,
-    isInitializedImageConfig,
-    isLogin,
-    lastSelectedImageModel,
-    lastSelectedImageProvider,
-    initializeImageConfig,
-  ]);
+  }, [isReadyForInit, isInitializedImageConfig, isLogin, initParams, initializeImageConfig]);
 };

package/src/libs/trpc/utils/internalJwt.ts

@@ -66,7 +66,7 @@ const getVerificationKey = async () => {
 
 /**
  * Sign JWT for internal lambda → async calls
- * Uses JWKS private key with short expiration (3s)
+ * Uses JWKS private key with configurable expiration (default: 30s)
  * The JWT only proves the request is from lambda, payload is sent via LOBE_CHAT_AUTH_HEADER
  */
 export const signInternalJWT = async (): Promise<string> => {
@@ -75,7 +75,7 @@ export const signInternalJWT = async (): Promise<string> => {
   return new SignJWT({ purpose: INTERNAL_JWT_PURPOSE })
     .setProtectedHeader({ alg: 'RS256', kid })
     .setIssuedAt()
-    .setExpirationTime('3s')
+    .setExpirationTime(authEnv.INTERNAL_JWT_EXPIRATION)
     .sign(key);
 };
 

package/src/locales/default/file.ts

@@ -39,6 +39,7 @@ export default {
   'header.actions.notionGuide.title': 'Import from Notion',
   'header.actions.uploadFile': 'Upload File',
   'header.actions.uploadFolder': 'Upload Folder',
+  'header.actions.uploadFolder.creatingFolders': 'Creating folder structure...',
   'header.newPageButton': 'New Page',
   'header.uploadButton': 'Upload',
   'home.getStarted': 'Get Started',
@@ -129,6 +130,8 @@ export default {
   'title': 'Resources',
   'toggleLeftPanel': 'Show/Hide Left Panel',
   'uploadDock.body.collapse': 'Collapse',
+  'uploadDock.body.item.cancel': 'Cancel',
+  'uploadDock.body.item.cancelled': 'Cancelled',
   'uploadDock.body.item.done': 'Uploaded',
   'uploadDock.body.item.error': 'Upload failed, please try again',
   'uploadDock.body.item.pending': 'Preparing to upload...',
@@ -137,6 +140,7 @@ export default {
   'uploadDock.fileQueueInfo':
     'Uploading the first {{count}} files, {{remaining}} remaining in queue',
   'uploadDock.totalCount': 'Total {{count}} items',
+  'uploadDock.uploadStatus.cancelled': 'Upload cancelled',
   'uploadDock.uploadStatus.error': 'Upload error',
   'uploadDock.uploadStatus.pending': 'Waiting to upload',
   'uploadDock.uploadStatus.processing': 'Uploading',

package/src/locales/default/setting.ts

@@ -603,6 +603,9 @@ export default {
   'tools.klavis.servers': 'servers',
   'tools.klavis.tools': 'tools',
   'tools.klavis.verifyAuth': 'I have completed authentication',
+  'tools.lobehubSkill.authorize': 'Authorize',
+  'tools.lobehubSkill.connect': 'Connect',
+  'tools.lobehubSkill.error': 'Error',
   'tools.notInstalled': 'Not Installed',
   'tools.notInstalledWarning':
     'This skill is not currently installed, which may affect agent functionality.',

package/src/server/globalConfig/index.ts

@@ -76,6 +76,7 @@ export const getServerGlobalConfig = async () => {
     },
     enableEmailVerification: authEnv.AUTH_EMAIL_VERIFICATION,
     enableKlavis: !!klavisEnv.KLAVIS_API_KEY,
+    enableLobehubSkill: !!(appEnv.MARKET_TRUSTED_CLIENT_SECRET && appEnv.MARKET_TRUSTED_CLIENT_ID),
     enableMagicLink: authEnv.ENABLE_MAGIC_LINK,
     enableMarketTrustedClient: !!(
       appEnv.MARKET_TRUSTED_CLIENT_SECRET && appEnv.MARKET_TRUSTED_CLIENT_ID

package/src/server/modules/ModelRuntime/index.test.ts

@@ -26,7 +26,7 @@ import { ClientSecretPayload } from '@lobechat/types';
 import { ModelProvider } from 'model-bank';
 import { describe, expect, it, vi } from 'vitest';
 
-import { initModelRuntimeWithUserPayload } from './index';
+import { buildPayloadFromKeyVaults, initModelRuntimeWithUserPayload } from './index';
 
 // 模拟依赖项
 vi.mock('@/envs/llm', () => ({
@@ -496,3 +496,216 @@ describe('initModelRuntimeWithUserPayload method', () => {
     });
   });
 });
+
+/**
+ * Test cases for buildPayloadFromKeyVaults function
+ * This function builds ClientSecretPayload based on runtimeProvider (sdkType)
+ * to ensure provider-specific fields are correctly forwarded
+ */
+describe('buildPayloadFromKeyVaults', () => {
+  describe('should build payload with correct fields based on runtimeProvider', () => {
+    it('OpenAI compatible: returns apiKey, baseURL and runtimeProvider', () => {
+      const keyVaults = {
+        apiKey: 'test-api-key',
+        baseURL: 'https://custom-endpoint.com/v1',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.OpenAI);
+
+      expect(payload).toEqual({
+        apiKey: 'test-api-key',
+        baseURL: 'https://custom-endpoint.com/v1',
+        runtimeProvider: ModelProvider.OpenAI,
+      });
+    });
+
+    it('Azure: returns apiKey, baseURL, azureApiVersion and runtimeProvider', () => {
+      const keyVaults = {
+        apiKey: 'azure-api-key',
+        baseURL: 'https://my-azure.openai.azure.com',
+        apiVersion: '2024-06-01',
+        endpoint: 'https://fallback-endpoint.com',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Azure);
+
+      expect(payload).toEqual({
+        apiKey: 'azure-api-key',
+        azureApiVersion: '2024-06-01',
+        baseURL: 'https://my-azure.openai.azure.com',
+        runtimeProvider: ModelProvider.Azure,
+      });
+    });
+
+    it('Azure: uses endpoint as fallback when baseURL is not provided', () => {
+      const keyVaults = {
+        apiKey: 'azure-api-key',
+        endpoint: 'https://fallback-endpoint.com',
+        apiVersion: '2024-06-01',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Azure);
+
+      expect(payload.baseURL).toBe('https://fallback-endpoint.com');
+    });
+
+    it('Cloudflare: returns apiKey, cloudflareBaseURLOrAccountID and runtimeProvider', () => {
+      const keyVaults = {
+        apiKey: 'cloudflare-api-key',
+        baseURLOrAccountID: 'my-account-id',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Cloudflare);
+
+      expect(payload).toEqual({
+        apiKey: 'cloudflare-api-key',
+        cloudflareBaseURLOrAccountID: 'my-account-id',
+        runtimeProvider: ModelProvider.Cloudflare,
+      });
+    });
+
+    it('Bedrock: returns AWS credentials and runtimeProvider', () => {
+      const keyVaults = {
+        accessKeyId: 'aws-access-key',
+        secretAccessKey: 'aws-secret-key',
+        region: 'us-east-1',
+        sessionToken: 'session-token',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Bedrock);
+
+      expect(payload).toEqual({
+        apiKey: 'aws-secret-keyaws-access-key',
+        awsAccessKeyId: 'aws-access-key',
+        awsRegion: 'us-east-1',
+        awsSecretAccessKey: 'aws-secret-key',
+        awsSessionToken: 'session-token',
+        runtimeProvider: ModelProvider.Bedrock,
+      });
+    });
+
+    it('Ollama: returns baseURL and runtimeProvider', () => {
+      const keyVaults = {
+        baseURL: 'http://localhost:11434',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Ollama);
+
+      expect(payload).toEqual({
+        baseURL: 'http://localhost:11434',
+        runtimeProvider: ModelProvider.Ollama,
+      });
+    });
+
+    it('VertexAI: returns apiKey, baseURL, vertexAIRegion and runtimeProvider', () => {
+      const keyVaults = {
+        apiKey: 'vertex-credentials-json',
+        baseURL: 'https://vertex-endpoint.com',
+        region: 'us-central1',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.VertexAI);
+
+      expect(payload).toEqual({
+        apiKey: 'vertex-credentials-json',
+        baseURL: 'https://vertex-endpoint.com',
+        runtimeProvider: ModelProvider.VertexAI,
+        vertexAIRegion: 'us-central1',
+      });
+    });
+
+    it('ComfyUI: returns all auth fields and runtimeProvider', () => {
+      const keyVaults = {
+        apiKey: 'comfyui-api-key',
+        authType: 'bearer',
+        baseURL: 'http://localhost:8188',
+        customHeaders: { 'X-Custom': 'header' },
+        password: 'pass',
+        username: 'user',
+      } as const;
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.ComfyUI);
+
+      expect(payload).toEqual({
+        apiKey: 'comfyui-api-key',
+        authType: 'bearer',
+        baseURL: 'http://localhost:8188',
+        customHeaders: { 'X-Custom': 'header' },
+        password: 'pass',
+        runtimeProvider: ModelProvider.ComfyUI,
+        username: 'user',
+      });
+    });
+
+    it('Unknown provider: falls back to default with apiKey, baseURL and runtimeProvider', () => {
+      const keyVaults = {
+        apiKey: 'unknown-api-key',
+        baseURL: 'https://unknown-endpoint.com',
+      };
+      const payload = buildPayloadFromKeyVaults(keyVaults, 'unknown-provider');
+
+      expect(payload).toEqual({
+        apiKey: 'unknown-api-key',
+        baseURL: 'https://unknown-endpoint.com',
+        runtimeProvider: 'unknown-provider',
+      });
+    });
+  });
+
+  describe('custom provider with sdkType should include provider-specific fields', () => {
+    it('custom provider with Azure sdkType includes azureApiVersion', () => {
+      const keyVaults = {
+        apiKey: 'custom-azure-key',
+        baseURL: 'https://custom-azure.openai.azure.com',
+        apiVersion: '2024-06-01',
+      };
+      // Simulates a custom provider where runtimeProvider is resolved to 'azure'
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Azure);
+
+      expect(payload.azureApiVersion).toBe('2024-06-01');
+      expect(payload.runtimeProvider).toBe(ModelProvider.Azure);
+    });
+
+    it('custom provider with Cloudflare sdkType includes cloudflareBaseURLOrAccountID', () => {
+      const keyVaults = {
+        apiKey: 'custom-cloudflare-key',
+        baseURLOrAccountID: 'custom-account-id',
+      };
+      // Simulates a custom provider where runtimeProvider is resolved to 'cloudflare'
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Cloudflare);
+
+      expect(payload.cloudflareBaseURLOrAccountID).toBe('custom-account-id');
+      expect(payload.runtimeProvider).toBe(ModelProvider.Cloudflare);
+    });
+
+    it('custom provider with Bedrock sdkType includes AWS credentials', () => {
+      const keyVaults = {
+        accessKeyId: 'custom-aws-id',
+        secretAccessKey: 'custom-aws-secret',
+        region: 'eu-west-1',
+      };
+      // Simulates a custom provider where runtimeProvider is resolved to 'bedrock'
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Bedrock);
+
+      expect(payload.awsAccessKeyId).toBe('custom-aws-id');
+      expect(payload.awsSecretAccessKey).toBe('custom-aws-secret');
+      expect(payload.awsRegion).toBe('eu-west-1');
+      expect(payload.runtimeProvider).toBe(ModelProvider.Bedrock);
+    });
+
+    it('custom provider with Ollama sdkType includes baseURL', () => {
+      const keyVaults = {
+        baseURL: 'http://custom-ollama:11434',
+      };
+      // Simulates a custom provider where runtimeProvider is resolved to 'ollama'
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.Ollama);
+
+      expect(payload.baseURL).toBe('http://custom-ollama:11434');
+      expect(payload.runtimeProvider).toBe(ModelProvider.Ollama);
+    });
+
+    it('custom provider with VertexAI sdkType includes vertexAIRegion', () => {
+      const keyVaults = {
+        apiKey: 'custom-vertex-creds',
+        region: 'asia-northeast1',
+      };
+      // Simulates a custom provider where runtimeProvider is resolved to 'vertexai'
+      const payload = buildPayloadFromKeyVaults(keyVaults, ModelProvider.VertexAI);
+
+      expect(payload.vertexAIRegion).toBe('asia-northeast1');
+      expect(payload.runtimeProvider).toBe(ModelProvider.VertexAI);
+    });
+  });
+});

package/src/server/modules/ModelRuntime/index.ts

@@ -32,6 +32,24 @@ type ProviderKeyVaults = OpenAICompatibleKeyVault &
   ComfyUIKeyVault &
   VertexAIKeyVault;
 
+/**
+ * Resolve the runtime provider for a given provider.
+ *
+ * This is the server-side equivalent of the frontend's resolveRuntimeProvider function.
+ * For builtin providers, returns the provider as-is.
+ * For custom providers, returns the sdkType from settings (defaults to 'openai').
+ *
+ * @param provider - The provider id
+ * @param sdkType - The sdkType from provider settings
+ * @returns The resolved runtime provider
+ */
+const resolveRuntimeProvider = (provider: string, sdkType?: string): string => {
+  const isBuiltin = Object.values(ModelProvider).includes(provider as ModelProvider);
+  if (isBuiltin) return provider;
+
+  return sdkType || 'openai';
+};
+
 /**
  * Build ClientSecretPayload from keyVaults stored in database
  *
@@ -39,15 +57,21 @@ type ProviderKeyVaults = OpenAICompatibleKeyVault &
  * It converts the keyVaults object from database to the ClientSecretPayload format
  * expected by initModelRuntimeWithUserPayload.
  *
- * @param provider - The model provider
+ * For custom providers, we use runtimeProvider (sdkType) to determine which fields
+ * to include in the payload. This ensures that provider-specific fields like
+ * cloudflareBaseURLOrAccountID or azureApiVersion are correctly forwarded.
+ *
  * @param keyVaults - The keyVaults object from database (already decrypted)
+ * @param runtimeProvider - The runtime provider (sdkType) to use for building payload
  * @returns ClientSecretPayload for the provider
  */
 export const buildPayloadFromKeyVaults = (
-  provider: string,
   keyVaults: ProviderKeyVaults,
+  runtimeProvider: string,
 ): ClientSecretPayload => {
-  switch (provider) {
+  // Use runtimeProvider to determine which fields to include
+  // This handles both builtin providers and custom providers with sdkType
+  switch (runtimeProvider) {
     case ModelProvider.Bedrock: {
       const { accessKeyId, region, secretAccessKey, sessionToken } = keyVaults;
       const apiKey = (secretAccessKey || '') + (accessKeyId || '');
@@ -58,6 +82,7 @@ export const buildPayloadFromKeyVaults = (
         awsRegion: region,
         awsSecretAccessKey: secretAccessKey,
         awsSessionToken: sessionToken,
+        runtimeProvider,
       };
     }
 
@@ -66,17 +91,19 @@ export const buildPayloadFromKeyVaults = (
         apiKey: keyVaults.apiKey,
         azureApiVersion: keyVaults.apiVersion,
         baseURL: keyVaults.baseURL || keyVaults.endpoint,
+        runtimeProvider,
       };
     }
 
     case ModelProvider.Ollama: {
-      return { baseURL: keyVaults.baseURL };
+      return { baseURL: keyVaults.baseURL, runtimeProvider };
     }
 
     case ModelProvider.Cloudflare: {
       return {
         apiKey: keyVaults.apiKey,
         cloudflareBaseURLOrAccountID: keyVaults.baseURLOrAccountID,
+        runtimeProvider,
       };
     }
 
@@ -87,6 +114,7 @@ export const buildPayloadFromKeyVaults = (
         baseURL: keyVaults.baseURL,
         customHeaders: keyVaults.customHeaders,
         password: keyVaults.password,
+        runtimeProvider,
         username: keyVaults.username,
       };
     }
@@ -95,6 +123,7 @@ export const buildPayloadFromKeyVaults = (
       return {
         apiKey: keyVaults.apiKey,
         baseURL: keyVaults.baseURL,
+        runtimeProvider,
         vertexAIRegion: keyVaults.region,
       };
     }
@@ -103,6 +132,7 @@ export const buildPayloadFromKeyVaults = (
       return {
         apiKey: keyVaults.apiKey,
         baseURL: keyVaults.baseURL,
+        runtimeProvider,
       };
     }
   }
@@ -350,10 +380,16 @@ export const initModelRuntimeFromDB = async (
     KeyVaultsGateKeeper.getUserKeyVaults,
   );
 
-  // 2. Build ClientSecretPayload from keyVaults
+  // 2. Resolve the runtime provider for custom providers
+  // For custom providers, use sdkType from settings (defaults to 'openai')
+  const sdkType = providerConfig?.settings?.sdkType;
+  const runtimeProvider = resolveRuntimeProvider(provider, sdkType);
+
+  // 3. Build ClientSecretPayload from keyVaults based on runtimeProvider
+  // This ensures provider-specific fields (e.g., cloudflareBaseURLOrAccountID) are included
   const keyVaults = (providerConfig?.keyVaults || {}) as ProviderKeyVaults;
-  const payload = buildPayloadFromKeyVaults(provider, keyVaults);
+  const payload = buildPayloadFromKeyVaults(keyVaults, runtimeProvider);
 
-  // 3. Initialize ModelRuntime with the payload
+  // 4. Initialize ModelRuntime with the payload
   return initModelRuntimeWithUserPayload(provider, payload);
 };

package/src/server/routers/lambda/document.ts

@@ -55,6 +55,50 @@ export const documentRouter = router({
       });
     }),
 
+  createDocuments: documentProcedure
+    .input(
+      z.object({
+        documents: z.array(
+          z.object({
+            content: z.string().optional(),
+            editorData: z.string(),
+            fileType: z.string().optional(),
+            knowledgeBaseId: z.string().optional(),
+            metadata: z.record(z.any()).optional(),
+            parentId: z.string().optional(),
+            slug: z.string().optional(),
+            title: z.string(),
+          }),
+        ),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      // Process each document: resolve parentId and parse editorData
+      const processedDocuments = await Promise.all(
+        input.documents.map(async (doc) => {
+          // Resolve parentId if it's a slug
+          let resolvedParentId = doc.parentId;
+          if (doc.parentId) {
+            const docBySlug = await ctx.documentModel.findBySlug(doc.parentId);
+            if (docBySlug) {
+              resolvedParentId = docBySlug.id;
+            }
+          }
+
+          // Parse editorData from JSON string to object
+          const editorData = JSON.parse(doc.editorData);
+
+          return {
+            ...doc,
+            editorData,
+            parentId: resolvedParentId,
+          };
+        }),
+      );
+
+      return ctx.documentService.createDocuments(processedDocuments);
+    }),
+
   deleteDocument: documentProcedure
     .input(z.object({ id: z.string() }))
     .mutation(async ({ ctx, input }) => {