@lobehub/lobehub 2.0.0-next.361 → 2.0.0-next.362

package/packages/context-engine/src/providers/__tests__/PageSelectionsInjector.test.ts

@@ -0,0 +1,333 @@
+import { describe, expect, it } from 'vitest';
+
+import type { PipelineContext } from '../../types';
+import { PageSelectionsInjector } from '../PageSelectionsInjector';
+
+describe('PageSelectionsInjector', () => {
+  const createContext = (messages: any[] = []): PipelineContext => ({
+    initialState: {
+      messages: [],
+      model: 'test-model',
+      provider: 'test-provider',
+    },
+    isAborted: false,
+    messages,
+    metadata: {
+      maxTokens: 4000,
+      model: 'test-model',
+    },
+  });
+
+  const createPageSelection = (id: string, xmlContent: string, pageId = 'page-1') => ({
+    content: xmlContent, // preview content
+    id,
+    pageId,
+    xml: xmlContent, // actual content used by formatPageSelections
+  });
+
+  describe('enabled/disabled', () => {
+    it('should skip injection when disabled', async () => {
+      const injector = new PageSelectionsInjector({ enabled: false });
+
+      const context = createContext([
+        {
+          content: 'Question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'Selected text')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.messages[0].content).toBe('Question');
+      expect(result.metadata.PageSelectionsInjectorInjectedCount).toBeUndefined();
+    });
+
+    it('should inject when enabled', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'Question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'Selected text')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.messages[0].content).toContain('Question');
+      expect(result.messages[0].content).toContain('<user_page_selections>');
+      expect(result.messages[0].content).toContain('Selected text');
+    });
+  });
+
+  describe('injection to every user message', () => {
+    it('should inject selections to each user message that has them', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'First question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'First selection')],
+          },
+          role: 'user',
+        },
+        { content: 'First answer', role: 'assistant' },
+        {
+          content: 'Second question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-2', 'Second selection')],
+          },
+          role: 'user',
+        },
+        { content: 'Second answer', role: 'assistant' },
+        {
+          content: 'Third question without selection',
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      // First user message should have first selection
+      expect(result.messages[0].content).toContain('First question');
+      expect(result.messages[0].content).toContain('First selection');
+      expect(result.messages[0].content).toContain('<user_page_selections>');
+
+      // Second user message should have second selection
+      expect(result.messages[2].content).toContain('Second question');
+      expect(result.messages[2].content).toContain('Second selection');
+      expect(result.messages[2].content).toContain('<user_page_selections>');
+
+      // Third user message should NOT have injection (no selections)
+      expect(result.messages[4].content).toBe('Third question without selection');
+
+      // Assistant messages should be unchanged
+      expect(result.messages[1].content).toBe('First answer');
+      expect(result.messages[3].content).toBe('Second answer');
+
+      // Metadata should show 2 injections
+      expect(result.metadata.PageSelectionsInjectorInjectedCount).toBe(2);
+    });
+
+    it('should skip user messages without pageSelections', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        { content: 'No selections here', role: 'user' },
+        { content: 'Answer', role: 'assistant' },
+        {
+          content: 'With selections',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'Some text')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.messages[0].content).toBe('No selections here');
+      expect(result.messages[2].content).toContain('With selections');
+      expect(result.messages[2].content).toContain('Some text');
+    });
+
+    it('should skip user messages with empty pageSelections array', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'Empty selections',
+          metadata: { pageSelections: [] },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.messages[0].content).toBe('Empty selections');
+    });
+  });
+
+  describe('SYSTEM CONTEXT wrapper', () => {
+    it('should wrap selection content with SYSTEM CONTEXT markers', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'Question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'Selected text')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+      const content = result.messages[0].content as string;
+
+      expect(content).toContain('<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->');
+      expect(content).toContain('<context.instruction>');
+      expect(content).toContain('<user_page_selections>');
+      expect(content).toContain('</user_page_selections>');
+      expect(content).toContain('<!-- END SYSTEM CONTEXT -->');
+    });
+
+    it('should have only one SYSTEM CONTEXT wrapper per message even with multiple selections', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'Question',
+          metadata: {
+            pageSelections: [
+              createPageSelection('sel-1', 'First selection'),
+              createPageSelection('sel-2', 'Second selection'),
+            ],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+      const content = result.messages[0].content as string;
+
+      const startCount = (content.match(/<!-- SYSTEM CONTEXT/g) || []).length;
+      const endCount = (content.match(/<!-- END SYSTEM CONTEXT/g) || []).length;
+
+      expect(startCount).toBe(1);
+      expect(endCount).toBe(1);
+    });
+
+    it('should create separate SYSTEM CONTEXT wrappers for each user message', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'First question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'First selection')],
+          },
+          role: 'user',
+        },
+        { content: 'Answer', role: 'assistant' },
+        {
+          content: 'Second question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-2', 'Second selection')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      // Each user message should have its own SYSTEM CONTEXT wrapper
+      const firstContent = result.messages[0].content as string;
+      const secondContent = result.messages[2].content as string;
+
+      expect(firstContent).toContain('<!-- SYSTEM CONTEXT');
+      expect(firstContent).toContain('First selection');
+
+      expect(secondContent).toContain('<!-- SYSTEM CONTEXT');
+      expect(secondContent).toContain('Second selection');
+    });
+  });
+
+  describe('multimodal messages', () => {
+    it('should handle array content with text parts', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: [
+            { text: 'Question with image', type: 'text' },
+            { image_url: { url: 'http://example.com/img.png' }, type: 'image_url' },
+          ],
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'Selected text')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.messages[0].content[0].text).toContain('Question with image');
+      expect(result.messages[0].content[0].text).toContain('Selected text');
+      expect(result.messages[0].content[0].text).toContain('<user_page_selections>');
+      expect(result.messages[0].content[1]).toEqual({
+        image_url: { url: 'http://example.com/img.png' },
+        type: 'image_url',
+      });
+    });
+  });
+
+  describe('integration with PageEditorContextInjector', () => {
+    it('should create wrapper that PageEditorContextInjector can reuse', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'Question about the page',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'Selected paragraph')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+      const content = result.messages[0].content as string;
+
+      // Verify the wrapper structure is correct for reuse
+      expect(content).toContain('<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->');
+      expect(content).toContain('<context.instruction>');
+      expect(content).toContain('<!-- END SYSTEM CONTEXT -->');
+
+      // Verify the content is in the right position (between instruction and end marker)
+      const instructionIndex = content.indexOf('</context.instruction>');
+      const selectionsIndex = content.indexOf('<user_page_selections>');
+      const endIndex = content.indexOf('<!-- END SYSTEM CONTEXT -->');
+
+      expect(instructionIndex).toBeLessThan(selectionsIndex);
+      expect(selectionsIndex).toBeLessThan(endIndex);
+    });
+  });
+
+  describe('metadata', () => {
+    it('should set metadata when injections are made', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([
+        {
+          content: 'Question',
+          metadata: {
+            pageSelections: [createPageSelection('sel-1', 'Text')],
+          },
+          role: 'user',
+        },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.metadata.PageSelectionsInjectorInjectedCount).toBe(1);
+    });
+
+    it('should not set metadata when no injections are made', async () => {
+      const injector = new PageSelectionsInjector({ enabled: true });
+
+      const context = createContext([{ content: 'No selections', role: 'user' }]);
+
+      const result = await injector.process(context);
+
+      expect(result.metadata.PageSelectionsInjectorInjectedCount).toBeUndefined();
+    });
+  });
+});

