@lobehub/chat 1.98.2 → 1.99.0

package/src/locales/default/image.ts

@@ -0,0 +1,100 @@
+export default {
+  config: {
+    aspectRatio: {
+      label: '宽高比',
+      lock: '锁定宽高比',
+      unlock: '解锁宽高比',
+    },
+    header: {
+      desc: '简单描述，即刻创作',
+      title: '绘画',
+    },
+    height: {
+      label: '高度',
+    },
+    imageNum: {
+      label: '图片数量',
+    },
+    imageUrl: {
+      label: '参考图',
+    },
+    imageUrls: {
+      label: '参考图',
+    },
+    model: {
+      label: '模型',
+    },
+    prompt: {
+      placeholder: '描述你想要生成的内容',
+    },
+    seed: {
+      label: '种子',
+      random: '随机种子',
+    },
+    size: {
+      label: '尺寸',
+    },
+    steps: {
+      label: '步数',
+    },
+    title: 'AI 绘画',
+    width: {
+      label: '宽度',
+    },
+  },
+  generation: {
+    actions: {
+      applySeed: '应用种子',
+      copyError: '复制错误信息',
+      copyPrompt: '复制提示词',
+      copySeed: '复制种子',
+      delete: '删除',
+      deleteBatch: '删除批次',
+      download: '下载',
+      downloadFailed: '下载图片失败，请检查网络连接或 S3 存储服务的跨域配置',
+      errorCopied: '错误信息已复制到剪贴板',
+      errorCopyFailed: '复制错误信息失败',
+      generate: '生成',
+      promptCopied: '提示词已复制到剪贴板',
+      promptCopyFailed: '复制提示词失败',
+      reuseSettings: '复用设置',
+      seedApplied: '种子已应用到配置',
+      seedApplyFailed: '应用种子失败',
+      seedCopied: '种子已复制到剪贴板',
+      seedCopyFailed: '复制种子失败',
+    },
+    metadata: {
+      count: '{{count}} 张图片',
+    },
+    status: {
+      failed: '生成失败',
+      generating: '生成中...',
+    },
+  },
+  notSupportGuide: {
+    desc: '当前部署实例为客户端数据库模式，无法使用 AI 图像生成功能。请切换到<1>服务端数据库部署模式</1>，或直接使用 <3>LobeChat Cloud</3>',
+    features: {
+      fileIntegration: {
+        desc: '与文件管理系统深度整合，生成的图片自动保存到文件系统，支持统一管理和组织',
+        title: '文件系统互通',
+      },
+      llmAssisted: {
+        desc: '结合大语言模型能力，智能优化和扩展提示词，提升图像生成质量（Coming Soon）',
+        title: 'LLM 辅助生图',
+      },
+      multiProviders: {
+        desc: '支持多种 AI 绘画服务商，包括 OpenAI gpt-image-1、Google Imagen、FAL.ai 等，提供丰富的模型选择',
+        title: '多 Providers 支持',
+      },
+    },
+    title: '当前部署模式不支持 AI 绘画',
+  },
+  topic: {
+    createNew: '新建主题',
+    deleteConfirm: '删除生成主题',
+    deleteConfirmDesc: '即将删除该生成主题，删除后将不可恢复，请谨慎操作。',
+    empty: '暂无生成主题',
+    title: '绘画主题',
+    untitled: '默认主题',
+  },
+};

package/src/locales/default/index.ts

@@ -10,6 +10,7 @@ import electron from './electron';
 import error from './error';
 import file from './file';
 import hotkey from './hotkey';
+import image from './image';
 import knowledgeBase from './knowledgeBase';
 import metadata from './metadata';
 import migration from './migration';
