@lobehub/chat 1.98.2 → 1.99.0

package/src/libs/standard-parameters/meta-schema.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  ModelParamsMetaSchema,
+  ModelParamsSchema,
+  type RuntimeImageGenParams,
+  extractDefaultValues,
+  validateModelParamsSchema,
+} from './meta-schema';
+
+describe('meta-schema', () => {
+  describe('ModelParamsMetaSchema', () => {
+    it('should validate a complete parameter schema', () => {
+      const validSchema: ModelParamsSchema = {
+        prompt: { default: 'test prompt' },
+        width: { default: 1024, min: 512, max: 2048, step: 64 },
+        height: { default: 1024, min: 512, max: 2048, step: 64 },
+        steps: { default: 20, min: 1, max: 50 },
+        seed: { default: null, min: 0 },
+        cfg: { default: 7.5, min: 1, max: 20, step: 0.5 },
+        aspectRatio: { default: '1:1', enum: ['1:1', '16:9', '4:3'] },
+        size: { default: '1024x1024', enum: ['512x512', '1024x1024', '1536x1536'] },
+        imageUrl: { default: null },
+        imageUrls: { default: [] },
+      };
+
+      expect(() => ModelParamsMetaSchema.parse(validSchema)).not.toThrow();
+    });
+
+    it('should validate minimal parameter schema with only prompt', () => {
+      const minimalSchema: ModelParamsSchema = {
+        prompt: { default: '' },
+      };
+
+      expect(() => ModelParamsMetaSchema.parse(minimalSchema)).not.toThrow();
+    });
+
+    it('should apply default values for optional properties', () => {
+      const schema: ModelParamsSchema = {
+        prompt: {},
+        width: { default: 1024, min: 512, max: 2048 },
+        seed: {},
+      };
+
+      const result = ModelParamsMetaSchema.parse(schema);
+
+      expect(result.prompt.default).toBe('');
+      expect(result.width?.step).toBe(1);
+      expect(result.seed?.default).toBeNull();
+      expect(result.seed?.min).toBe(0);
+    });
+
+    it('should reject invalid parameter schemas', () => {
+      const invalidSchema = {
+        prompt: { default: 123 }, // Should be string
+        width: { min: 'invalid' }, // Should be number
+      };
+
+      expect(() => ModelParamsMetaSchema.parse(invalidSchema)).toThrow();
+    });
+
+    it('should handle optional parameters correctly', () => {
+      const partialSchema: ModelParamsSchema = {
+        prompt: { default: 'test' },
+        width: { default: 512, min: 256, max: 1024 },
+      };
+
+      const result = ModelParamsMetaSchema.parse(partialSchema);
+      expect(result.prompt.default).toBe('test');
+      expect(result.width?.default).toBe(512);
+      expect(result.height).toBeUndefined();
+    });
+  });
+
+  describe('validateModelParamsSchema', () => {
+    it('should validate correct parameter schema', () => {
+      const schema = {
+        prompt: { default: 'test' },
+        width: { default: 1024, min: 512, max: 2048 },
+      };
+
+      expect(() => validateModelParamsSchema(schema)).not.toThrow();
+    });
+
+    it('should throw error for invalid parameter schema', () => {
+      const invalidSchema = {
+        prompt: { default: 123 }, // Invalid type
+      };
+
+      expect(() => validateModelParamsSchema(invalidSchema)).toThrow();
+    });
+
+    it('should handle unknown properties gracefully', () => {
+      const schemaWithExtra = {
+        prompt: { default: 'test' },
+        unknownParam: { default: 'value' },
+      };
+
+      // Should not throw since schema uses passthrough
+      expect(() => validateModelParamsSchema(schemaWithExtra)).not.toThrow();
+    });
+  });
+
+  describe('extractDefaultValues', () => {
+    it('should extract default values from parameter schema', () => {
+      const schema: ModelParamsSchema = {
+        prompt: { default: 'test prompt' },
+        width: { default: 1024, min: 512, max: 2048 },
+        height: { default: 768, min: 512, max: 2048 },
+        steps: { default: 20, min: 1, max: 50 },
+        seed: { default: null },
+      };
+
+      const result = extractDefaultValues(schema);
+
+      expect(result).toEqual({
+        prompt: 'test prompt',
+        width: 1024,
+        height: 768,
+        steps: 20,
+        seed: null,
+      });
+    });
+
+    it('should apply schema defaults for missing properties', () => {
+      const schema: ModelParamsSchema = {
+        prompt: {},
+        width: { default: 1024, min: 512, max: 2048 },
+        seed: {},
+      };
+
+      const result = extractDefaultValues(schema);
+
+      expect(result.prompt).toBe(''); // Schema default
+      expect(result.width).toBe(1024);
+      expect(result.seed).toBeNull(); // Schema default
+    });
+
+    it('should handle empty schema gracefully', () => {
+      const schema: ModelParamsSchema = {
+        prompt: { default: '' },
+      };
+
+      const result = extractDefaultValues(schema);
+
+      expect(result).toEqual({
+        prompt: '',
+      });
+    });
+
+    it('should preserve all parameter types correctly', () => {
+      const schema: ModelParamsSchema = {
+        prompt: { default: 'test' },
+        width: { default: 1024, min: 512, max: 2048 },
+        seed: { default: 12345 },
+        cfg: { default: 7.5, min: 1, max: 20, step: 0.5 },
+        aspectRatio: { default: '16:9', enum: ['1:1', '16:9', '4:3'] },
+        imageUrls: { default: ['test.jpg'] },
+        imageUrl: { default: 'test.jpg' },
+      };
+
+      const result = extractDefaultValues(schema);
+
+      expect(typeof result.prompt).toBe('string');
+      expect(typeof result.width).toBe('number');
+      expect(typeof result.seed).toBe('number');
+      expect(typeof result.cfg).toBe('number');
+      expect(typeof result.aspectRatio).toBe('string');
+      expect(Array.isArray(result.imageUrls)).toBe(true);
+      expect(typeof result.imageUrl).toBe('string');
+    });
+
+    it('should handle null values properly', () => {
+      const schema: ModelParamsSchema = {
+        prompt: { default: 'test' },
+        seed: { default: null },
+        imageUrl: { default: null },
+      };
+
+      const result = extractDefaultValues(schema);
+
+      expect(result.seed).toBeNull();
+      expect(result.imageUrl).toBeNull();
+    });
+  });
+
+  describe('Type inference', () => {
+    it('should infer correct RuntimeImageGenParams type', () => {
+      // This is a compile-time test to ensure types are correctly inferred
+      const params: RuntimeImageGenParams = {
+        prompt: 'test',
+        width: 1024,
+        height: 768,
+        steps: 20,
+        seed: null,
+        cfg: 7.5,
+      };
+
+      expect(params.prompt).toBe('test');
+      expect(params.width).toBe(1024);
+      expect(params.seed).toBeNull();
+    });
+
+    it('should require prompt but make other parameters optional', () => {
+      // This test ensures prompt is required while others are optional
+      const minimalParams: RuntimeImageGenParams = {
+        prompt: 'required prompt',
+      };
+
+      expect(minimalParams.prompt).toBe('required prompt');
+      expect(minimalParams.width).toBeUndefined();
+    });
+  });
+});

