Merge pull request #1890 from emqx/ysf/desktop

Red-Asuka · web-flow · commit 6f50082eaf75 · 2025-03-11T13:47:44.000+08:00
feat(copilot): introduce session management for AI interactions
diff --git a/src/components/ai/Copilot.vue b/src/components/ai/Copilot.vue
@@ -32,11 +32,12 @@ import CopilotHeader from './CopilotHeader.vue'
 import CopilotMessages from './CopilotMessages.vue'
 import CopilotInput from './CopilotInput.vue'
 import { streamText } from 'ai'
-import { loadSystemPrompt, getModelProvider } from '@/utils/ai/copilot'
+import { getModelProvider } from '@/utils/ai/copilot'
 import { throttle } from 'lodash'
 import ConnectionsIndex from '@/views/connections/index.vue'
 import { CopilotMessage, CopilotRole, CopilotPresetPrompt, StreamError } from '@/types/copilot'
 import { needsUserInput } from '@/utils/ai/preset'
+import { SessionManager } from '@/utils/ai/SessionManager'
 
 @Component({
   components: {
@@ -63,6 +64,8 @@ export default class Copilot extends Vue {
   private currPresetPrompt = ''
   private abortController: AbortController | null = null
 
+  private sessionManager = new SessionManager()
+
   private systemMessage = {
     id: 'system-id',
     role: 'system',
@@ -117,6 +120,8 @@ export default class Copilot extends Vue {
     const content = msg || this.currentPublishMsg
     if (!content) return
 
+    this.sessionManager.startSession()
+
     await this.saveUserMessage(content)
     await this.generateAIResponse()
   }
@@ -151,10 +156,12 @@ export default class Copilot extends Vue {
   }
 
   private buildMessageHistory(): Array<{ role: CopilotRole; content: string }> {
+    const systemPrompt = this.sessionManager.getSystemPrompt(this.currentLang)
+
     return [
       {
         role: this.systemMessage.role as 'system',
-        content: loadSystemPrompt(this.currentLang, this.currPresetPrompt),
+        content: systemPrompt,
       },
       ...this.messages.slice(-20).map(({ role, content }) => {
         if (content.includes('@connection')) {
@@ -275,6 +282,7 @@ export default class Copilot extends Vue {
     this.responseStreamText = ''
     const { copilotService } = useServices()
     await copilotService.deleteAll()
+    this.sessionManager.resetSession()
     this.loadMessages({ reset: true })
   }
 
@@ -294,6 +302,7 @@ export default class Copilot extends Vue {
 
     await this.clearAllMessages()
     this.currPresetPrompt = data.prompt
+    this.sessionManager.updatePreset(data.prompt)
 
     const promptValue = data.promptMap[this.currPresetPrompt]
 
diff --git a/src/utils/ai/SessionManager.ts b/src/utils/ai/SessionManager.ts
@@ -0,0 +1,94 @@
+import { loadSystemPrompt } from './copilot'
+// Language type is globally defined
+// No need to explicitly import Language type
+
+/**
+ * Session state interface
+ */
+export interface SessionState {
+  systemPrompt: string // Current system prompt for the session
+  presetPrompt: string // Current preset prompt being used
+  isNewSession: boolean // Whether this is a new session
+  lastPresetChangeTime: number // Timestamp of the last preset change
+}
+
+/**
+ * Copilot Session Manager
+ *
+ * Manages conversation session state including system prompts, preset selection, and session lifecycle
+ */
+export class SessionManager {
+  private state: SessionState = {
+    systemPrompt: '',
+    presetPrompt: '',
+    isNewSession: true,
+    lastPresetChangeTime: 0,
+  }
+
+  /**
+   * Get current session state
+   */
+  public getState(): SessionState {
+    return { ...this.state }
+  }
+
+  /**
+   * Reset session state
+   */
+  public resetSession(): void {
+    this.state = {
+      systemPrompt: '',
+      presetPrompt: '',
+      isNewSession: true,
+      lastPresetChangeTime: 0,
+    }
+  }
+
+  /**
+   * Reset session while preserving preset
+   * Useful for language switching scenarios
+   */
+  public resetSessionKeepPreset(): void {
+    const currentPreset = this.state.presetPrompt
+    this.resetSession()
+    this.state.presetPrompt = currentPreset
+  }
+
+  /**
+   * Mark session as started
+   * Called when sending the first message
+   */
+  public startSession(): void {
+    this.state.isNewSession = false
+  }
+
+  /**
+   * Update session preset prompt
+   */
+  public updatePreset(preset: string): void {
+    this.state.presetPrompt = preset
+    this.state.isNewSession = true
+    this.state.lastPresetChangeTime = Date.now()
+    this.state.systemPrompt = '' // Force system prompt reload
+  }
+
+  /**
+   * Get system prompt for current session
+   * Reloads if necessary
+   */
+  public getSystemPrompt(language: Language): string {
+    // Reload system prompt if new session or empty
+    if (this.state.isNewSession || !this.state.systemPrompt) {
+      this.loadSystemPrompt(language)
+    }
+    return this.state.systemPrompt
+  }
+
+  /**
+   * Load system prompt for current session
+   */
+  private loadSystemPrompt(language: Language): void {
+    this.state.systemPrompt = loadSystemPrompt(language, this.state.presetPrompt)
+    this.state.isNewSession = false
+  }
+}
diff --git a/tests/unit/utils/ai/SessionManager.spec.ts b/tests/unit/utils/ai/SessionManager.spec.ts
@@ -0,0 +1,170 @@
+import { expect } from 'chai'
+import { SessionManager } from '@/utils/ai/SessionManager'
+
+describe('SessionManager', () => {
+  let sessionManager: SessionManager
+
+  beforeEach(() => {
+    // Create a new SessionManager instance before each test
+    sessionManager = new SessionManager()
+  })
+
+  describe('getState', () => {
+    it('should return a copy of the state', () => {
+      const state = sessionManager.getState()
+
+      // Verify that it returns an object
+      expect(state).to.be.an('object')
+
+      // Verify that the returned state contains expected properties
+      expect(state).to.have.property('systemPrompt')
+      expect(state).to.have.property('isNewSession')
+      expect(state).to.have.property('presetPrompt')
+
+      // Modifying the returned state should not affect the original state
+      state.isNewSession = false
+      expect(sessionManager.getState().isNewSession).to.be.true
+    })
+  })
+
+  describe('resetSession', () => {
+    it('should reset the session to initial values', () => {
+      // First modify the session state
+      sessionManager.startSession()
+      sessionManager.updatePreset('test-preset')
+
+      // Then reset
+      sessionManager.resetSession()
+
+      // Verify the state has been reset
+      const state = sessionManager.getState()
+      expect(state.isNewSession).to.be.true
+      expect(state.systemPrompt).to.equal('')
+      expect(state.presetPrompt).to.equal('')
+    })
+  })
+
+  describe('resetSessionKeepPreset', () => {
+    it('should reset the session while keeping preset prompt', () => {
+      // First modify the session state
+      sessionManager.startSession()
+      sessionManager.updatePreset('test-preset')
+
+      // Then reset, but keep the preset prompt
+      sessionManager.resetSessionKeepPreset()
+
+      // Verify the state has been reset, but preset prompt is retained
+      const state = sessionManager.getState()
+      expect(state.isNewSession).to.be.true
+      expect(state.systemPrompt).to.equal('')
+      expect(state.presetPrompt).to.equal('test-preset')
+    })
+  })
+
+  describe('startSession', () => {
+    it('should mark the session as not new', () => {
+      // Initially isNewSession should be true
+      expect(sessionManager.getState().isNewSession).to.be.true
+
+      // Start the session
+      sessionManager.startSession()
+
+      // Verify isNewSession becomes false
+      expect(sessionManager.getState().isNewSession).to.be.false
+    })
+
+    it('should not affect other state properties', () => {
+      // Set some initial state
+      sessionManager.updatePreset('test-preset')
+
+      // Record the current system prompt state
+      const initialSystemPrompt = sessionManager.getState().systemPrompt
+
+      // Start the session
+      sessionManager.startSession()
+
+      // Verify only the isNewSession property was modified
+      const state = sessionManager.getState()
+      expect(state.systemPrompt).to.equal(initialSystemPrompt)
+      expect(state.presetPrompt).to.equal('test-preset')
+    })
+  })
+
+  describe('updatePreset', () => {
+    it('should update the preset prompt', () => {
+      sessionManager.updatePreset('new-preset')
+
+      expect(sessionManager.getState().presetPrompt).to.equal('new-preset')
+    })
+
+    it('should mark the session as new', () => {
+      // First mark the session as not new
+      sessionManager.startSession()
+      expect(sessionManager.getState().isNewSession).to.be.false
+
+      // Update the preset prompt
+      sessionManager.updatePreset('new-preset')
+
+      // Verify the session is marked as new
+      expect(sessionManager.getState().isNewSession).to.be.true
+    })
+
+    it('should clear the system prompt', () => {
+      // Simulate having an existing system prompt
+      sessionManager.getSystemPrompt('en')
+      expect(sessionManager.getState().systemPrompt).to.not.equal('')
+
+      // Update the preset prompt
+      sessionManager.updatePreset('new-preset')
+
+      // Verify the system prompt is cleared
+      expect(sessionManager.getState().systemPrompt).to.equal('')
+    })
+  })
+
+  describe('getSystemPrompt', () => {
+    it('should load system prompt if session is new', () => {
+      // Using sinon would encounter import issues, so we simply test behavior here
+      const result = sessionManager.getSystemPrompt('en')
+
+      // Verify it returned a non-empty string
+      expect(result).to.be.a('string')
+      expect(result).to.not.equal('')
+
+      // Verify the state was updated
+      expect(sessionManager.getState().systemPrompt).to.equal(result)
+    })
+
+    it('should return cached system prompt if session is not new', () => {
+      // Get the system prompt for the first time
+      const firstPrompt = sessionManager.getSystemPrompt('en')
+
+      // Mark the session as not new
+      sessionManager.startSession()
+
+      // Get the system prompt again
+      const secondPrompt = sessionManager.getSystemPrompt('en')
+
+      // Verify the same prompt is returned
+      expect(secondPrompt).to.equal(firstPrompt)
+    })
+
+    it('should reload system prompt if empty even if session is not new', () => {
+      // Get the system prompt for the first time
+      sessionManager.getSystemPrompt('en')
+
+      // Mark the session as not new
+      sessionManager.startSession()
+
+      // Manually clear the system prompt
+      sessionManager['state'].systemPrompt = ''
+
+      // Get the system prompt again
+      const reloadedPrompt = sessionManager.getSystemPrompt('en')
+
+      // Verify it returned a non-empty prompt
+      expect(reloadedPrompt).to.be.a('string')
+      expect(reloadedPrompt).to.not.equal('')
+    })
+  })
+})
diff --git a/tests/unit/utils/ai/copilot.spec.ts b/tests/unit/utils/ai/copilot.spec.ts
