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

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.362](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.361...v2.0.0-next.362)
+
+<sup>Released on **2026-01-24**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix page selection not display correctly.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix page selection not display correctly, closes [#11765](https://github.com/lobehub/lobe-chat/issues/11765) ([7ae5f68](https://github.com/lobehub/lobe-chat/commit/7ae5f68))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.361](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.360...v2.0.0-next.361)
 
 <sup>Released on **2026-01-24**</sup>

package/Dockerfile

@@ -47,7 +47,8 @@ ENV NEXT_PUBLIC_BASE_PATH="${NEXT_PUBLIC_BASE_PATH}" \
 ENV APP_URL="http://app.com" \
     DATABASE_DRIVER="node" \
     DATABASE_URL="postgres://postgres:password@localhost:5432/postgres" \
-    KEY_VAULTS_SECRET="use-for-build"
+    KEY_VAULTS_SECRET="use-for-build" \
+    AUTH_SECRET="use-for-build"
 
 # Sentry
 ENV NEXT_PUBLIC_SENTRY_DSN="${NEXT_PUBLIC_SENTRY_DSN}" \

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fix page selection not display correctly."
+      ]
+    },
+    "date": "2026-01-24",
+    "version": "2.0.0-next.362"
+  },
   {
     "children": {},
     "date": "2026-01-24",

package/locales/en-US/chat.json

@@ -208,7 +208,9 @@
   "operation.sendMessage": "Sending message",
   "owner": "Group owner",
   "pageCopilot.title": "Page Agent",
-  "pageCopilot.welcome": "**Clearer, sharper writing**\n\nDraft, rewrite, or polish—tell me your intent and I’ll refine the rest.",
+  "pageCopilot.welcome": "**Clearer, sharper writing**\n\nDraft, rewrite, or polish—tell me your intent and I'll refine the rest.",
+  "pageSelection.lines": "Lines {{start}}-{{end}}",
+  "pageSelection.reference": "Selected Text",
   "pin": "Pin",
   "pinOff": "Unpin",
   "prompts.summaryExpert": "As a summary expert, please summarize the following content based on the system prompts above:",

package/locales/zh-CN/chat.json

@@ -209,6 +209,8 @@
   "owner": "群主",
   "pageCopilot.title": "文稿助理",
   "pageCopilot.welcome": "**让文字更清晰、更到位**\n\n起草、改写、润色都可以。你把意图说清楚，其余交给我打磨",
+  "pageSelection.lines": "第 {{start}}-{{end}} 行",
+  "pageSelection.reference": "选中文本",
   "pin": "置顶",
   "pinOff": "取消置顶",
   "prompts.summaryExpert": "作为一名总结专家，请结合以上系统提示词，将以下内容进行总结：",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.361",
+  "version": "2.0.0-next.362",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/context-engine/src/base/BaseEveryUserContentProvider.ts

@@ -0,0 +1,204 @@
+import type { Message, PipelineContext, ProcessorOptions } from '../types';
+import { BaseProcessor } from './BaseProcessor';
+import { CONTEXT_INSTRUCTION, SYSTEM_CONTEXT_END, SYSTEM_CONTEXT_START } from './constants';
+
+/**
+ * Base Provider for appending content to every user message
+ * Used for injecting context that should be attached to each user message individually
+ * (e.g., page selections that are specific to each message)
+ *
+ * Features:
+ * - Iterates through all user messages
+ * - For each message, calls buildContentForMessage to get content to inject
+ * - Wraps content with SYSTEM CONTEXT markers (or reuses existing wrapper)
+ * - Runs BEFORE BaseLastUserContentProvider so that the last user message
+ *   can reuse the SYSTEM CONTEXT wrapper created here
+ */
+export abstract class BaseEveryUserContentProvider extends BaseProcessor {
+  constructor(options: ProcessorOptions = {}) {
+    super(options);
+  }
+
+  /**
+   * Build the content to inject for a specific user message
+   * Subclasses must implement this method
+   * @param message - The user message to build content for
+   * @param index - The index of the message in the messages array
+   * @param isLastUser - Whether this is the last user message
+   * @returns Object with content and contextType, or null to skip injection for this message
+   */
+  protected abstract buildContentForMessage(
+    message: Message,
+    index: number,
+    isLastUser: boolean,
+  ): { content: string; contextType: string } | null;
+
+  /**
+   * Get the text content from a message (handles both string and array content)
+   */
+  private getTextContent(content: string | any[]): string {
+    if (typeof content === 'string') {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      const lastTextPart = content.findLast((part: any) => part.type === 'text');
+      return lastTextPart?.text || '';
+    }
+    return '';
+  }
+
+  /**
+   * Check if the content already has a system context wrapper
+   */
+  protected hasSystemContextWrapper(content: string | any[]): boolean {
+    const textContent = this.getTextContent(content);
+    return textContent.includes(SYSTEM_CONTEXT_START) && textContent.includes(SYSTEM_CONTEXT_END);
+  }
+
+  /**
+   * Wrap content with system context markers
+   */
+  protected wrapWithSystemContext(content: string, contextType: string): string {
+    return `${SYSTEM_CONTEXT_START}
+${CONTEXT_INSTRUCTION}
+<${contextType}>
+${content}
+</${contextType}>
+${SYSTEM_CONTEXT_END}`;
+  }
+
+  /**
+   * Insert content into existing system context wrapper (before the END marker)
+   */
+  private insertIntoExistingWrapper(existingContent: string, newContextBlock: string): string {
+    const endMarkerIndex = existingContent.lastIndexOf(SYSTEM_CONTEXT_END);
+    if (endMarkerIndex === -1) {
+      return existingContent + '\n\n' + newContextBlock;
+    }
+
+    const beforeEnd = existingContent.slice(0, endMarkerIndex);
+    const afterEnd = existingContent.slice(endMarkerIndex);
+
+    return beforeEnd + newContextBlock + '\n' + afterEnd;
+  }
+
+  /**
+   * Create a context block without the full wrapper (for inserting into existing wrapper)
+   */
+  protected createContextBlock(content: string, contextType: string): string {
+    return `<${contextType}>
+${content}
+</${contextType}>`;
+  }
+
+  /**
+   * Append content to a message with SYSTEM CONTEXT wrapper
+   */
+  protected appendToMessage(message: Message, content: string, contextType: string): Message {
+    const currentContent = message.content;
+
+    // Handle string content
+    if (typeof currentContent === 'string') {
+      let newContent: string;
+
+      if (this.hasSystemContextWrapper(currentContent)) {
+        // Insert into existing wrapper
+        const contextBlock = this.createContextBlock(content, contextType);
+        newContent = this.insertIntoExistingWrapper(currentContent, contextBlock);
+      } else {
+        // Create new wrapper
+        newContent = currentContent + '\n\n' + this.wrapWithSystemContext(content, contextType);
+      }
+
+      return {
+        ...message,
+        content: newContent,
+      };
+    }
+
+    // Handle array content (multimodal messages)
+    if (Array.isArray(currentContent)) {
+      const lastTextIndex = currentContent.findLastIndex((part: any) => part.type === 'text');
+
+      if (lastTextIndex !== -1) {
+        const newContent = [...currentContent];
+        const existingText = newContent[lastTextIndex].text;
+        let updatedText: string;
+
+        if (this.hasSystemContextWrapper(existingText)) {
+          // Insert into existing wrapper
+          const contextBlock = this.createContextBlock(content, contextType);
+          updatedText = this.insertIntoExistingWrapper(existingText, contextBlock);
+        } else {
+          // Create new wrapper
+          updatedText = existingText + '\n\n' + this.wrapWithSystemContext(content, contextType);
+        }
+
+        newContent[lastTextIndex] = {
+          ...newContent[lastTextIndex],
+          text: updatedText,
+        };
+        return {
+          ...message,
+          content: newContent,
+        };
+      } else {
+        // No text part found, add a new one with wrapper
+        return {
+          ...message,
+          content: [
+            ...currentContent,
+            { text: this.wrapWithSystemContext(content, contextType), type: 'text' },
+          ],
+        };
+      }
+    }
+
+    return message;
+  }
+
+  /**
+   * Find the index of the last user message
+   */
+  protected findLastUserMessageIndex(messages: Message[]): number {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].role === 'user') {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  /**
+   * Process the context by injecting content to every user message
+   */
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const clonedContext = this.cloneContext(context);
+    const lastUserIndex = this.findLastUserMessageIndex(clonedContext.messages);
+    let injectCount = 0;
+
+    // Iterate through all messages
+    for (let i = 0; i < clonedContext.messages.length; i++) {
+      const message = clonedContext.messages[i];
+
+      // Only process user messages
+      if (message.role !== 'user') continue;
+
+      const isLastUser = i === lastUserIndex;
+      const result = this.buildContentForMessage(message, i, isLastUser);
+
+      if (!result) continue;
+
+      // Append to this user message with SYSTEM CONTEXT wrapper
+      clonedContext.messages[i] = this.appendToMessage(message, result.content, result.contextType);
+      injectCount++;
+    }
+
+    // Update metadata with injection count
+    if (injectCount > 0) {
+      clonedContext.metadata[`${this.name}InjectedCount`] = injectCount;
+    }
+
+    return this.markAsExecuted(clonedContext);
+  }
+}

