@csntgao/uni-base 0.6.3 → 0.6.5

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({

package/packages/web-components/tests/customer-support-transport.test.ts

@@ -1,7 +1,9 @@
 // @vitest-environment happy-dom
 
 import { describe, expect, it, vi } from 'vitest'
-import { createHrSaasCustomerSupportTransport } from '../src'
+import { createHrSaasCustomerSupportTransport, HrSaasCustomerSupportTransportError } from '../src'
+
+const actionTransactionId = '8f0b790c-1c5f-4f8c-95cc-4ead9d9cfb1a'
 
 function response(data: unknown): Response {
   return new Response(JSON.stringify({ rescode: 0, data }), {
@@ -76,4 +78,90 @@ describe('createHrSaasCustomerSupportTransport', () => {
       expect(new Headers(call[1]?.headers).get('authorization')).toBe('Bearer customer.support.jwt')
     }
   })
+
+  it('creates an idempotent handoff with only the source session and trusted action id', async () => {
+    const fetchImplementation = vi.fn<typeof fetch>(async (input, init) => {
+      void input
+      void init
+      return response({
+        session: {
+          session_id: 'support-81',
+          title: '职责越界转接',
+          status: 'waiting',
+          unread_count: 0,
+        },
+        initial_message: {
+          message_id: 'support-message-91',
+          session_id: 'support-81',
+          sequence: '1',
+          sender_type: 'customer',
+          content: '来自数字员工会话的转接',
+          created_at: '2026-09-09T08:00:00Z',
+        },
+        created: true,
+        repaired: false,
+      })
+    })
+    const transport = createHrSaasCustomerSupportTransport({
+      serviceBaseUrl: 'https://hr.example.com/general/project/hr_saas/service/customer_support_api',
+      getAccessToken: () => 'customer.support.jwt',
+      fetch: fetchImplementation as typeof fetch,
+    })
+
+    const result = await transport.createHandoffSession?.({
+      sourceSessionId: 'ai-session-31',
+      actionTransactionId,
+    })
+
+    expect(result).toMatchObject({
+      session: { id: 'support-81', status: 'waiting' },
+      initialMessage: { id: 'support-message-91', sessionId: 'support-81' },
+      created: true,
+      repaired: false,
+    })
+    const [url, init] = fetchImplementation.mock.calls[0]!
+    expect(String(url)).toBe(
+      'https://hr.example.com/general/project/hr_saas/service/customer_support_api/user_session_handoff_create',
+    )
+    expect(JSON.parse(String(init?.body))).toEqual({
+      source_session_id: 'ai-session-31',
+      action_transaction_id: actionTransactionId,
+    })
+    expect(String(init?.body)).not.toContain('ae_code')
+    expect(String(init?.body)).not.toContain('agent_code')
+    expect(String(init?.body)).not.toContain('org_id')
+    expect(new Headers(init?.headers).get('authorization')).toBe('Bearer customer.support.jwt')
+  })
+
+  it('maps handoff failures to stable safe errors without exposing backend text', async () => {
+    const fetchImplementation = vi.fn(
+      async () =>
+        new Response(
+          JSON.stringify({
+            rescode: 1,
+            error_code: 'HANDOFF_ACTION_MISMATCH',
+            msg: 'private upstream details',
+          }),
+          { status: 409, headers: { 'content-type': 'application/json' } },
+        ),
+    )
+    const transport = createHrSaasCustomerSupportTransport({
+      serviceBaseUrl: 'https://hr.example.com/general/project/hr_saas/service/customer_support_api',
+      getAccessToken: () => 'customer.support.jwt',
+      fetch: fetchImplementation as typeof fetch,
+    })
+
+    const request = transport.createHandoffSession?.({
+      sourceSessionId: 'ai-session-31',
+      actionTransactionId,
+    })
+
+    await expect(request).rejects.toMatchObject({
+      name: 'HrSaasCustomerSupportTransportError',
+      code: 'HANDOFF_ACTION_MISMATCH',
+      message: 'Customer support request failed',
+    })
+    await expect(request).rejects.not.toThrow('private upstream details')
+    expect(HrSaasCustomerSupportTransportError).toBeTypeOf('function')
+  })
 })