package/packages/context-engine/src/providers/index.ts

@@ -7,6 +7,7 @@ export { GTDTodoInjector } from './GTDTodoInjector';
 export { HistorySummaryProvider } from './HistorySummary';
 export { KnowledgeInjector } from './KnowledgeInjector';
 export { PageEditorContextInjector } from './PageEditorContextInjector';
+export { PageSelectionsInjector } from './PageSelectionsInjector';
 export { SystemRoleInjector } from './SystemRoleInjector';
 export { ToolSystemRoleProvider } from './ToolSystemRole';
 export { UserMemoryInjector } from './UserMemoryInjector';
@@ -27,11 +28,12 @@ export type {
   GroupContextInjectorConfig,
   GroupMemberInfo as GroupContextMemberInfo,
 } from './GroupContextInjector';
-export type { HistorySummaryConfig } from './HistorySummary';
 export type { GTDPlan, GTDPlanInjectorConfig } from './GTDPlanInjector';
 export type { GTDTodoInjectorConfig, GTDTodoItem, GTDTodoList } from './GTDTodoInjector';
+export type { HistorySummaryConfig } from './HistorySummary';
 export type { KnowledgeInjectorConfig } from './KnowledgeInjector';
 export type { PageEditorContextInjectorConfig } from './PageEditorContextInjector';