@@ -39,6 +40,7 @@ const resources = {
   error,
   file,
   hotkey,
+  image,
   knowledgeBase,
   metadata,
   migration,

package/src/locales/default/metadata.ts

@@ -37,6 +37,10 @@ export default {
     search: '搜索',
     title: '发现',
   },
+  image: {
+    description: '{{appName}} 带给你最好的 GPT Image, Flux, Midjourney, Stable Diffusion 使用体验',
+    title: 'AI 绘画',
+  },
   plugins: {
     description:
       '搜素、图表生成、学术、图像生成、视频生成、语音生成、自动化工作流，定制 ChatGPT / Claude 专属的 ToolCall 插件能力',

package/src/locales/default/modelProvider.ts

@@ -68,6 +68,8 @@ export default {
       customSessionToken: '自定义 Session Token',
       description:
         '输入你的 AWS AccessKeyId / SecretAccessKey 即可开始会话。应用不会记录你的鉴权配置',
+      imageGenerationDescription:
+        '输入你的 AWS AccessKeyId / SecretAccessKey 即可开始生成。应用不会记录你的鉴权配置',
       title: '使用自定义 Bedrock 鉴权信息',
     },
   },

package/src/locales/default/plugin.ts

@@ -57,12 +57,28 @@ export default {
       },
     },
     mcp: {
+      advanced: {
+        title: '高级设置',
+      },
       args: {
         desc: '传递给执行命令的参数列表，一般在这里输入 MCP 服务器名称，或启动脚本路径',
         label: '命令参数',
         placeholder: '例如：mcp-hello-world',
         required: '请输入启动参数',
       },
+      auth: {
+        bear: 'API Key',
+        desc: '选择 MCP 服务器的认证方式',
+        label: '认证类型',
+        none: '无需认证',
+        placeholder: '请选择认证类型',
+        token: {
+          desc: '输入你的 API Key 或 Bearer Token',
+          label: 'API Key',
+          placeholder: 'sk-xxxxx',
+          required: '请输入认证令牌',
+        },
+      },
       avatar: {
         label: '插件图标',
       },
@@ -90,6 +106,11 @@ export default {
         label: 'MCP Server 环境变量',
         stringifyError: '无法序列化参数，请检查参数格式',
       },
+      headers: {
+        add: '新增一行',
+        desc: '输入请求头',
+        label: 'HTTP Headers',
+      },
       identifier: {
         desc: '为你的 MCP 插件指定一个名称，需要使用英文字符',
         invalid: '标识符只能包含字母、数字、连字符和下划线',
@@ -271,6 +292,7 @@ export default {
       showDetails: '查看详情',
     },
     errorTypes: {
+      AUTHORIZATION_ERROR: '授权验证错误',
       CONNECTION_FAILED: '连接失败',
       INITIALIZATION_TIMEOUT: '初始化超时',
       PROCESS_SPAWN_ERROR: '进程启动失败',

package/src/locales/default/setting.ts

@@ -488,6 +488,11 @@ export default {
       placeholder: '请输入自定义提示词',
       title: '自定义提示词',
     },
+    generationTopic: {
+      label: 'AI 绘画话题命名模型',
+      modelDesc: '指定用于 AI 绘画自动命名话题的模型',
+      title: 'AI 绘画自动命名话题',
+    },
     helpInfo: '当创建新助手时，将以默认助手设置作为预设值。',
     historyCompress: {
       label: '会话历史模型',

package/src/middleware.ts

@@ -37,6 +37,7 @@ export const config = {
     '/chat(.*)',
     '/changelog(.*)',
     '/settings(.*)',
+    '/image',
     '/files',
     '/files(.*)',
     '/repos(.*)',

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

@@ -1,4 +1,4 @@
-import { ElectronIpcClient } from '@lobechat/electron-server-ipc';
+import { CreateFileParams, ElectronIpcClient, FileMetadata } from '@lobechat/electron-server-ipc';
 
 import packageJSON from '@/../apps/desktop/package.json';
 
@@ -27,12 +27,20 @@ class LobeHubElectronIpcClient extends ElectronIpcClient {
     return this.sendRequest<string>('getStaticFilePath', id);
   };
 
+  getFileHTTPURL = async (path: string) => {
+    return this.sendRequest<string>('getFileHTTPURL', path);
+  };
+
   deleteFiles = async (paths: string[]) => {
     return this.sendRequest<{ errors?: { message: string; path: string }[]; success: boolean }>(
       'deleteFiles',
       paths,
     );
   };
+
+  createFile = async (params: CreateFileParams) => {
+    return this.sendRequest<{ metadata: FileMetadata; success: boolean }>('createFile', params);
+  };
 }
 
 export const electronIpcClient = new LobeHubElectronIpcClient(packageJSON.name);

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

@@ -9,6 +9,8 @@ import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { z } from 'zod';
 
 import { fileEnv } from '@/config/file';
+import { YEAR } from '@/utils/units';
+import { inferContentTypeFromImageUrl } from '@/utils/url';
 
 export const fileSchema = z.object({
   Key: z.string(),
@@ -142,4 +144,17 @@ export class S3 {
 
     return this.client.send(command);
   }
+
+  public async uploadMedia(key: string, buffer: Buffer) {
+    const command = new PutObjectCommand({
+      ACL: this.setAcl ? 'public-read' : undefined,
+      Body: buffer,
+      Bucket: this.bucket,
+      CacheControl: `public, max-age=${YEAR}`,
+      ContentType: inferContentTypeFromImageUrl(key)!,
+      Key: key,
+    });
+
+    await this.client.send(command);
+  }
 }

package/src/server/routers/async/caller.ts

@@ -1,4 +1,5 @@
 import { createTRPCClient, httpLink } from '@trpc/client';
+import debug from 'debug';
 import superjson from 'superjson';
 import urlJoin from 'url-join';
 
@@ -13,7 +14,11 @@ import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 import { asyncRouter } from './index';
 import type { AsyncRouter } from './index';
 
+const log = debug('lobe-image:async-caller');
+
 export const createAsyncServerClient = async (userId: string, payload: JWTPayload) => {
+  log('Creating async server client for userId: %s', userId);
+
   const gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
   const headers: Record<string, string> = {
     Authorization: `Bearer ${serverDBEnv.KEY_VAULTS_SECRET}`,
@@ -24,7 +29,7 @@ export const createAsyncServerClient = async (userId: string, payload: JWTPayloa
     headers['x-vercel-protection-bypass'] = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
   }
 
-  return createTRPCClient<AsyncRouter>({
+  const client = createTRPCClient<AsyncRouter>({
     links: [
       httpLink({
         headers,
@@ -33,6 +38,9 @@ export const createAsyncServerClient = async (userId: string, payload: JWTPayloa
       }),
     ],
   });
+
+  log('Async server client created successfully for userId: %s', userId);
+  return client;
 };
 
 /**

package/src/server/routers/async/image.ts

@@ -0,0 +1,253 @@
+import debug from 'debug';
+import { z } from 'zod';
+
+import { ASYNC_TASK_TIMEOUT, AsyncTaskModel } from '@/database/models/asyncTask';
+import { FileModel } from '@/database/models/file';
+import { GenerationModel } from '@/database/models/generation';
+import { AgentRuntimeErrorType } from '@/libs/model-runtime/error';
+import { RuntimeImageGenParams } from '@/libs/standard-parameters/meta-schema';
+import { asyncAuthedProcedure, asyncRouter as router } from '@/libs/trpc/async';
+import { initAgentRuntimeWithUserPayload } from '@/server/modules/AgentRuntime';
+import { GenerationService } from '@/server/services/generation';
+import { AsyncTaskError, AsyncTaskErrorType, AsyncTaskStatus } from '@/types/asyncTask';
+
+const log = debug('lobe-image:async');
+
+// Constants for better maintainability
+const FILENAME_MAX_LENGTH = 50;
+const IMAGE_URL_PREVIEW_LENGTH = 100;
+
+const imageProcedure = asyncAuthedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: {
+      asyncTaskModel: new AsyncTaskModel(ctx.serverDB, ctx.userId),
+      fileModel: new FileModel(ctx.serverDB, ctx.userId),
+      generationModel: new GenerationModel(ctx.serverDB, ctx.userId),
+      generationService: new GenerationService(ctx.serverDB, ctx.userId),
+    },
+  });
+});
+
+const createImageInputSchema = z.object({
+  generationId: z.string(),
+  model: z.string(),
+  params: z
+    .object({
+      cfg: z.number().optional(),
+      height: z.number().optional(),
+      imageUrls: z.array(z.string()).optional(),
+      prompt: z.string(),
+      seed: z.number().nullable().optional(),
+      steps: z.number().optional(),
+      width: z.number().optional(),
+    })
+    .passthrough(),
+  provider: z.string(),
+  taskId: z.string(),
+});
+
+/**
+ * Checks if the abort signal has been triggered and throws an error if so
+ */
+const checkAbortSignal = (signal: AbortSignal) => {
+  if (signal.aborted) {
+    throw new Error('Operation was aborted');
+  }
+};
+
+/**
+ * Categorizes errors into appropriate AsyncTaskErrorType
+ */
+const categorizeError = (
+  error: any,
+  isAborted: boolean,
+): { errorMessage: string; errorType: AsyncTaskErrorType } => {
+  // FIXME: 401 的问题应该放到 agentRuntime 中处理会更好
+  if (error.errorType === AgentRuntimeErrorType.InvalidProviderAPIKey || error?.status === 401) {
+    return {
+      errorMessage: 'Invalid provider API key, please check your API key',
+      errorType: AsyncTaskErrorType.InvalidProviderAPIKey,
+    };
+  }
+
+  if (error instanceof AsyncTaskError) {
+    return {
+      errorMessage: typeof error.body === 'string' ? error.body : error.body.detail,
+      errorType: error.name as AsyncTaskErrorType,
+    };
+  }
+
+  if (isAborted || error.message?.includes('aborted')) {
+    return {
+      errorMessage: 'Image generation task timed out, please try again',
+      errorType: AsyncTaskErrorType.Timeout,
+    };
+  }
+
+  if (error.message?.includes('timeout') || error.name === 'TimeoutError') {
+    return {
+      errorMessage: 'Image generation task timed out, please try again',
+      errorType: AsyncTaskErrorType.Timeout,
+    };
+  }
+
+  if (error.message?.includes('network') || error.name === 'NetworkError') {
+    return {
+      errorMessage: error.message || 'Network error occurred during image generation',
+      errorType: AsyncTaskErrorType.ServerError,
+    };
+  }
+
+  return {
+    errorMessage: error.message || 'Unknown error occurred during image generation',
+    errorType: AsyncTaskErrorType.ServerError,
+  };
+};
+
+export const imageRouter = router({
+  createImage: imageProcedure.input(createImageInputSchema).mutation(async ({ input, ctx }) => {
+    const { taskId, generationId, provider, model, params } = input;
+
+    log('Starting async image generation: %O', {
+      generationId,
+      imageParams: { height: params.height, steps: params.steps, width: params.width },
+      model,
+      prompt: params.prompt,
+      provider,
+      taskId,
+    });
+
+    log('Updating task status to Processing: %s', taskId);
+    await ctx.asyncTaskModel.update(taskId, { status: AsyncTaskStatus.Processing });
+
+    // Use AbortController to prevent resource leaks
+    const abortController = new AbortController();
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    try {
+      const imageGenerationPromise = async (signal: AbortSignal) => {
+        log('Initializing agent runtime for provider: %s', provider);
+        const agentRuntime = await initAgentRuntimeWithUserPayload(provider, ctx.jwtPayload);
+
+        // Check if operation has been cancelled
+        checkAbortSignal(signal);
+
+        log('Agent runtime initialized, calling createImage');
+        const response = await agentRuntime.createImage({
+          model,
+          params: params as unknown as RuntimeImageGenParams,
+        });
+
+        if (!response) {
+          log('Create image response is empty');
+          throw new Error('Create image response is empty');
+        }
+
+        // Check if operation has been cancelled
+        checkAbortSignal(signal);
+
+        log('Image generation successful: %O', {
+          height: response.height,
+          imageUrl: response.imageUrl.startsWith('data:')
+            ? response.imageUrl.slice(0, IMAGE_URL_PREVIEW_LENGTH) + '...'
+            : response.imageUrl,
+          width: response.width,
+        });
+
+        log('Transforming image for generation');
+        const { imageUrl, width, height } = response;
+        const { image, thumbnailImage } =
+          await ctx.generationService.transformImageForGeneration(imageUrl);
+
+        // Check if operation has been cancelled
+        checkAbortSignal(signal);
+
+        log('Uploading image for generation');
+        const { imageUrl: uploadedImageUrl, thumbnailImageUrl } =
+          await ctx.generationService.uploadImageForGeneration(image, thumbnailImage);
+
+        // Check if operation has been cancelled
+        checkAbortSignal(signal);
+
+        log('Updating generation asset and file');
+        await ctx.generationModel.createAssetAndFile(
+          generationId,
+          {
+            height: height ?? image.height,
+            originalUrl: imageUrl,
+            thumbnailUrl: thumbnailImageUrl,
+            type: 'image',
+            url: uploadedImageUrl,
+            width: width ?? image.width,
+          },
+          {
+            fileHash: image.hash,
+            fileType: image.mime,
+            metadata: {
+              generationId,
+              height: image.height,
+              width: image.width,
+            },
+            name: `${params.prompt.slice(0, FILENAME_MAX_LENGTH)}.${image.extension}`,
+            // Use first 50 characters of prompt as filename
+            size: image.size,
+            url: uploadedImageUrl,
+          },
+        );
+
+        log('Updating task status to Success: %s', taskId);
+        await ctx.asyncTaskModel.update(taskId, {
+          status: AsyncTaskStatus.Success,
+        });
+
+        log('Async image generation completed successfully: %s', taskId);
+        return { success: true };
+      };
+
+      // Set timeout to cancel operation and prevent resource leaks
+      timeoutId = setTimeout(() => {
+        log('Image generation timeout, aborting operation: %s', taskId);
+        abortController.abort();
+      }, ASYNC_TASK_TIMEOUT);
+
+      const result = await imageGenerationPromise(abortController.signal);
+
+      // Clean up timeout timer
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+
+      return result;
+    } catch (error: any) {
+      // Clean up timeout timer
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+
+      log('Async image generation failed: %O', {
+        error: error.message || error,
+        generationId,
+        taskId,
+      });
+
+      // Improved error categorization logic
+      const { errorType, errorMessage } = categorizeError(error, abortController.signal.aborted);
+
+      await ctx.asyncTaskModel.update(taskId, {
+        error: new AsyncTaskError(errorType, errorMessage),
+        status: AsyncTaskStatus.Error,
+      });
+
+      log('Task status updated to Error: %s, errorType: %s', taskId, errorType);
+
+      return {
+        message: `Image generation ${taskId} failed: ${errorMessage}`,
+        success: false,
+      };
+    }
+  }),
+});

package/src/server/routers/async/index.ts

@@ -1,11 +1,13 @@
 import { publicProcedure, asyncRouter as router } from '@/libs/trpc/async';
 
 import { fileRouter } from './file';
+import { imageRouter } from './image';
 import { ragEvalRouter } from './ragEval';
 
 export const asyncRouter = router({
   file: fileRouter,
   healthcheck: publicProcedure.query(() => "i'm live!"),
+  image: imageRouter,
   ragEval: ragEvalRouter,
 });
 

package/src/server/routers/lambda/aiProvider.test.ts

@@ -38,6 +38,7 @@ describe('aiProviderRouter', () => {
     enabledAiModels: [],
     enabledAiProviders: [],
     runtimeConfig: {},
+    enabledImageAiProviders: [],
   };
 
   beforeEach(() => {