package/packages/context-engine/src/base/BaseLastUserContentProvider.ts

@@ -1,13 +1,6 @@
 import type { Message, PipelineContext, ProcessorOptions } from '../types';
 import { BaseProcessor } from './BaseProcessor';
-
-const SYSTEM_CONTEXT_START = '<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->';
-const SYSTEM_CONTEXT_END = '<!-- END SYSTEM CONTEXT -->';
-const CONTEXT_INSTRUCTION = `<context.instruction>following part contains context information injected by the system. Please follow these instructions:
-
-1. Always prioritize handling user-visible content.
-2. the context is only required when user's queries rely on it.
-</context.instruction>`;
+import { CONTEXT_INSTRUCTION, SYSTEM_CONTEXT_END, SYSTEM_CONTEXT_START } from './constants';
 
 /**
  * Base Provider for appending content to the last user message

package/packages/context-engine/src/base/__tests__/BaseEveryUserContentProvider.test.ts

@@ -0,0 +1,354 @@
+import { describe, expect, it } from 'vitest';
+
+import type { Message, PipelineContext } from '../../types';
+import { BaseEveryUserContentProvider } from '../BaseEveryUserContentProvider';
+
+class TestEveryUserContentProvider extends BaseEveryUserContentProvider {
+  readonly name = 'TestEveryUserContentProvider';
+
+  constructor(
+    private contentBuilder?: (
+      message: Message,
+      index: number,
+      isLastUser: boolean,
+    ) => { content: string; contextType: string } | null,
+  ) {
+    super();
+  }
+
+  protected buildContentForMessage(
+    message: Message,
+    index: number,
+    isLastUser: boolean,
+  ): { content: string; contextType: string } | null {
+    if (this.contentBuilder) {
+      return this.contentBuilder(message, index, isLastUser);
+    }
+    // Default: inject content for every user message
+    return {
+      content: `Content for message ${index}`,
+      contextType: 'test_context',
+    };
+  }
+
+  // Expose protected methods for testing
+  testHasSystemContextWrapper(content: string | any[]) {
+    return this.hasSystemContextWrapper(content);
+  }
+
+  testWrapWithSystemContext(content: string, contextType: string) {
+    return this.wrapWithSystemContext(content, contextType);
+  }
+
+  testCreateContextBlock(content: string, contextType: string) {
+    return this.createContextBlock(content, contextType);
+  }
+
+  testAppendToMessage(message: Message, content: string, contextType: string) {
+    return this.appendToMessage(message, content, contextType);
+  }
+
+  testFindLastUserMessageIndex(messages: Message[]) {
+    return this.findLastUserMessageIndex(messages);
+  }
+}
+
+describe('BaseEveryUserContentProvider', () => {
+  const createContext = (messages: any[] = []): PipelineContext => ({
+    initialState: {
+      messages: [],
+      model: 'test-model',
+      provider: 'test-provider',
+    },
+    isAborted: false,
+    messages,
+    metadata: {
+      maxTokens: 4000,
+      model: 'test-model',
+    },
+  });
+
+  describe('findLastUserMessageIndex', () => {
+    it('should find the last user message', () => {
+      const provider = new TestEveryUserContentProvider();
+      const messages = [
+        { content: 'Hello', role: 'user' },
+        { content: 'Hi', role: 'assistant' },
+        { content: 'Question', role: 'user' },
+        { content: 'Answer', role: 'assistant' },
+      ];
+
+      expect(provider.testFindLastUserMessageIndex(messages)).toBe(2);
+    });
+
+    it('should return -1 when no user messages exist', () => {
+      const provider = new TestEveryUserContentProvider();
+      const messages = [{ content: 'System', role: 'system' }];
+
+      expect(provider.testFindLastUserMessageIndex(messages)).toBe(-1);
+    });
+  });
+
+  describe('hasSystemContextWrapper', () => {
+    it('should detect existing system context wrapper in string content', () => {
+      const provider = new TestEveryUserContentProvider();
+
+      const withWrapper = `Question
+<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->
+<test>content</test>
+<!-- END SYSTEM CONTEXT -->`;
+
+      const withoutWrapper = 'Simple question';
+
+      expect(provider.testHasSystemContextWrapper(withWrapper)).toBe(true);
+      expect(provider.testHasSystemContextWrapper(withoutWrapper)).toBe(false);
+    });
+
+    it('should detect existing system context wrapper in array content', () => {
+      const provider = new TestEveryUserContentProvider();
+
+      const withWrapper = [
+        {
+          text: `Question
+<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->
+<test>content</test>
+<!-- END SYSTEM CONTEXT -->`,
+          type: 'text',
+        },
+      ];
+
+      const withoutWrapper = [{ text: 'Simple question', type: 'text' }];
+
+      expect(provider.testHasSystemContextWrapper(withWrapper)).toBe(true);
+      expect(provider.testHasSystemContextWrapper(withoutWrapper)).toBe(false);
+    });
+  });
+
+  describe('wrapWithSystemContext', () => {
+    it('should wrap content with system context markers', () => {
+      const provider = new TestEveryUserContentProvider();
+      const result = provider.testWrapWithSystemContext('Test content', 'test_type');
+
+      expect(result).toContain('<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->');
+      expect(result).toContain('<context.instruction>');
+      expect(result).toContain('<test_type>');
+      expect(result).toContain('Test content');
+      expect(result).toContain('</test_type>');
+      expect(result).toContain('<!-- END SYSTEM CONTEXT -->');
+    });
+  });
+
+  describe('createContextBlock', () => {
+    it('should create context block without wrapper', () => {
+      const provider = new TestEveryUserContentProvider();
+      const result = provider.testCreateContextBlock('Block content', 'block_type');
+
+      expect(result).toBe(`<block_type>
+Block content
+</block_type>`);
+    });
+  });
+
+  describe('appendToMessage', () => {
+    it('should append with new wrapper to string content without existing wrapper', () => {
+      const provider = new TestEveryUserContentProvider();
+      const message: Message = { content: 'Original question', role: 'user' };
+
+      const result = provider.testAppendToMessage(message, 'New content', 'new_type');
+
+      expect(result.content).toContain('Original question');
+      expect(result.content).toContain('<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->');
+      expect(result.content).toContain('<new_type>');
+      expect(result.content).toContain('New content');
+      expect(result.content).toContain('<!-- END SYSTEM CONTEXT -->');
+    });
+
+    it('should insert into existing wrapper in string content', () => {
+      const provider = new TestEveryUserContentProvider();
+      const message: Message = {
+        content: `Original question
+
+<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->
+<context.instruction>...</context.instruction>
+<existing_type>
+Existing content
+</existing_type>
+<!-- END SYSTEM CONTEXT -->`,
+        role: 'user',
+      };
+
+      const result = provider.testAppendToMessage(message, 'New content', 'new_type');
+
+      // Should have only one SYSTEM CONTEXT wrapper
+      const content = result.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);
+      expect(content).toContain('<existing_type>');
+      expect(content).toContain('<new_type>');
+      expect(content).toContain('New content');
+    });
+
+    it('should handle array content without existing wrapper', () => {
+      const provider = new TestEveryUserContentProvider();
+      const message: Message = {
+        content: [
+          { text: 'Original question', type: 'text' },
+          { image_url: { url: 'http://example.com/img.png' }, type: 'image_url' },
+        ],
+        role: 'user',
+      };
+
+      const result = provider.testAppendToMessage(message, 'New content', 'new_type');
+
+      expect(result.content[0].text).toContain('Original question');
+      expect(result.content[0].text).toContain('<!-- SYSTEM CONTEXT');
+      expect(result.content[0].text).toContain('<new_type>');
+      expect(result.content[1].type).toBe('image_url');
+    });
+
+    it('should add new text part when array content has no text part', () => {
+      const provider = new TestEveryUserContentProvider();
+      const message: Message = {
+        content: [{ image_url: { url: 'http://example.com/img.png' }, type: 'image_url' }],
+        role: 'user',
+      };
+
+      const result = provider.testAppendToMessage(message, 'New content', 'new_type');
+
+      expect(result.content).toHaveLength(2);
+      expect(result.content[1].type).toBe('text');
+      expect(result.content[1].text).toContain('<!-- SYSTEM CONTEXT');
+      expect(result.content[1].text).toContain('New content');
+    });
+  });
+
+  describe('process integration', () => {
+    it('should inject content to all user messages', async () => {
+      const provider = new TestEveryUserContentProvider();
+      const context = createContext([
+        { content: 'First question', role: 'user' },
+        { content: 'First answer', role: 'assistant' },
+        { content: 'Second question', role: 'user' },
+        { content: 'Second answer', role: 'assistant' },
+        { content: 'Third question', role: 'user' },
+      ]);
+
+      const result = await provider.process(context);
+
+      // All user messages should have content injected
+      expect(result.messages[0].content).toContain('First question');
+      expect(result.messages[0].content).toContain('<test_context>');
+      expect(result.messages[0].content).toContain('Content for message 0');
+
+      expect(result.messages[2].content).toContain('Second question');
+      expect(result.messages[2].content).toContain('<test_context>');
+      expect(result.messages[2].content).toContain('Content for message 2');
+
+      expect(result.messages[4].content).toContain('Third question');
+      expect(result.messages[4].content).toContain('<test_context>');
+      expect(result.messages[4].content).toContain('Content for message 4');
+
+      // Assistant messages should be unchanged
+      expect(result.messages[1].content).toBe('First answer');
+      expect(result.messages[3].content).toBe('Second answer');
+    });
+
+    it('should correctly identify isLastUser parameter', async () => {
+      const isLastUserCalls: boolean[] = [];
+
+      const provider = new TestEveryUserContentProvider((message, index, isLastUser) => {
+        isLastUserCalls.push(isLastUser);
+        return { content: `Content ${index}`, contextType: 'test' };
+      });
+
+      const context = createContext([
+        { content: 'First', role: 'user' },
+        { content: 'Answer', role: 'assistant' },
+        { content: 'Second', role: 'user' },
+        { content: 'Answer', role: 'assistant' },
+        { content: 'Third (last)', role: 'user' },
+      ]);
+
+      await provider.process(context);
+
+      expect(isLastUserCalls).toEqual([false, false, true]);
+    });
+
+    it('should skip injection when buildContentForMessage returns null', async () => {
+      const provider = new TestEveryUserContentProvider((message, index) => {
+        // Only inject for first user message
+        if (index === 0) {
+          return { content: 'First only', contextType: 'test' };
+        }
+        return null;
+      });
+
+      const context = createContext([
+        { content: 'First question', role: 'user' },
+        { content: 'Answer', role: 'assistant' },
+        { content: 'Second question', role: 'user' },
+      ]);
+
+      const result = await provider.process(context);
+
+      expect(result.messages[0].content).toContain('<test>');
+      expect(result.messages[0].content).toContain('First only');
+      expect(result.messages[2].content).toBe('Second question');
+    });
+
+    it('should update metadata with injection count', async () => {
+      const provider = new TestEveryUserContentProvider();
+      const context = createContext([
+        { content: 'First', role: 'user' },
+        { content: 'Second', role: 'user' },
+        { content: 'Third', role: 'user' },
+      ]);
+
+      const result = await provider.process(context);
+
+      expect(result.metadata.TestEveryUserContentProviderInjectedCount).toBe(3);
+    });
+
+    it('should not set metadata when no injections made', async () => {
+      const provider = new TestEveryUserContentProvider(() => null);
+      const context = createContext([{ content: 'Question', role: 'user' }]);
+
+      const result = await provider.process(context);
+
+      expect(result.metadata.TestEveryUserContentProviderInjectedCount).toBeUndefined();
+    });
+  });
+
+  describe('integration with BaseLastUserContentProvider', () => {
+    it('should allow BaseLastUserContentProvider to reuse wrapper created by BaseEveryUserContentProvider', async () => {
+      // First: BaseEveryUserContentProvider injects to last user message
+      const everyProvider = new TestEveryUserContentProvider((message, index, isLastUser) => {
+        if (isLastUser) {
+          return { content: 'Selection content', contextType: 'user_selections' };
+        }
+        return null;
+      });
+
+      const context = createContext([
+        { content: 'First question', role: 'user' },
+        { content: 'Answer', role: 'assistant' },
+        { content: 'Last question', role: 'user' },
+      ]);
+
+      const result = await everyProvider.process(context);
+
+      // The last user message should have a SYSTEM CONTEXT wrapper
+      const lastUserContent = result.messages[2].content as string;
+      expect(lastUserContent).toContain('<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->');
+      expect(lastUserContent).toContain('<user_selections>');
+      expect(lastUserContent).toContain('Selection content');
+      expect(lastUserContent).toContain('<!-- END SYSTEM CONTEXT -->');
+
+      // Now BaseLastUserContentProvider can detect and reuse this wrapper
+      expect(everyProvider.testHasSystemContextWrapper(lastUserContent)).toBe(true);
+    });
+  });
+});

package/packages/context-engine/src/base/constants.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared constants for context injection
+ */
+
+/**
+ * System context wrapper markers
+ * Used to wrap injected context content so models can distinguish it from user content
+ */
+export const SYSTEM_CONTEXT_START = '<!-- SYSTEM CONTEXT (NOT PART OF USER QUERY) -->';
+export const SYSTEM_CONTEXT_END = '<!-- END SYSTEM CONTEXT -->';
+
+/**
+ * Context instruction text
+ * Provides guidance to the model on how to handle injected context
+ */
+export const CONTEXT_INSTRUCTION = `<context.instruction>following part contains context information injected by the system. Please follow these instructions:
+
+1. Always prioritize handling user-visible content.
+2. the context is only required when user's queries rely on it.
+</context.instruction>`;