+export type { PageSelectionsInjectorConfig } from './PageSelectionsInjector';
 export type { SystemRoleInjectorConfig } from './SystemRoleInjector';
 export type { ToolSystemRoleConfig } from './ToolSystemRole';
 export type { UserMemoryInjectorConfig } from './UserMemoryInjector';

package/packages/prompts/src/agents/index.ts

@@ -1 +1,2 @@
 export * from './pageContentContext';
+export * from './pageSelectionContext';

package/packages/prompts/src/agents/pageSelectionContext.ts

@@ -0,0 +1,28 @@
+import type { PageSelection } from '@lobechat/types';
+
+/**
+ * Format page selections into a system prompt context
+ * Each selection is wrapped in a <selection> tag with metadata
+ */
+export const formatPageSelections = (selections: PageSelection[]): string => {
+  if (!selections || selections.length === 0) {
+    return '';
+  }
+
+  const formattedSelections = selections
+    .map((sel) => {
+      const lineInfo =
+        sel.startLine !== undefined
+          ? ` lines="${sel.startLine}-${sel.endLine ?? sel.startLine}"`
+          : '';
+
+      return `<selection ${lineInfo}>
+${sel.xml}
+</selection>`;
+    })
+    .join('\n');
+
+  return `<user_selections count="${selections.length}">
+${formattedSelections}
+</user_selections>`;
+};

package/packages/types/src/aiChat.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 
 import { UIChatMessage } from './message';
+import { PageSelection, PageSelectionSchema } from './message/ui/params';
 import { OpenAIChatMessage } from './openai/chat';
 import { LobeUniformTool, LobeUniformToolSchema } from './tool';
 import { ChatTopic } from './topic';
@@ -10,6 +11,8 @@ export interface SendNewMessage {
   content: string;
   // if message has attached with files, then add files to message and the agent
   files?: string[];
+  /** Page selections attached to this message (for Ask AI functionality) */
+  pageSelections?: PageSelection[];
   parentId?: string;
 }
 
@@ -83,6 +86,7 @@ export const AiSendMessageServerSchema = z.object({
   newUserMessage: z.object({
     content: z.string(),
     files: z.array(z.string()).optional(),
+    pageSelections: z.array(PageSelectionSchema).optional(),
     parentId: z.string().optional(),
   }),
   sessionId: z.string().optional(),

package/packages/types/src/message/common/index.ts

@@ -2,5 +2,6 @@ export * from './base';
 export * from './image';
 export * from './messageGroup';
 export * from './metadata';
+export * from './pageSelection';
 export * from './tools';
 export * from './translate';

package/packages/types/src/message/common/metadata.ts

@@ -1,6 +1,8 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix , typescript-sort-keys/interface */
 import { z } from 'zod';
 
+import { PageSelection, PageSelectionSchema } from './pageSelection';
+
 export interface ModelTokensUsage {
   // Input tokens breakdown
   /**
@@ -80,6 +82,7 @@ export const MessageMetadataSchema = ModelUsageSchema.merge(ModelPerformanceSche
   inspectExpanded: z.boolean().optional(),
   isMultimodal: z.boolean().optional(),
   isSupervisor: z.boolean().optional(),
+  pageSelections: z.array(PageSelectionSchema).optional(),
 });
 
 export interface ModelUsage extends ModelTokensUsage {
@@ -147,4 +150,9 @@ export interface MessageMetadata extends ModelUsage, ModelPerformance {
    */
   instruction?: string;
   taskTitle?: string;
+  /**
+   * Page selections attached to user message
+   * Used for Ask AI functionality to persist selection context
+   */
+  pageSelections?: PageSelection[];
 }

package/packages/types/src/message/common/pageSelection.ts

@@ -0,0 +1,36 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix , typescript-sort-keys/interface */
+import { z } from 'zod';
+
+/**
+ * Page selection represents a user-selected text region in a page/document.
+ * Used for Ask AI functionality to persist selection context with user messages.
+ */
+export interface PageSelection {
+  /** Selection unique identifier */
+  id: string;
+  anchor?: {
+    startNodeId: string;
+    endNodeId: string;
+    startOffset: number;
+    endOffset: number;
+  };
+  /** Selected content (plain text or markdown) */
+  content: string;
+  /** XML structure of the selected content (for positioning edits) */
+  xml?: string;
+  /** Page ID the selection belongs to */
+  pageId: string;
+  /** Start line number */
+  startLine?: number;
+  /** End line number */
+  endLine?: number;
+}
+
+export const PageSelectionSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  xml: z.string().optional(),
+  pageId: z.string(),
+  startLine: z.number().optional(),
+  endLine: z.number().optional(),
+});