package/src/libs/standard-parameters/meta-schema.ts

@@ -0,0 +1,147 @@
+import type { Simplify } from 'type-fest';
+import { z } from 'zod';
+
+export const MAX_SEED = 2 ** 31 - 1;
+
+// 定义顶层的元规范 - 平铺结构
+export const ModelParamsMetaSchema = z.object({
+  aspectRatio: z
+    .object({
+      default: z.string(),
+      description: z.string().optional(),
+      enum: z.array(z.string()),
+      type: z.literal('string').optional(),
+    })
+    .optional(),
+
+  cfg: z
+    .object({
+      default: z.number(),
+      description: z.string().optional(),
+      max: z.number(),
+      min: z.number(),
+      step: z.number(),
+      type: z.literal('number').optional(),
+    })
+    .optional(),
+
+  height: z
+    .object({
+      default: z.number(),
+      description: z.string().optional(),
+      max: z.number(),
+      min: z.number(),
+      step: z.number().optional().default(1),
+      type: z.literal('number').optional(),
+    })
+    .optional(),
+
+  imageUrl: z
+    .object({
+      default: z.string().nullable().optional(),
+      description: z.string().optional(),
+      type: z.tuple([z.literal('string'), z.literal('null')]).optional(),
+    })
+    .optional(),
+
+  imageUrls: z
+    .object({
+      default: z.array(z.string()),
+      description: z.string().optional(),
+      type: z.literal('array').optional(),
+    })
+    .optional(),
+  /**
+   * Prompt 是唯一一个每个模型都有的参数
+   */
+  prompt: z.object({
+    default: z.string().optional().default(''),
+    description: z.string().optional(),
+    type: z.literal('string').optional(),
+  }),
+  seed: z
+    .object({
+      default: z.number().nullable().default(null),
+      description: z.string().optional(),
+      max: z.number().optional().default(MAX_SEED),
+      min: z.number().optional().default(0),
+      type: z.tuple([z.literal('number'), z.literal('null')]).optional(),
+    })
+    .optional(),
+  size: z
+    .object({
+      default: z.string(),
+      description: z.string().optional(),
+      enum: z.array(z.string()),
+      type: z.literal('string').optional(),
+    })
+    .optional(),
+  steps: z
+    .object({
+      default: z.number(),
+      description: z.string().optional(),
+      max: z.number(),
+      min: z.number(),
+      step: z.number().optional().default(1),
+      type: z.literal('number').optional(),
+    })
+    .optional(),
+  width: z
+    .object({
+      default: z.number(),
+      description: z.string().optional(),
+      max: z.number(),
+      min: z.number(),
+      step: z.number().optional().default(1),
+      type: z.literal('number').optional(),
+    })
+    .optional(),
+});
+// 导出推断出的类型，供定义对象使用
+export type ModelParamsSchema = z.input<typeof ModelParamsMetaSchema>;
+export type ModelParamsOutputSchema = z.output<typeof ModelParamsMetaSchema>;
+export type ModelParamsKeys = Simplify<keyof ModelParamsOutputSchema>;
+
+type TypeMapping<T> = T extends 'string'
+  ? string
+  : T extends 'number'
+    ? number
+    : T extends ['number', 'null']
+      ? number | null
+      : T extends ['string', 'null']
+        ? string | null
+        : T extends 'string'
+          ? string
+          : T extends 'boolean'
+            ? boolean
+            : never;
+type TypeType<K extends ModelParamsKeys> = NonNullable<ModelParamsOutputSchema[K]>['type'];
+type DefaultType<K extends ModelParamsKeys> = NonNullable<ModelParamsOutputSchema[K]>['default'];
+type _StandardImageGenerationParameters<P extends ModelParamsKeys = ModelParamsKeys> = {
+  [key in P]: NonNullable<TypeType<key>> extends 'array'
+    ? DefaultType<key>
+    : TypeMapping<TypeType<key>>;
+};
+
+export type RuntimeImageGenParams = Pick<_StandardImageGenerationParameters, 'prompt'> &
+  Partial<Omit<_StandardImageGenerationParameters, 'prompt'>>;
+export type RuntimeImageGenParamsKeys = keyof RuntimeImageGenParams;
+export type RuntimeImageGenParamsValue = RuntimeImageGenParams[RuntimeImageGenParamsKeys];
+
+// 验证函数
+export function validateModelParamsSchema(paramsSchema: unknown): ModelParamsOutputSchema {
+  return ModelParamsMetaSchema.parse(paramsSchema);
+}
+
+/**
+ * 从参数定义对象提取默认值
+ */
+export function extractDefaultValues(paramsSchema: ModelParamsSchema) {
+  // 部分默认值从 ModelParamsMetaSchema 中获取
+  const schemaWithDefault = ModelParamsMetaSchema.parse(paramsSchema);
+  return Object.fromEntries(
+    Object.entries(schemaWithDefault).map(([key, value]) => {
+      return [key, value.default];
+    }),
+  ) as RuntimeImageGenParams;
+}

