@csntgao/uni-base 0.6.2 → 0.6.5

package/packages/web-components/src/customer-support-transport.ts

@@ -1,6 +1,7 @@
 import type {
   CustomerSupportAgent,
   CustomerSupportCreateSessionResult,
+  CustomerSupportHandoffResult,
   CustomerSupportMessage,
   CustomerSupportMessagePage,
   CustomerSupportSenderType,
@@ -8,6 +9,7 @@ import type {
   CustomerSupportSessionStatus,
   CustomerSupportTransport,
 } from '@uniplat/ai-employee-client'
+import { isUuidV4 } from '@uniplat/ai-employee-client'
 
 export interface HrSaasCustomerSupportTransportOptions {
   serviceBaseUrl: string
@@ -15,8 +17,30 @@ export interface HrSaasCustomerSupportTransportOptions {
   fetch?: typeof fetch
 }
 
+export type HrSaasCustomerSupportTransportErrorCode =
+  | 'AUTH_REQUIRED'
+  | 'SOURCE_SESSION_NOT_FOUND'
+  | 'SOURCE_SESSION_ACCESS_DENIED'
+  | 'HANDOFF_ACTION_NOT_FOUND'
+  | 'HANDOFF_ACTION_MISMATCH'
+  | 'UNAUTHORIZED'
+  | 'CUSTOMER_SUPPORT_UNAVAILABLE'
+  | 'REQUEST_FAILED'
+  | 'INVALID_RESPONSE'
+
+export class HrSaasCustomerSupportTransportError extends Error {
+  readonly code: HrSaasCustomerSupportTransportErrorCode
+
+  constructor(code: HrSaasCustomerSupportTransportErrorCode) {
+    super('Customer support request failed')
+    this.name = 'HrSaasCustomerSupportTransportError'
+    this.code = code
+  }
+}
+
 const SESSION_PAGE_ACTION = 'user_session_page'
 const SESSION_CREATE_ACTION = 'user_session_create'
+const SESSION_HANDOFF_CREATE_ACTION = 'user_session_handoff_create'
 const SESSION_DETAIL_ACTION = 'user_session_detail'
 const MESSAGE_PAGE_ACTION = 'user_message_page'
 const MESSAGE_SEND_ACTION = 'user_message_send'
@@ -63,6 +87,37 @@ export function createHrSaasCustomerSupportTransport(
       if (parsedInitialMessage) result.initialMessage = parsedInitialMessage
       return result
     },
+    async createHandoffSession(handoffRequest) {
+      const sourceSessionId = requiredText(handoffRequest.sourceSessionId, 128)
+      const actionTransactionId = requiredText(handoffRequest.actionTransactionId, 36)
+      if (!isUuidV4(actionTransactionId)) {
+        throw new HrSaasCustomerSupportTransportError('INVALID_RESPONSE')
+      }
+      const data = record(
+        await request(SESSION_HANDOFF_CREATE_ACTION, {
+          source_session_id: sourceSessionId,
+          action_transaction_id: actionTransactionId,
+        }),
+      )
+      const session = parseSession(data.session)
+      const initialMessage = parseMessage(data.initial_message)
+      if (
+        !session ||
+        !initialMessage ||
+        initialMessage.sessionId !== session.id ||
+        typeof data.created !== 'boolean' ||
+        typeof data.repaired !== 'boolean'
+      ) {
+        throw new HrSaasCustomerSupportTransportError('INVALID_RESPONSE')
+      }
+      const result: CustomerSupportHandoffResult = {
+        session,
+        initialMessage,
+        created: data.created,
+        repaired: data.repaired,
+      }
+      return result
+    },
     async getSession(sessionId) {
       const data = await request(SESSION_DETAIL_ACTION, {
         session_id: requiredText(sessionId, 128),
@@ -169,27 +224,74 @@ async function requestData(
   accessToken: string,
   body: Record<string, unknown>,
 ): Promise<unknown> {
-  if (!fetchImplementation) throw new Error('Fetch is unavailable')
-  const response = await fetchImplementation(endpoint, {
-    method: 'POST',
-    credentials: 'include',
-    headers: {
-      accept: 'application/json',
-      authorization: `Bearer ${accessToken}`,
-      'content-type': 'application/json',
-    },
-    body: JSON.stringify(body),
-  })
-  if (!response.ok) throw new Error('Customer support request failed')
-  const payload: unknown = await response.json()
+  if (!fetchImplementation) throw new HrSaasCustomerSupportTransportError('REQUEST_FAILED')
+  let response: Response
+  try {
+    response = await fetchImplementation(endpoint, {
+      method: 'POST',
+      credentials: 'include',
+      headers: {
+        accept: 'application/json',
+        authorization: `Bearer ${accessToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+  } catch {
+    throw new HrSaasCustomerSupportTransportError('REQUEST_FAILED')
+  }
+  let payload: unknown = null
+  try {
+    payload = await response.json()
+  } catch {
+    if (!response.ok) throw transportResponseError({}, response.status)
+    throw new HrSaasCustomerSupportTransportError('INVALID_RESPONSE')
+  }
   const envelope = record(payload)
+  if (!response.ok) throw transportResponseError(envelope, response.status)
   if ('rescode' in envelope) {
-    if (Number(envelope.rescode) !== 0) throw new Error('Customer support request failed')
+    if (Number(envelope.rescode) !== 0) {
+      throw transportResponseError(envelope, response.status)
+    }
     return envelope.data
   }
   return payload
 }
 
+function transportResponseError(
+  envelope: Record<string, unknown>,
+  status: number,
+): HrSaasCustomerSupportTransportError {
+  const detail = record(envelope.data)
+  const error = record(envelope.error)
+  const candidate = [
+    envelope.error_code,
+    envelope.code,
+    detail.error_code,
+    detail.code,
+    error.error_code,
+    error.code,
+  ].find((value) => typeof value === 'string' && value.trim())
+  const code = typeof candidate === 'string' ? candidate.trim().toUpperCase() : ''
+  if (isTransportErrorCode(code)) return new HrSaasCustomerSupportTransportError(code)
+  if (status === 401) return new HrSaasCustomerSupportTransportError('UNAUTHORIZED')
+  if (status === 503) {
+    return new HrSaasCustomerSupportTransportError('CUSTOMER_SUPPORT_UNAVAILABLE')
+  }
+  return new HrSaasCustomerSupportTransportError('REQUEST_FAILED')
+}
+
+function isTransportErrorCode(value: string): value is HrSaasCustomerSupportTransportErrorCode {
+  return [
+    'SOURCE_SESSION_NOT_FOUND',
+    'SOURCE_SESSION_ACCESS_DENIED',
+    'HANDOFF_ACTION_NOT_FOUND',
+    'HANDOFF_ACTION_MISMATCH',
+    'UNAUTHORIZED',
+    'CUSTOMER_SUPPORT_UNAVAILABLE',
+  ].includes(value)
+}
+
 function validateServiceBaseUrl(value: string): string {
   const raw = typeof value === 'string' ? value.trim() : ''
   if (!raw) throw new TypeError('Customer support serviceBaseUrl is required')
@@ -216,7 +318,7 @@ async function resolveAccessToken(provider: () => string | Promise<string>): Pro
   } catch {
     // Provider details may contain credentials and are intentionally discarded.
   }
-  if (!value) throw new Error('Access token is unavailable')
+  if (!value) throw new HrSaasCustomerSupportTransportError('AUTH_REQUIRED')
   return value
 }
 

package/packages/web-components/src/index.ts

@@ -77,8 +77,20 @@ export type {
   CustomerSupportChatConfig,
   CustomerSupportChatEventMap,
 } from './customer-support-chat'
-export { createHrSaasCustomerSupportTransport } from './customer-support-transport'
-export type { HrSaasCustomerSupportTransportOptions } from './customer-support-transport'
+export {
+  createHrSaasCustomerSupportTransport,
+  HrSaasCustomerSupportTransportError,
+} from './customer-support-transport'
+export type {
+  HrSaasCustomerSupportTransportErrorCode,
+  HrSaasCustomerSupportTransportOptions,
+} from './customer-support-transport'
+export { isUuidV4, parseAiEmployeeAssistantContent } from '@uniplat/ai-employee-client'
+export type {
+  AiEmployeeAssistantAction,
+  OpenCustomerSupportAssistantAction,
+  ParsedAiEmployeeAssistantContent,
+} from '@uniplat/ai-employee-client'
 export type {
   NotificationCenterConfig,
   NotificationCenterEventMap,

package/packages/web-components/tests/chat.test.ts

@@ -2,13 +2,32 @@
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import {
-  AiEmployeeTransportError,
   type AiEmployeeMessage,
   type AiEmployeeTransport,
+  type CustomerSupportHandoffRequest,
+  AiEmployeeTransportError,
+  type CustomerSupportHandoffResult,
+  type CustomerSupportSession,
+  type CustomerSupportTransport,
 } from '@uniplat/ai-employee-client'
+import { HrSaasCustomerSupportTransportError } from '../src'
 import '../src'
 import type { UniplatAiEmployeeChat } from '../src'
 
+const customerSupportActionTransactionId = '8f0b790c-1c5f-4f8c-95cc-4ead9d9cfb1a'
+
+function customerSupportActionContent(): string {
+  return `该问题超出我的职责范围。\n\n您可以从‘帮助与支持’菜单项入口发起人工客服。\n\n\`\`\`json
+{
+  "type": "assistant_action",
+  "action": "open_customer_support",
+  "transaction-id": "${customerSupportActionTransactionId}",
+  "trigger": "out_of_scope",
+  "entry": "help_and_support"
+}
+\`\`\``
+}
+
 class ComponentFakeWebSocket {
   readonly url: string
   readyState = 0
@@ -66,6 +85,60 @@ function createTransport(history: AiEmployeeMessage[] = []) {
   } satisfies AiEmployeeTransport
 }
 
+function createCustomerSupportTransport() {
+  const session: CustomerSupportSession = {
+    id: 'support-session-81',
+    sessionNo: 'CS-81',
+    title: '职责越界转接',
+    status: 'waiting',
+    statusText: '等待客服接入',
+    primaryAgent: null,
+    lastMessage: '已从数字员工转接',
+    unreadCount: 0,
+    openedAt: '2026-09-09T08:00:00.000Z',
+    updatedAt: '2026-09-09T08:00:00.000Z',
+    version: '1',
+  }
+  const handoffResult: CustomerSupportHandoffResult = {
+    session,
+    initialMessage: {
+      id: 'support-message-91',
+      sessionId: session.id,
+      sequence: '1',
+      clientMessageId: '',
+      senderType: 'customer',
+      senderName: '',
+      content: '已从数字员工转接',
+      createdAt: '2026-09-09T08:00:00.000Z',
+    },
+    created: true,
+    repaired: false,
+  }
+  return {
+    session,
+    handoffResult,
+    transport: {
+      getAccessToken: vi.fn(async () => 'customer.support.jwt'),
+      listSessions: vi.fn(async () => [session]),
+      getSession: vi.fn(async () => session),
+      createSession: vi.fn(async () => ({ session })),
+      createHandoffSession: vi.fn(async (request: CustomerSupportHandoffRequest) => {
+        void request
+        return handoffResult
+      }),
+      listMessages: vi.fn(async () => ({
+        messages: [],
+        latestSequence: '1',
+        sessionVersion: '1',
+      })),
+      sendMessage: vi.fn(async () => {
+        throw new Error('not used')
+      }),
+      markRead: vi.fn(async () => undefined),
+    } satisfies CustomerSupportTransport,
+  }
+}
+
 async function settle(element: UniplatAiEmployeeChat): Promise<void> {
   await Promise.resolve()
   await element.updateComplete
@@ -413,6 +486,254 @@ describe('<uniplat-ai-employee-chat>', () => {
     expect(chat.shadowRoot?.textContent).toContain('继续咨询招聘方案')
   })
 
+  it('renders a trusted handoff action from history without exposing its raw JSON', async () => {
+    const transport = createTransport([
+      {
+        id: 'assistant-action-message',
+        sessionId: 'session-1',
+        role: 'assistant',
+        content: customerSupportActionContent(),
+        createdAt: '2026-09-09T08:00:00.000Z',
+      },
+    ])
+    const chat = document.createElement('uniplat-ai-employee-chat')
+    chat.configure({
+      realtimeUrl: 'wss://kanban.example.com/api/user-realtime/ws',
+      aeCode: 'payroll',
+      agentCode: 'specialist',
+      sessionId: 'session-1',
+      transport,
+      webSocketFactory: () => new ComponentFakeWebSocket('wss://kanban.example.com').asWebSocket(),
+    })
+    document.body.append(chat)
+    chat.open()
+
+    await vi.waitFor(() =>
+      expect(chat.shadowRoot?.querySelector('.assistant-action-button')).not.toBeNull(),
+    )
+    expect(chat.shadowRoot?.textContent).toContain('该问题超出我的职责范围。')
+    expect(chat.shadowRoot?.textContent).toContain('发起人工客服')
+    expect(chat.shadowRoot?.textContent).not.toContain('open_customer_support')
+    expect(chat.shadowRoot?.textContent).not.toContain(customerSupportActionTransactionId)
+
+    chat.shadowRoot?.querySelector<HTMLButtonElement>('.conversation-mark')?.click()
+    await settle(chat)
+    expect(chat.shadowRoot?.querySelector('.session-item-preview')?.textContent).toContain(
+      '该问题超出我的职责范围。',
+    )
+    expect(chat.shadowRoot?.querySelector('.session-item-preview')?.textContent).not.toContain(
+      'open_customer_support',
+    )
+  })
+
+  it('submits one handoff request and opens the returned customer support session', async () => {
+    const aiSockets: ComponentFakeWebSocket[] = []
+    const supportSockets: ComponentFakeWebSocket[] = []
+    const transport = createTransport([
+      {
+        id: 'assistant-action-message',
+        sessionId: 'session-1',
+        role: 'assistant',
+        content: customerSupportActionContent(),
+        createdAt: '2026-09-09T08:00:00.000Z',
+      },
+    ])
+    const support = createCustomerSupportTransport()
+    const completion = deferred<CustomerSupportHandoffResult>()
+    support.transport.createHandoffSession.mockImplementation(() => completion.promise)
+    const chat = document.createElement('uniplat-ai-employee-chat')
+    chat.configure({
+      realtimeUrl: 'wss://kanban.example.com/api/user-realtime/ws',
+      aeCode: 'archives',
+      agentCode: 'default',
+      sessionId: 'session-1',
+      transport,
+      webSocketFactory: (url) => {
+        const socket = new ComponentFakeWebSocket(url)
+        aiSockets.push(socket)
+        return socket.asWebSocket()
+      },
+      customerSupport: {
+        realtimeUrl: 'wss://kanban.example.com/api/user-realtime/ws',
+        transport: support.transport,
+        webSocketFactory: (url) => {
+          const socket = new ComponentFakeWebSocket(url)
+          supportSockets.push(socket)
+          return socket.asWebSocket()
+        },
+      },
+    })
+    document.body.append(chat)
+    chat.open()
+    await vi.waitFor(() =>
+      expect(chat.shadowRoot?.querySelector('.assistant-action-button')).not.toBeNull(),
+    )
+
+    const button = chat.shadowRoot?.querySelector<HTMLButtonElement>('.assistant-action-button')
+    button?.click()
+    button?.click()
+    await chat.updateComplete
+
+    expect(support.transport.createHandoffSession).toHaveBeenCalledTimes(1)
+    expect(support.transport.createHandoffSession).toHaveBeenCalledWith({
+      sourceSessionId: 'session-1',
+      actionTransactionId: customerSupportActionTransactionId,
+    })
+    expect(
+      chat.shadowRoot?.querySelector<HTMLButtonElement>('.assistant-action-button')?.disabled,
+    ).toBe(true)
+
+    completion.resolve(support.handoffResult)
+    await vi.waitFor(() =>
+      expect(chat.shadowRoot?.querySelector('uniplat-customer-support-chat')).not.toBeNull(),
+    )
+    await vi.waitFor(() =>
+      expect(support.transport.listMessages).toHaveBeenCalledWith('support-session-81'),
+    )
+
+    expect(aiSockets[0]?.closeCount).toBe(1)
+    expect(supportSockets).toHaveLength(1)
+    expect(
+      chat.shadowRoot?.querySelector('uniplat-customer-support-chat')?.shadowRoot?.textContent,
+    ).toContain('企业客服人工顾问')
+  })
+
+  it('retries a failed handoff with the same trusted action id', async () => {
+    const transport = createTransport([
+      {
+        id: 'assistant-action-message',
+        sessionId: 'session-1',
+        role: 'assistant',
+        content: customerSupportActionContent(),
+        createdAt: '2026-09-09T08:00:00.000Z',
+      },
+    ])
+    const support = createCustomerSupportTransport()
+    support.transport.createHandoffSession
+      .mockRejectedValueOnce(
+        new HrSaasCustomerSupportTransportError('CUSTOMER_SUPPORT_UNAVAILABLE'),
+      )
+      .mockResolvedValueOnce(support.handoffResult)
+    const chat = document.createElement('uniplat-ai-employee-chat')
+    const publicErrors: unknown[] = []
+    chat.addEventListener('error', (event) =>
+      publicErrors.push((event as unknown as CustomEvent).detail),
+    )
+    chat.configure({
+      realtimeUrl: 'wss://kanban.example.com/api/user-realtime/ws',
+      aeCode: 'social-security',
+      agentCode: 'default',
+      sessionId: 'session-1',
+      transport,
+      webSocketFactory: () => new ComponentFakeWebSocket('wss://kanban.example.com').asWebSocket(),
+      customerSupport: {
+        realtimeUrl: 'wss://kanban.example.com/api/user-realtime/ws',
+        transport: support.transport,
+        webSocketFactory: () =>
+          new ComponentFakeWebSocket('wss://kanban.example.com').asWebSocket(),
+      },
+    })
+    document.body.append(chat)
+    chat.open()
+    await vi.waitFor(() =>
+      expect(chat.shadowRoot?.querySelector('.assistant-action-button')).not.toBeNull(),
+    )
+
+    chat.shadowRoot?.querySelector<HTMLButtonElement>('.assistant-action-button')?.click()
+    await vi.waitFor(() =>
+      expect(chat.shadowRoot?.textContent).toContain('人工客服暂时不可用，请稍后重试。'),
+    )
+    chat.shadowRoot?.querySelector<HTMLButtonElement>('.assistant-action-button')?.click()
+    await vi.waitFor(() =>
+      expect(chat.shadowRoot?.querySelector('uniplat-customer-support-chat')).not.toBeNull(),
+    )
+
+    expect(support.transport.createHandoffSession).toHaveBeenCalledTimes(2)
+    expect(support.transport.createHandoffSession.mock.calls[0]?.[0]).toEqual(
+      support.transport.createHandoffSession.mock.calls[1]?.[0],
+    )
+    expect(publicErrors).toContainEqual({
+      code: 'CUSTOMER_SUPPORT_UNAVAILABLE',
+      message: '人工客服暂时不可用，请稍后重试。',
+      recoverable: true,
+    })
+    expect(JSON.stringify(publicErrors)).not.toContain(customerSupportActionTransactionId)
+  })
+
+  it('renders the same trusted action from realtime messages and ignores malformed actions', async () => {
+    const sockets: ComponentFakeWebSocket[] = []
+    const transport = createTransport()
+    const chat = document.createElement('uniplat-ai-employee-chat')
+    chat.configure({
+      realtimeUrl: 'wss://kanban.example.com/api/user-realtime/ws',
+      aeCode: 'enterprise-advisor',
+      agentCode: 'non-default',
+      sessionId: 'session-1',
+      transport,
+      webSocketFactory: (url) => {
+        const socket = new ComponentFakeWebSocket(url)
+        sockets.push(socket)
+        return socket.asWebSocket()
+      },
+    })
+    document.body.append(chat)
+    chat.open()
+    await vi.waitFor(() => expect(sockets).toHaveLength(1))
+    await authenticateAndReadyComponent(sockets[0]!)
+
+    sockets[0]?.receive({
+      type: 'realtime_event',
+      channel: 'ai_employee',
+      event: {
+        type: 'session_message',
+        session_id: 'session-1',
+        payload: {
+          JsonPatch: [
+            {
+              path: '/0',
+              value: {
+                ws_message_id: 'realtime-action-message',
+                entry_type: { type: 'assistant_message' },
+                content: JSON.stringify({ text: customerSupportActionContent() }),
+              },
+            },
+          ],
+        },
+      },
+    })
+    await vi.waitFor(() =>
+      expect(chat.shadowRoot?.querySelectorAll('.assistant-action-button')).toHaveLength(1),
+    )
+
+    const malformed = customerSupportActionContent().replace(
+      customerSupportActionTransactionId,
+      'not-a-uuid',
+    )
+    sockets[0]?.receive({
+      type: 'realtime_event',
+      channel: 'ai_employee',
+      event: {
+        type: 'session_message',
+        session_id: 'session-1',
+        payload: {
+          JsonPatch: [
+            {
+              path: '/0',
+              value: {
+                ws_message_id: 'malformed-action-message',
+                entry_type: { type: 'assistant_message' },
+                content: JSON.stringify({ text: malformed }),
+              },
+            },
+          ],
+        },
+      },
+    })
+    await settle(chat)
+
+    expect(chat.shadowRoot?.querySelectorAll('.assistant-action-button')).toHaveLength(1)
+  })
+
   it('owns the drawer lifecycle and switches to the customer support component', async () => {
     const sockets: ComponentFakeWebSocket[] = []
     const transport = createTransport()
@@ -903,7 +1224,7 @@ describe('<uniplat-ai-employee-chat>', () => {
             {
               path: '/0',
               value: {
-                ws_message_id: '204',
+                ws_message_id: 'ws-204',
                 entry_type: { type: 'assistant_message' },
                 content: JSON.stringify({ text: '后来到达的未读回复' }),
                 create_time: '2026-08-15T01:01:00.000Z',
@@ -921,10 +1242,12 @@ describe('<uniplat-ai-employee-chat>', () => {
     expect(chat.shadowRoot?.querySelector('.session-item-unread')).toBeNull()
 
     chat.shadowRoot?.querySelector<HTMLButtonElement>('.session-item')?.click()
-    await vi.waitFor(() =>
-      expect(transport.markSessionRead).toHaveBeenCalledWith('session-1', '204'),
-    )
     await settle(chat)
+    // 实时事件只带 ws_message_id，已读同步不得使用它。
+    expect(transport.markSessionRead).not.toHaveBeenCalledWith('session-1', 'ws-204')
+    expect(
+      transport.markSessionRead.mock.calls.map((call) => (call as unknown as string[])[1]),
+    ).toEqual(['203'])
     expect(chat.shadowRoot?.querySelector('.conversation-unread')).toBeNull()
   })
 
@@ -1047,7 +1370,7 @@ describe('<uniplat-ai-employee-chat>', () => {
             {
               path: '/0',
               value: {
-                ws_message_id: '402',
+                ws_message_id: 'ws-402',
                 entry_type: { type: 'assistant_message' },
                 content: JSON.stringify({ text: '当前实时回复' }),
                 create_time: '2026-08-15T01:02:00.000Z',
@@ -1057,12 +1380,16 @@ describe('<uniplat-ai-employee-chat>', () => {
         },
       },
     })
-    await vi.waitFor(() =>
-      expect(transport.markSessionRead).toHaveBeenCalledWith('session-1', '402'),
-    )
+    await settle(chat)
+    // 实时事件的 ws_message_id 不是持久化 ID，服务端会拒绝，不能拿它同步已读。
+    expect(transport.markSessionRead).not.toHaveBeenCalledWith('session-1', 'ws-402')
 
     chat.shadowRoot?.querySelector<HTMLButtonElement>('.conversation-mark')?.click()
     await vi.waitFor(() => expect(transport.listSessions).toHaveBeenCalledTimes(1))
+    // 列表返回的 latestMessageId 才是持久化 ID，这时才同步。
+    await vi.waitFor(() =>
+      expect(transport.markSessionRead).toHaveBeenCalledWith('session-1', '402'),
+    )
     expect(chat.shadowRoot?.querySelector('.session-item.current .session-item-unread')).toBeNull()
 
     chat.shadowRoot?.querySelector<HTMLButtonElement>('.session-back-button')?.click()
@@ -1070,6 +1397,87 @@ describe('<uniplat-ai-employee-chat>', () => {
     expect(chat.shadowRoot?.querySelector('.conversation-unread')?.textContent).toBe('2')
   })
 
+  it('refetches history after the turn ends and marks read with the persisted id', async () => {
+    const sockets: ComponentFakeWebSocket[] = []
+    let history: AiEmployeeMessage[] = [
+      {
+        id: '501',
+        sessionId: 'session-1',
+        role: 'assistant',
+        content: '旧回复',
+        createdAt: '2026-08-15T01:00:00.000Z',
+      },
+    ]
+    const transport = {
+      ...createTransport(history),
+      listMessages: vi.fn(async () => history),
+      markSessionRead: vi.fn(async () => undefined),
+    } satisfies AiEmployeeTransport
+    const chat = document.createElement('uniplat-ai-employee-chat')
+    chat.configure({
+      realtimeUrl: 'wss://kanban.example.com/api/user-realtime/ws',
+      aeCode: 'recruit',
+      agentCode: 'default',
+      sessionId: 'session-1',
+      transport,
+      webSocketFactory: (url) => {
+        const socket = new ComponentFakeWebSocket(url)
+        sockets.push(socket)
+        return socket.asWebSocket()
+      },
+    })
+    document.body.append(chat)
+    chat.open()
+    await vi.waitFor(() =>
+      expect(transport.markSessionRead).toHaveBeenCalledWith('session-1', '501'),
+    )
+    await authenticateAndReadyComponent(sockets[0]!)
+
+    // 服务端持久化后历史里才有数字 ID。
+    history = [
+      ...history,
+      {
+        id: '502',
+        sessionId: 'session-1',
+        role: 'assistant',
+        content: '新回复',
+        createdAt: '2026-08-15T01:02:00.000Z',
+      },
+    ]
+
+    const turnFrame = (processing: boolean) => ({
+      type: 'realtime_event',
+      channel: 'ai_employee',
+      event: {
+        type: 'session_message',
+        session_id: 'session-1',
+        payload: {
+          Ready: processing ? true : undefined,
+          finished: processing ? undefined : true,
+          JsonPatch: [
+            {
+              path: '/0',
+              value: {
+                ws_message_id: 'ws-502',
+                entry_type: { type: 'assistant_message' },
+                content: JSON.stringify({ text: '新回复' }),
+                create_time: '2026-08-15T01:02:00.000Z',
+              },
+            },
+          ],
+        },
+      },
+    })
+    sockets[0]?.receive(turnFrame(true))
+    await settle(chat)
+    sockets[0]?.receive(turnFrame(false))
+
+    await vi.waitFor(() =>
+      expect(transport.markSessionRead).toHaveBeenCalledWith('session-1', '502'),
+    )
+    expect(transport.markSessionRead).not.toHaveBeenCalledWith('session-1', 'ws-502')
+  })
+
   it('shows the current conversation when the Host has not added session listing yet', async () => {
     const chat = document.createElement('uniplat-ai-employee-chat')
     chat.configure({