package/packages/types/src/message/ui/params.ts

@@ -5,6 +5,8 @@ import { ConversationContext } from '../../conversation';
 import { UploadFileItem } from '../../files';
 import { MessageSemanticSearchChunk } from '../../rag';
 import { ChatMessageError, ChatMessageErrorSchema } from '../common/base';
+// Import for local use
+import type { PageSelection } from '../common/pageSelection';
 import { ChatPluginPayload, ToolInterventionSchema } from '../common/tools';
 import { UIChatMessage } from './chat';
 import { SemanticSearchChunkSchema } from './rag';
@@ -78,6 +80,10 @@ export interface ChatContextContent {
    */
   format?: 'xml' | 'text' | 'markdown';
   id: string;
+  /**
+   * Page ID the selection belongs to (for page editor selections)
+   */
+  pageId?: string;
   /**
    * Optional short preview for displaying in UI.
    */
@@ -86,6 +92,10 @@ export interface ChatContextContent {
   type: 'text';
 }
 
+// Re-export PageSelection from common for backwards compatibility
+export type { PageSelection } from '../common/pageSelection';
+export { PageSelectionSchema } from '../common/pageSelection';
+
 export interface SendMessageParams {
   /**
    * create a thread
@@ -119,8 +129,14 @@ export interface SendMessageParams {
   parentId?: string;
   /**
    * Additional contextual snippets (e.g., text selections) attached to the request.
+   * @deprecated Use pageSelections instead for page editor selections
    */
   contexts?: ChatContextContent[];
+  /**
+   * Page selections attached to the message (for Ask AI functionality)
+   * These will be persisted to the database and injected via context-engine
+   */
+  pageSelections?: PageSelection[];
 }
 
 export interface SendGroupMessageParams {

package/scripts/prebuild.mts

@@ -51,6 +51,7 @@ const checkRequiredEnvVars = () => {
       console.error(`    📖 Documentation: ${docUrl}\n`);
     }
     console.error('Please configure these environment variables and redeploy.');
+    console.error('\n💡 TIP: If you previously used NEXT_AUTH_SECRET, simply rename it to AUTH_SECRET.');
     console.error('═'.repeat(70) + '\n');
     process.exit(1);
   }

package/src/features/ChatInput/Desktop/ContextContainer/ContextList.tsx

@@ -30,7 +30,7 @@ const ContextList = memo(() => {
   const rawSelectionList = useFileStore(fileChatSelectors.chatContextSelections);
   const showSelectionList = useFileStore(fileChatSelectors.chatContextSelectionHasItem);
   const clearChatContextSelections = useFileStore((s) => s.clearChatContextSelections);
-
+  console.log(rawSelectionList);
   // Clear selections only when agentId changes (not on initial mount)
   useEffect(() => {
     if (prevAgentIdRef.current !== undefined && prevAgentIdRef.current !== agentId) {

package/src/features/Conversation/ChatInput/index.tsx

@@ -110,8 +110,16 @@ const ChatInput = memo<ChatInputProps>(
         fileStore.clearChatUploadFileList();
         fileStore.clearChatContextSelections();
 
+        // Convert ChatContextContent to PageSelection for persistence
+        const pageSelections = currentContextList.map((ctx) => ({
+          content: ctx.preview || '',
+          id: ctx.id,
+          pageId: ctx.pageId || '',
+          xml: ctx.content,
+        }));
+
         // Fire and forget - send with captured message
-        await sendMessage({ contexts: currentContextList, files: currentFileList, message });
+        await sendMessage({ files: currentFileList, message, pageSelections });
       },
       [isAIGenerating, sendMessage],
     );

package/src/features/Conversation/Messages/User/components/MessageContent.tsx

@@ -7,13 +7,19 @@ import { type UIChatMessage } from '@/types/index';
 import { useMarkdown } from '../useMarkdown';
 import FileListViewer from './FileListViewer';
 import ImageFileListViewer from './ImageFileListViewer';
+import PageSelections from './PageSelections';
 import VideoFileListViewer from './VideoFileListViewer';
 
 const UserMessageContent = memo<UIChatMessage>(
-  ({ id, content, imageList, videoList, fileList }) => {
+  ({ id, content, imageList, videoList, fileList, metadata }) => {
     const markdownProps = useMarkdown(id);
+    const pageSelections = metadata?.pageSelections;
+
     return (
       <Flexbox gap={8} id={id}>
+        {pageSelections && pageSelections.length > 0 && (
+          <PageSelections selections={pageSelections} />
+        )}
         {content && <MarkdownMessage {...markdownProps}>{content}</MarkdownMessage>}
         {imageList && imageList?.length > 0 && <ImageFileListViewer items={imageList} />}
         {videoList && videoList?.length > 0 && <VideoFileListViewer items={videoList} />}

package/src/features/Conversation/Messages/User/components/PageSelections.tsx

@@ -0,0 +1,62 @@
+import { Flexbox } from '@lobehub/ui';
+import { createStaticStyles } from 'antd-style';
+import { memo } from 'react';
+
+import type { PageSelection } from '@/types/index';
+
+const styles = createStaticStyles(({ css, cssVar }) => ({
+  container: css`
+    cursor: pointer;
+    position: relative;
+    border-radius: 8px;
+
+    :hover {
+      background: ${cssVar.colorFillQuaternary};
+    }
+  `,
+  content: css`
+    overflow: hidden;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 3;
+
+    font-size: 12px;
+    line-height: 1.5;
+    color: ${cssVar.colorTextSecondary};
+    white-space: pre-wrap;
+  `,
+  quote: css`
+    inset-block-start: 2px;
+    inset-inline-start: 0;
+
+    font-family: Georgia, serif;
+    font-size: 28px;
+    line-height: 1;
+    color: ${cssVar.colorTextQuaternary};
+  `,
+  wrapper: css``,
+}));
+
+interface PageSelectionsProps {
+  selections: PageSelection[];
+}
+
+const PageSelections = memo<PageSelectionsProps>(({ selections }) => {
+  if (!selections || selections.length === 0) return null;
+
+  return (
+    <Flexbox gap={8}>
+      {selections.map((selection) => (
+        <Flexbox className={styles.container} key={selection.id}>
+          <Flexbox className={styles.wrapper} gap={4} horizontal padding={4}>
+            {/* eslint-disable-next-line react/no-unescaped-entities */}
+            <span className={styles.quote}>"</span>
+            <div className={styles.content}>{selection.content}</div>
+          </Flexbox>
+        </Flexbox>
+      ))}
+    </Flexbox>
+  );
+});
+
+export default PageSelections;

package/src/features/PageEditor/EditorCanvas/useAskCopilotItem.tsx

@@ -12,6 +12,8 @@ import { useTranslation } from 'react-i18next';
 import { useFileStore } from '@/store/file';
 import { useGlobalStore } from '@/store/global';
 
+import { usePageEditorStore } from '../store';
+
 const styles = createStaticStyles(({ css }) => ({
   askCopilot: css`
     border-radius: 6px;
@@ -26,6 +28,7 @@ const styles = createStaticStyles(({ css }) => ({
 export const useAskCopilotItem = (editor: IEditor | undefined): ChatInputActionsProps['items'] => {
   const { t } = useTranslation('common');
   const addSelectionContext = useFileStore((s) => s.addChatContextSelection);
+  const pageId = usePageEditorStore((s) => s.documentId);
 
   return useMemo(() => {
     if (!editor) return [];
@@ -60,6 +63,7 @@ export const useAskCopilotItem = (editor: IEditor | undefined): ChatInputActions
                 content,
                 format,
                 id: `selection-${nanoid(6)}`,
+                pageId,
                 preview,
                 title: 'Selection',
                 type: 'text',
@@ -95,5 +99,5 @@ export const useAskCopilotItem = (editor: IEditor | undefined): ChatInputActions
         onClick: () => {},
       },
     ];
-  }, [addSelectionContext, editor, t]);
+  }, [addSelectionContext, editor, pageId, t]);
 };