package/src/libs/swr/index.ts

@@ -28,6 +28,7 @@ export const useClientDataSWR: SWRHook = (key, fetch, config) =>
     // we need to set it to 0.
     dedupingInterval: 0,
     focusThrottleInterval:
+      // FIXME: desktop 云同步模式也是走 edge 请求，也应该增大延迟
       // desktop 1.5s
       isDesktop
         ? 1500

package/src/libs/trpc/async/asyncAuth.ts

@@ -1,25 +1,46 @@
 import { TRPCError } from '@trpc/server';
+import debug from 'debug';
 
 import { serverDBEnv } from '@/config/db';
 import { UserModel } from '@/database/models/user';
-import { serverDB } from '@/database/server';
+import { LobeChatDatabase } from '@/database/type';
 
 import { asyncTrpc } from './init';
 
+const log = debug('lobe-async:auth');
+
 export const asyncAuth = asyncTrpc.middleware(async (opts) => {
   const { ctx } = opts;
 
+  log('Async auth middleware called for userId: %s', ctx.userId);
+  log('Secret validation: %s', ctx.secret === serverDBEnv.KEY_VAULTS_SECRET);
+
   if (ctx.secret !== serverDBEnv.KEY_VAULTS_SECRET || !ctx.userId) {
+    log('Async auth failed - invalid secret or missing userId');
+    log('Has secret: %s, Has userId: %s', !!ctx.secret, !!ctx.userId);
     throw new TRPCError({ code: 'UNAUTHORIZED' });
   }
 
-  const result = await UserModel.findById(serverDB, ctx.userId);
+  try {
+    log('Looking up user in database: %s', ctx.userId);
+    const result = await UserModel.findById(ctx.serverDB as LobeChatDatabase, ctx.userId);
 
-  if (!result) {
-    throw new TRPCError({ code: 'UNAUTHORIZED', message: 'user is invalid' });
-  }
+    if (!result) {
+      log('User not found in database: %s', ctx.userId);
+      throw new TRPCError({ code: 'UNAUTHORIZED', message: 'user is invalid' });
+    }
 
-  return opts.next({
-    ctx: { userId: ctx.userId },
-  });
+    log('User authentication successful: %s', ctx.userId);
+    log('Passing jwtPayload keys: %O', Object.keys(ctx.jwtPayload || {}));
+
+    return opts.next({
+      ctx: {
+        jwtPayload: ctx.jwtPayload,
+        userId: ctx.userId,
+      },
+    });
+  } catch (error) {
+    log('Database error during user lookup: %O', error);
+    throw error;
+  }
 });

