@lobehub/chat 1.140.0 → 1.141.1

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

@@ -1,4 +1,10 @@
+import { marked } from 'marked';
+import PDFDocument from 'pdfkit';
+import { z } from 'zod';
+
 import { DrizzleMigrationModel } from '@/database/models/drizzleMigration';
+import { MessageModel } from '@/database/models/message';
+import { SessionModel } from '@/database/models/session';
 import { DataExporterRepos } from '@/database/repositories/dataExporter';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { serverDatabase } from '@/libs/trpc/lambda/middleware';
@@ -8,18 +14,182 @@ const exportProcedure = authedProcedure.use(serverDatabase).use(async (opts) =>
   const { ctx } = opts;
   const dataExporterRepos = new DataExporterRepos(ctx.serverDB, ctx.userId);
   const drizzleMigration = new DrizzleMigrationModel(ctx.serverDB);
+  const messageModel = new MessageModel(ctx.serverDB, ctx.userId);
+  const sessionModel = new SessionModel(ctx.serverDB, ctx.userId);
 
   return opts.next({
-    ctx: { dataExporterRepos, drizzleMigration },
+    ctx: { dataExporterRepos, drizzleMigration, messageModel, sessionModel },
   });
 });
 
+
+const REGULAR_FONT_URL =
+  'https://cdn.jsdelivr.net/gh/adobe-fonts/source-han-sans@2.004R/OTF/SimplifiedChinese/SourceHanSansSC-Regular.otf';
+
+let regularFontCache: Buffer | null = null;
+
+const loadRegularFont = async (): Promise<Buffer> => {
+  if (regularFontCache) return regularFontCache;
+
+  const response = await fetch(REGULAR_FONT_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch font from CDN: ${response.status} ${response.statusText}`);
+  }
+
+  const fontBuffer = Buffer.from(await response.arrayBuffer());
+  regularFontCache = fontBuffer;
+
+  return fontBuffer;
+};
+
+const generatePdfFromMarkdown = async (
+  markdownContent: string,
+  title?: string,
+): Promise<Buffer> => {
+  const regularFont = await loadRegularFont();
+
+  return new Promise((resolve, reject) => {
+    try {
+      const tokens = marked.lexer(markdownContent);
+
+      const doc = new PDFDocument({
+        bufferPages: true,
+        margins: {
+          bottom: 50,
+          left: 50,
+          right: 50,
+          top: 50,
+        },
+        size: 'A4',
+      });
+
+      const chunks: Buffer[] = [];
+
+      doc.registerFont('Regular', regularFont);
+      doc.font('Regular');
+
+      doc.on('data', (chunk: Buffer) => chunks.push(chunk));
+      doc.on('end', () => {
+        const pdfBuffer = Buffer.concat(chunks);
+        resolve(pdfBuffer);
+      });
+      doc.on('error', reject);
+
+      if (title) {
+        doc.fontSize(20).text(title, { align: 'center' });
+      }
+      doc.moveDown(2);
+
+      let currentY = doc.y;
+
+      for (const token of tokens) {
+        if (currentY > 700) {
+          doc.addPage();
+          currentY = 50;
+        }
+
+        switch (token.type) {
+          case 'heading': {
+            const headingSize = Math.max(16 - (token.depth - 1) * 2, 12);
+            doc.fontSize(headingSize).fillColor('#222').text(token.text, { continued: false });
+            doc.moveDown(0.5);
+            break;
+          }
+
+          case 'paragraph': {
+            doc.fontSize(12).fillColor('#333').text(token.text, { align: 'left', lineGap: 2 });
+            doc.moveDown(1);
+            break;
+          }
+
+          case 'list': {
+            for (const item of token.items) {
+              doc.fontSize(12).fillColor('#333').text(`• ${item.text}`, { indent: 20, lineGap: 2 });
+            }
+            doc.moveDown(1);
+            break;
+          }
+
+          case 'blockquote': {
+            doc.fontSize(12).fillColor('#666').text(token.text, { indent: 20, lineGap: 2 });
+            doc.moveDown(1);
+            break;
+          }
+
+          case 'code': {
+            doc.fontSize(10).fillColor('#333').text(token.text, {
+              continued: false,
+              indent: 20,
+              lineGap: 1,
+            });
+            doc.moveDown(1);
+            break;
+          }
+
+          case 'hr': {
+            doc.moveTo(50, doc.y).lineTo(545, doc.y).stroke();
+            doc.moveDown(1);
+            break;
+          }
+
+          default: {
+            if ('text' in token && token.text) {
+              doc.fontSize(12).fillColor('#333').text(token.text, { align: 'left', lineGap: 2 });
+              doc.moveDown(1);
+            }
+            break;
+          }
+        }
+
+        currentY = doc.y;
+      }
+
+      const pages = doc.bufferedPageRange();
+      for (let i = 0; i < pages.count; i++) {
+        doc.switchToPage(i);
+        doc
+          .fontSize(8)
+          .fillColor('#666')
+          .text(`Page ${i + 1} of ${pages.count}`, 50, 750, {
+            align: 'center',
+            width: 495,
+          });
+      }
+
+      // 完成文档
+      doc.end();
+    } catch (error) {
+      reject(
+        new Error(
+          `PDFKit PDF generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        ),
+      );
+    }
+  });
+};
+
 export const exporterRouter = router({
   exportData: exportProcedure.mutation(async ({ ctx }): Promise<ExportDatabaseData> => {
     const data = await ctx.dataExporterRepos.export(5);
-
     const schemaHash = await ctx.drizzleMigration.getLatestMigrationHash();
-
     return { data, schemaHash };
   }),
+
+  exportPdf: exportProcedure
+    .input(
+      z.object({
+        content: z.string(),
+        sessionId: z.string(),
+        title: z.string().optional(),
+        topicId: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      const { content, title } = input;
+      const pdfBuffer = await generatePdfFromMarkdown(content, title);
+      return {
+        filename: `${title}.pdf`,
+        pdf: pdfBuffer.toString('base64'),
+      };
+    }),
 });

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

@@ -198,6 +198,17 @@ export const messageRouter = router({
       await ctx.messageModel.updateMessageRAG(input.id, input.value);
     }),
 
+  updateMetadata: messageProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: z.object({}).passthrough(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.messageModel.updateMetadata(input.id, input.value);
+    }),
+
   updatePluginError: messageProcedure
     .input(
       z.object({

package/src/services/chat/contextEngineering.ts

@@ -1,6 +1,5 @@
 import { INBOX_GUIDE_SYSTEMROLE, INBOX_SESSION_ID, isDesktop, isServerMode } from '@lobechat/const';
 import {
-  type AgentState,
   ContextEngine,
   HistorySummaryProvider,
   HistoryTruncateProcessor,
@@ -122,14 +121,7 @@ export const contextEngineering = async ({
     ],
   });
 
-  const initialState: AgentState = { messages, model, provider, systemRole, tools };
-
-  const result = await pipeline.process({
-    initialState,
-    maxTokens: 10_000_000,
-    messages,
-    model,
-  });
+  const result = await pipeline.process({ messages });
 
   return result.messages;
 };

package/src/store/agent/slices/chat/selectors/agent.ts

@@ -1,16 +1,16 @@
-import { VoiceList } from '@lobehub/tts';
-
-import { INBOX_SESSION_ID } from '@/const/session';
 import {
   DEFAULT_AGENT_CONFIG,
   DEFAULT_MODEL,
   DEFAULT_PROVIDER,
   DEFAUTT_AGENT_TTS_CONFIG,
-} from '@/const/settings';
+  INBOX_SESSION_ID,
+} from '@lobechat/const';
+import { KnowledgeItem, KnowledgeType, LobeAgentConfig, LobeAgentTTSConfig } from '@lobechat/types';
+import { VoiceList } from '@lobehub/tts';
+
 import { DEFAULT_OPENING_QUESTIONS } from '@/features/AgentSetting/store/selectors';
+import { filterToolIds } from '@/helpers/toolFilters';
 import { AgentStoreState } from '@/store/agent/initialState';
-import { LobeAgentConfig, LobeAgentTTSConfig } from '@/types/agent';
-import { KnowledgeItem, KnowledgeType } from '@/types/knowledgeBase';
 import { merge } from '@/utils/merge';
 
 const isInboxSession = (s: AgentStoreState) => s.activeId === INBOX_SESSION_ID;
@@ -68,6 +68,15 @@ const currentAgentPlugins = (s: AgentStoreState) => {
   return config?.plugins || [];
 };
 
+/**
+ * Get displayable agent plugins by filtering out platform-specific tools
+ * that shouldn't be shown in the current environment
+ */
+const displayableAgentPlugins = (s: AgentStoreState) => {
+  const plugins = currentAgentPlugins(s);
+  return filterToolIds(plugins);
+};
+
 const currentAgentKnowledgeBases = (s: AgentStoreState) => {
   const config = currentAgentConfig(s);
 
@@ -172,6 +181,7 @@ export const agentSelectors = {
   currentAgentTTSVoice,
   currentEnabledKnowledge,
   currentKnowledgeIds,
+  displayableAgentPlugins,
   getAgentConfigByAgentId,
   getAgentConfigById,
   hasEnabledKnowledge,

package/src/store/global/initialState.ts

@@ -57,6 +57,7 @@ export interface SystemStatus {
   expandInputActionbar?: boolean;
   // which sessionGroup should expand
   expandSessionGroupKeys: string[];
+  fileManagerViewMode?: 'list' | 'masonry';
   filePanelWidth: number;
   hideGemini2_5FlashImagePreviewChineseWarning?: boolean;
   hidePWAInstaller?: boolean;
@@ -125,6 +126,7 @@ export const INITIAL_STATUS = {
   chatInputHeight: 64,
   expandInputActionbar: true,
   expandSessionGroupKeys: [SessionDefaultGroup.Pinned, SessionDefaultGroup.Default],
+  fileManagerViewMode: 'list' as const,
   filePanelWidth: 320,
   hideGemini2_5FlashImagePreviewChineseWarning: false,
   hidePWAInstaller: false,

package/src/store/tool/slices/builtin/selectors.ts

@@ -1,5 +1,7 @@
+import { LobeToolMeta } from '@lobechat/types';
+
+import { shouldEnableTool } from '@/helpers/toolFilters';
 import { DalleManifest } from '@/tools/dalle';
-import { LobeToolMeta } from '@/types/tool/tool';
 
 import type { ToolStoreState } from '../../initialState';
 
@@ -7,10 +9,18 @@ const metaList =
   (showDalle?: boolean) =>
   (s: ToolStoreState): LobeToolMeta[] =>
     s.builtinTools
-      .filter(
-        (item) =>
-          !item.hidden && (!showDalle ? item.identifier !== DalleManifest.identifier : true),
-      )
+      .filter((item) => {
+        // Filter hidden tools
+        if (item.hidden) return false;
+
+        // Filter Dalle if not enabled
+        if (!showDalle && item.identifier === DalleManifest.identifier) return false;
+
+        // Filter platform-specific tools (e.g., LocalSystem desktop-only)
+        if (!shouldEnableTool(item.identifier)) return false;
+
+        return true;
+      })
       .map((t) => ({
         author: 'LobeHub',
         identifier: t.identifier,