package/src/libs/trpc/async/context.ts

@@ -1,11 +1,16 @@
+import debug from 'debug';
 import { NextRequest } from 'next/server';
 
 import { JWTPayload, LOBE_CHAT_AUTH_HEADER } from '@/const/auth';
+import { LobeChatDatabase } from '@/database/type';
 import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 
+const log = debug('lobe-async:context');
+
 export interface AsyncAuthContext {
   jwtPayload: JWTPayload;
   secret: string;
+  serverDB?: LobeChatDatabase;
   userId?: string | null;
 }
 
@@ -28,13 +33,46 @@ export type AsyncContext = Awaited<ReturnType<typeof createAsyncContextInner>>;
 export const createAsyncRouteContext = async (request: NextRequest): Promise<AsyncContext> => {
   // for API-response caching see https://trpc.io/docs/v11/caching
 
+  log('Creating async route context');
+
   const authorization = request.headers.get('Authorization');
   const lobeChatAuthorization = request.headers.get(LOBE_CHAT_AUTH_HEADER);
 
+  log('Authorization header present: %s', !!authorization);
+  log('LobeChat auth header present: %s', !!lobeChatAuthorization);
+
+  if (!authorization) {
+    log('No authorization header found');
+    throw new Error('No authorization header found');
+  }
+
+  if (!lobeChatAuthorization) {
+    log('No LobeChat authorization header found');
+    throw new Error('No LobeChat authorization header found');
+  }
+
   const secret = authorization?.split(' ')[1];
-  const gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
-  const { plaintext } = await gateKeeper.decrypt(lobeChatAuthorization || '');
+  log('Secret extracted from authorization header: %s', !!secret);
+
+  try {
+    log('Initializing KeyVaultsGateKeeper');
+    const gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
+
+    log('Decrypting LobeChat authorization');
+    const { plaintext } = await gateKeeper.decrypt(lobeChatAuthorization);
+
+    log('Parsing decrypted authorization data');
+    const { userId, payload } = JSON.parse(plaintext);
+
+    log(
+      'Successfully parsed authorization data - userId: %s, payload keys: %O',
+      userId,
+      Object.keys(payload || {}),
+    );
 
-  const { userId, payload } = JSON.parse(plaintext);
-  return createAsyncContextInner({ jwtPayload: payload, secret, userId });
+    return createAsyncContextInner({ jwtPayload: payload, secret, userId });
+  } catch (error) {
+    log('Error creating async route context: %O', error);
+    throw error;
+  }
 };

package/src/libs/trpc/async/index.ts

@@ -1,20 +1,33 @@
+import debug from 'debug';
+
 import { getServerDB } from '@/database/core/db-adaptor';
 
 import { asyncAuth } from './asyncAuth';
 import { asyncTrpc } from './init';
 
+const log = debug('lobe-async:middleware');
+
 export const publicProcedure = asyncTrpc.procedure;
 
 export const asyncRouter = asyncTrpc.router;
 
-export const asyncAuthedProcedure = asyncTrpc.procedure.use(asyncAuth).use(
-  asyncTrpc.middleware(async (opts) => {
+const dbMiddleware = asyncTrpc.middleware(async (opts) => {
+  log('Database middleware called');
+
+  try {
+    log('Getting server database connection');
     const serverDB = await getServerDB();
+    log('Database connection established successfully');
 
     return opts.next({
       ctx: { serverDB },
     });
-  }),
-);
+  } catch (error) {
+    log('Failed to establish database connection: %O', error);
+    throw error;
+  }
+});
+
+export const asyncAuthedProcedure = asyncTrpc.procedure.use(dbMiddleware).use(asyncAuth);
 
 export const createAsyncCallerFactory = asyncTrpc.createCallerFactory;

package/src/libs/trpc/async/init.ts

@@ -1,11 +1,19 @@
 import { initTRPC } from '@trpc/server';
+import debug from 'debug';
 import superjson from 'superjson';
 
 import { AsyncContext } from './context';
 
+const log = debug('lobe-async:init');
+
+log('Initializing async tRPC with context and superjson transformer');
+
 export const asyncTrpc = initTRPC.context<AsyncContext>().create({
   errorFormatter({ shape }) {
+    log('tRPC error formatter called: %O', shape);
     return shape;
   },
   transformer: superjson,
 });
+
+log('Async tRPC initialized successfully');

package/src/libs/trpc/client/lambda.ts

@@ -1,5 +1,6 @@
 import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import { createTRPCReact } from '@trpc/react-query';
+import debug from 'debug';
 import superjson from 'superjson';
 
 import { isDesktop } from '@/const/version';
@@ -8,6 +9,8 @@ import type { LambdaRouter } from '@/server/routers/lambda';
 
 import { ErrorResponse } from './types';
 
+const log = debug('lobe-image:lambda-client');
+
 const links = [
   httpBatchLink({
     fetch: async (input, init) => {
@@ -49,8 +52,22 @@ const links = [
       // dynamic import to avoid circular dependency
       const { createHeaderWithAuth } = await import('@/services/_auth');
 
-      // TODO: we need to support provider select
-      return createHeaderWithAuth({ provider: ModelProvider.OpenAI });
+      let provider: ModelProvider = ModelProvider.OpenAI;
+      // for image page, we need to get the provider from the store
+      log('Getting provider from store for image page: %s', location.pathname);
+      if (location.pathname === '/image') {
+        const { getImageStoreState } = await import('@/store/image');
+        const { imageGenerationConfigSelectors } = await import(
+          '@/store/image/slices/generationConfig/selectors'
+        );
+        provider = imageGenerationConfigSelectors.provider(getImageStoreState()) as ModelProvider;
+        log('Getting provider from store for image page: %s', provider);
+      }
+
+      // TODO: we need to support provider select for chat page
+      const headers = await createHeaderWithAuth({ provider });
+      log('Headers: %O', headers);
+      return headers;
     },
     maxURLLength: 2083,
     transformer: superjson,

package/src/locales/default/common.ts

@@ -186,6 +186,7 @@ export default {
   },
   fullscreen: '全屏模式',
   historyRange: '历史范围',
+  import: '导入',
   importData: '导入数据',
   importModal: {
     error: {
@@ -319,6 +320,7 @@ export default {
     unconnected: { tip: '信令服务器连接失败，将无法建立点对点通信频道，请检查网络后重试' },
   },
   tab: {
+    aiImage: 'AI 绘画',
     chat: '会话',
     discover: '发现',
     files: '文件',

package/src/locales/default/components.ts

@@ -70,6 +70,22 @@ export default {
   GoBack: {
     back: '返回',
   },
+  ImageUpload: {
+    actions: {
+      changeImage: '点击更换图片',
+    },
+    placeholder: {
+      primary: '添加图片',
+      secondary: '点击上传',
+    },
+  },
+  KeyValueEditor: {
+    addButton: '新增一行',
+    deleteTooltip: '删除',
+    duplicateKeyError: '键名必须唯一',
+    keyPlaceholder: '键',
+    valuePlaceholder: '值',
+  },
   MaxTokenSlider: {
     unlimited: '无限制',
   },
@@ -93,6 +109,25 @@ export default {
     provider: '服务商',
     title: '模型',
   },
+  MultiImagesUpload: {
+    actions: {
+      uploadMore: '点击上传更多',
+    },
+    modal: {
+      complete: '完成',
+      newFileIndicator: '新增',
+      selectImageToPreview: '请选择要预览的图片',
+      title: '管理图片 ({{count}})',
+      upload: '上传图片',
+    },
+    placeholder: {
+      primary: '点击上传图片',
+      secondary: '支持多张图片选择',
+    },
+    progress: {
+      uploadingWithCount: '{{completed}}/{{total}} 已上传',
+    },
+  },
   OllamaSetupGuide: {
     action: {
       close: '关闭提示',

package/src/locales/default/error.ts

@@ -151,6 +151,7 @@ export default {
   stt: {
     responseError: '服务请求失败，请检查配置或重试',
   },
+  testConnectionFailed: '测试连接失败：{{error}}',
   tts: {
     responseError: '服务请求失败，请检查配置或重试',
   },
@@ -158,6 +159,7 @@ export default {
     addProxyUrl: '添加 OpenAI 代理地址（可选）',
     apiKey: {
       description: '输入你的 {{name}} API Key 即可开始会话',
+      imageGenerationDescription: '输入你的 {{name}} API Key 即可开始生成',
       title: '使用自定义 {{name}} API Key',
     },
     closeMessage: '关闭提示',