@sales-bot-llm/sdk 0.2.0

package/tests/core/transport.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { postTurn, getResumeStream } from '../../src/core/transport'
+import { SalesBotError } from '../../src/core/types'
+
+const BASE_URL = 'http://localhost:3000'
+const EMBED_KEY = 'pk_live_abc123'
+
+function mockFetch(status: number, body: unknown, headers: Record<string, string> = {}) {
+  const responseHeaders = new Headers({
+    'content-type': 'text/event-stream',
+    ...headers,
+  })
+
+  const bodyStr = typeof body === 'string' ? body : JSON.stringify(body)
+  const stream = new ReadableStream({
+    start(ctrl) {
+      ctrl.enqueue(new TextEncoder().encode(bodyStr))
+      ctrl.close()
+    },
+  })
+
+  vi.stubGlobal(
+    'fetch',
+    vi.fn().mockResolvedValueOnce(
+      new Response(stream, { status, headers: responseHeaders }),
+    ),
+  )
+}
+
+function mockFetchWithJsonBody(status: number, body: unknown) {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn().mockResolvedValueOnce(
+      new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json' },
+      }),
+    ),
+  )
+}
+
+function mockFetchThrows(err: Error) {
+  vi.stubGlobal('fetch', vi.fn().mockRejectedValueOnce(err))
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('postTurn', () => {
+  it('calls POST /api/chat/turns', async () => {
+    mockFetch(200, '')
+    await postTurn(
+      { visitorToken: 'vt', message: 'hello' },
+      { embedKey: EMBED_KEY, baseUrl: BASE_URL },
+    )
+    const [url] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    expect(url).toBe(`${BASE_URL}/api/chat/turns`)
+  })
+
+  it('uses POST method', async () => {
+    mockFetch(200, '')
+    await postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+  })
+
+  it('sets Authorization: Bearer <embedKey>', async () => {
+    mockFetch(200, '')
+    await postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['Authorization']).toBe(`Bearer ${EMBED_KEY}`)
+  })
+
+  it('sets Accept: text/event-stream', async () => {
+    mockFetch(200, '')
+    await postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['Accept']).toBe('text/event-stream')
+  })
+
+  it('sets Content-Type: application/json', async () => {
+    mockFetch(200, '')
+    await postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['Content-Type']).toBe('application/json')
+  })
+
+  it('sets an Idempotency-Key header', async () => {
+    mockFetch(200, '')
+    await postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['Idempotency-Key']).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    )
+  })
+
+  it('sends the correct JSON body', async () => {
+    mockFetch(200, '')
+    await postTurn(
+      { visitorToken: 'vt-1', message: 'hi', conversationId: 'c-1' },
+      { embedKey: EMBED_KEY, baseUrl: BASE_URL },
+    )
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    const body = JSON.parse(init.body as string)
+    expect(body).toMatchObject({ visitorToken: 'vt-1', message: 'hi', conversationId: 'c-1' })
+  })
+
+  it('returns a ReadableStream on 200', async () => {
+    mockFetch(200, '')
+    const stream = await postTurn(
+      { visitorToken: 'vt', message: 'hello' },
+      { embedKey: EMBED_KEY, baseUrl: BASE_URL },
+    )
+    expect(stream).toBeInstanceOf(ReadableStream)
+  })
+
+  it('merges customHeaders', async () => {
+    mockFetch(200, '')
+    await postTurn(
+      { visitorToken: 'vt', message: 'hello' },
+      { embedKey: EMBED_KEY, baseUrl: BASE_URL, customHeaders: { 'X-Custom': 'yes' } },
+    )
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['X-Custom']).toBe('yes')
+  })
+
+  it('maps 401 with body code invalid_embed_key → SalesBotError(invalid_embed_key)', async () => {
+    mockFetchWithJsonBody(401, { code: 'invalid_embed_key', message: 'bad key', retryable: false })
+    await expect(
+      postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL }),
+    ).rejects.toMatchObject({ code: 'invalid_embed_key' })
+  })
+
+  it('maps 402 → out_of_credits', async () => {
+    mockFetchWithJsonBody(402, { code: 'out_of_credits', message: 'no credits', retryable: false })
+    await expect(
+      postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL }),
+    ).rejects.toMatchObject({ code: 'out_of_credits' })
+  })
+
+  it('maps 403 with body code origin_not_allowed → origin_not_allowed', async () => {
+    mockFetchWithJsonBody(403, { code: 'origin_not_allowed', message: 'no', retryable: false })
+    await expect(
+      postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL }),
+    ).rejects.toMatchObject({ code: 'origin_not_allowed' })
+  })
+
+  it('maps 429 → rate_limited', async () => {
+    mockFetchWithJsonBody(429, { code: 'rate_limited', message: 'slow down', retryable: true })
+    await expect(
+      postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL }),
+    ).rejects.toMatchObject({ code: 'rate_limited', retryable: true })
+  })
+
+  it('maps 500 → internal', async () => {
+    mockFetchWithJsonBody(500, { code: 'internal', message: 'oops', retryable: false })
+    await expect(
+      postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL }),
+    ).rejects.toMatchObject({ code: 'internal' })
+  })
+
+  it('maps fetch throw → SalesBotError(network_error)', async () => {
+    mockFetchThrows(new TypeError('Failed to fetch'))
+    await expect(
+      postTurn({ visitorToken: 'vt', message: 'hello' }, { embedKey: EMBED_KEY, baseUrl: BASE_URL }),
+    ).rejects.toMatchObject({ code: 'network_error' })
+  })
+})
+
+describe('getResumeStream', () => {
+  it('calls GET /api/chat/turns/:turnId/stream', async () => {
+    mockFetch(200, '')
+    await getResumeStream('turn-42', { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [url] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    expect(url).toBe(`${BASE_URL}/api/chat/turns/turn-42/stream`)
+  })
+
+  it('uses GET method', async () => {
+    mockFetch(200, '')
+    await getResumeStream('turn-42', { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+  })
+
+  it('sets Authorization header', async () => {
+    mockFetch(200, '')
+    await getResumeStream('turn-42', { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    const [, init] = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['Authorization']).toBe(`Bearer ${EMBED_KEY}`)
+  })
+
+  it('returns a ReadableStream on 200', async () => {
+    mockFetch(200, '')
+    const stream = await getResumeStream('turn-42', { embedKey: EMBED_KEY, baseUrl: BASE_URL })
+    expect(stream).toBeInstanceOf(ReadableStream)
+  })
+})

package/tests/core/visitor.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { MemoryStorageAdapter } from '../../src/core/storage'
+import { getOrCreateVisitorToken, VISITOR_TOKEN_KEY_PREFIX } from '../../src/core/visitor'
+
+describe('getOrCreateVisitorToken', () => {
+  it('generates a UUID on first call', () => {
+    const storage = new MemoryStorageAdapter()
+    const token = getOrCreateVisitorToken('pk_live_abc', storage)
+    expect(token).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    )
+  })
+
+  it('returns the same token on subsequent calls', () => {
+    const storage = new MemoryStorageAdapter()
+    const t1 = getOrCreateVisitorToken('pk_live_abc', storage)
+    const t2 = getOrCreateVisitorToken('pk_live_abc', storage)
+    expect(t1).toBe(t2)
+  })
+
+  it('namespaces the key by embedKey', () => {
+    const storage = new MemoryStorageAdapter()
+    const t1 = getOrCreateVisitorToken('pk_live_aaa', storage)
+    const t2 = getOrCreateVisitorToken('pk_live_bbb', storage)
+    expect(t1).not.toBe(t2)
+  })
+
+  it('stores the token under the correct key', () => {
+    const storage = new MemoryStorageAdapter()
+    const token = getOrCreateVisitorToken('pk_live_xyz', storage)
+    const key = `${VISITOR_TOKEN_KEY_PREFIX}pk_live_xyz`
+    expect(storage.getItem(key)).toBe(token)
+  })
+
+  it('reads from storage if already set externally', () => {
+    const storage = new MemoryStorageAdapter()
+    const existing = '550e8400-e29b-41d4-a716-446655440000'
+    storage.setItem(`${VISITOR_TOKEN_KEY_PREFIX}pk_live_abc`, existing)
+    const token = getOrCreateVisitorToken('pk_live_abc', storage)
+    expect(token).toBe(existing)
+  })
+})

package/tests/react/use-sales-bot.test.tsx

@@ -0,0 +1,188 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { renderHook, act } from '@testing-library/react'
+import { useSalesBot } from '../../src/react/use-sales-bot'
+import { SalesBotError } from '../../src/core/types'
+
+const EMBED_KEY = 'pk_live_reacttest'
+
+function encodeSse(name: string, data: unknown): string {
+  return `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`
+}
+
+function makeSseStream(...events: Array<[string, unknown]>): ReadableStream<Uint8Array> {
+  const raw = events.map(([n, d]) => encodeSse(n, d)).join('')
+  const encoder = new TextEncoder()
+  return new ReadableStream({
+    start(ctrl) {
+      ctrl.enqueue(encoder.encode(raw))
+      ctrl.close()
+    },
+  })
+}
+
+function mockFetchSSE(...events: Array<[string, unknown]>) {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn().mockResolvedValueOnce(
+      new Response(makeSseStream(...events), {
+        status: 200,
+        headers: { 'content-type': 'text/event-stream' },
+      }),
+    ),
+  )
+}
+
+function mockFetchError(status: number, code: string, message: string, retryable = false) {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn().mockResolvedValueOnce(
+      new Response(JSON.stringify({ code, message, retryable }), {
+        status,
+        headers: { 'content-type': 'application/json' },
+      }),
+    ),
+  )
+}
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('useSalesBot', () => {
+  it('returns a stable shape', () => {
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    expect(typeof result.current.ask).toBe('function')
+    expect(Array.isArray(result.current.messages)).toBe(true)
+    expect(typeof result.current.isStreaming).toBe('boolean')
+    expect(result.current.error).toBeNull()
+    expect(typeof result.current.reset).toBe('function')
+  })
+
+  it('starts with empty messages and not streaming', () => {
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    expect(result.current.messages).toHaveLength(0)
+    expect(result.current.isStreaming).toBe(false)
+  })
+
+  it('ask appends user message immediately', async () => {
+    mockFetchSSE(['done', { turnId: 't' }])
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    await act(async () => {
+      await result.current.ask('Hello!')
+    })
+    const userMsg = result.current.messages.find((m) => m.role === 'user')
+    expect(userMsg?.content).toBe('Hello!')
+  })
+
+  it('isStreaming becomes true during ask, false after done', async () => {
+    // We need to capture streaming state mid-stream.
+    // Use a stream that resolves after we can check.
+    const encoder = new TextEncoder()
+    let resolveStream!: () => void
+    const streamPromise = new Promise<void>((res) => { resolveStream = res })
+
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValueOnce(
+        new Response(
+          new ReadableStream({
+            async start(ctrl) {
+              ctrl.enqueue(encoder.encode(encodeSse('turn_started', { turnId: 't', conversationId: 'c', endUserId: 'e' })))
+              await streamPromise
+              ctrl.enqueue(encoder.encode(encodeSse('done', { turnId: 't' })))
+              ctrl.close()
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'text/event-stream' } },
+        ),
+      ),
+    )
+
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+
+    let askPromise: Promise<void>
+    act(() => {
+      askPromise = result.current.ask('hello')
+    })
+
+    // Give the stream a tick to start
+    await new Promise((r) => setTimeout(r, 10))
+    expect(result.current.isStreaming).toBe(true)
+
+    // Finish the stream
+    resolveStream()
+    await act(async () => { await askPromise })
+    expect(result.current.isStreaming).toBe(false)
+  })
+
+  it('accumulates delta content into assistant message', async () => {
+    mockFetchSSE(
+      ['turn_started', { turnId: 't', conversationId: 'c', endUserId: 'e' }],
+      ['delta', { content: 'Hello ' }],
+      ['delta', { content: 'world' }],
+      ['message_complete', { messageId: 'm', content: 'Hello world', modelId: 'x', promptTokens: 5, completionTokens: 5 }],
+      ['done', { turnId: 't' }],
+    )
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    await act(async () => { await result.current.ask('hi') })
+
+    const assistantMsg = result.current.messages.find((m) => m.role === 'assistant')
+    expect(assistantMsg?.content).toBe('Hello world')
+  })
+
+  it('sets conversationId from turn_started', async () => {
+    mockFetchSSE(
+      ['turn_started', { turnId: 't', conversationId: 'conv-abc', endUserId: 'e' }],
+      ['done', { turnId: 't' }],
+    )
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    await act(async () => { await result.current.ask('hi') })
+    expect(result.current.conversationId).toBe('conv-abc')
+  })
+
+  it('sets error on SalesBotError', async () => {
+    mockFetchError(429, 'rate_limited', 'Too fast', true)
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    await act(async () => {
+      await result.current.ask('hi')
+    })
+    expect(result.current.error).toBeInstanceOf(SalesBotError)
+    expect(result.current.error?.code).toBe('rate_limited')
+  })
+
+  it('reset clears messages and error', async () => {
+    mockFetchError(500, 'internal', 'oops')
+    const { result } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    await act(async () => { await result.current.ask('hi') })
+    expect(result.current.messages.length).toBeGreaterThan(0)
+
+    act(() => { result.current.reset() })
+    expect(result.current.messages).toHaveLength(0)
+    expect(result.current.error).toBeNull()
+    expect(result.current.conversationId).toBeNull()
+  })
+
+  it('client is not re-created on re-render', () => {
+    const { result, rerender } = renderHook(() =>
+      useSalesBot({ embedKey: EMBED_KEY, baseUrl: 'http://localhost:3000' }),
+    )
+    const token1 = result.current.visitorToken
+    rerender()
+    const token2 = result.current.visitorToken
+    expect(token1).toBe(token2)
+  })
+})

package/tests/sales-tool-discriminator.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import {
+  SALES_WORKFLOW_TOOL_NAMES,
+  isSalesWorkflowTool,
+  type SalesWorkflowToolName,
+} from '../src/core/types';
+
+describe('SALES_WORKFLOW_TOOL_NAMES', () => {
+  it('is a readonly tuple containing all five sales-workflow tool names', () => {
+    expect(SALES_WORKFLOW_TOOL_NAMES).toEqual([
+      'project_brief__set_field',
+      'project_brief__get_current',
+      'quotes__generate',
+      'quotes__send_as_pdf',
+      'quotes__send_as_proposal',
+    ]);
+  });
+});
+
+describe('isSalesWorkflowTool', () => {
+  it('returns true for each sales-workflow tool name', () => {
+    expect(isSalesWorkflowTool('project_brief__set_field')).toBe(true);
+    expect(isSalesWorkflowTool('project_brief__get_current')).toBe(true);
+    expect(isSalesWorkflowTool('quotes__generate')).toBe(true);
+    expect(isSalesWorkflowTool('quotes__send_as_pdf')).toBe(true);
+    expect(isSalesWorkflowTool('quotes__send_as_proposal')).toBe(true);
+  });
+
+  it('returns false for unrelated tool names', () => {
+    expect(isSalesWorkflowTool('chaindoc_media_upload')).toBe(false);
+    expect(isSalesWorkflowTool('llms_txt__search')).toBe(false);
+    expect(isSalesWorkflowTool('')).toBe(false);
+    expect(isSalesWorkflowTool('quotes__')).toBe(false);
+    expect(isSalesWorkflowTool('project_brief__unknown')).toBe(false);
+  });
+
+  it('narrows the type when used as a type guard', () => {
+    const name: string = 'quotes__generate';
+    if (isSalesWorkflowTool(name)) {
+      // Inside this branch, TypeScript narrows `name` to `SalesWorkflowToolName`.
+      const narrowed: SalesWorkflowToolName = name;
+      expect(narrowed).toBe('quotes__generate');
+    }
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,3 @@
+// Global test setup
+// happy-dom provides localStorage, crypto.randomUUID, etc.
+// Nothing extra needed here for now.

package/tests/vanilla/vanilla.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest'
+import { SalesBot } from '../../src/vanilla/index'
+import { SalesBotClient } from '../../src/core/client'
+import { MemoryStorageAdapter } from '../../src/core/storage'
+
+describe('SalesBot (vanilla entry)', () => {
+  it('SalesBot.init returns a SalesBotClient', () => {
+    const client = SalesBot.init({
+      embedKey: 'pk_live_vanilla_test',
+      baseUrl: 'http://localhost:3000',
+      storage: new MemoryStorageAdapter(),
+    })
+    expect(client).toBeInstanceOf(SalesBotClient)
+  })
+
+  it('SalesBotClient from init has a visitor token', () => {
+    const client = SalesBot.init({
+      embedKey: 'pk_live_vanilla_test',
+      baseUrl: 'http://localhost:3000',
+      storage: new MemoryStorageAdapter(),
+    })
+    expect(client.getVisitorToken()).toMatch(/^[0-9a-f-]{36}$/i)
+  })
+
+  it('SalesBot.widget mounts and returns a WidgetInstance', () => {
+    const instance = SalesBot.widget({
+      embedKey: 'pk_live_vanilla_test',
+      baseUrl: 'http://localhost:3000',
+      storage: new MemoryStorageAdapter(),
+    })
+    expect(typeof instance.open).toBe('function')
+    expect(typeof instance.close).toBe('function')
+    expect(typeof instance.toggle).toBe('function')
+    expect(typeof instance.destroy).toBe('function')
+    instance.destroy()
+  })
+})

package/tests/vue/use-sales-bot.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { mount } from '@vue/test-utils'
+import { defineComponent, nextTick } from 'vue'
+import { useSalesBot } from '../../src/vue/use-sales-bot'
+import { SalesBotError } from '../../src/core/types'
+
+const EMBED_KEY = 'pk_live_vuetest'
+const BASE_URL = 'http://localhost:3000'
+
+function encodeSse(name: string, data: unknown): string {
+  return `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`
+}
+
+function makeSseStream(...events: Array<[string, unknown]>): ReadableStream<Uint8Array> {
+  const raw = events.map(([n, d]) => encodeSse(n, d)).join('')
+  const encoder = new TextEncoder()
+  return new ReadableStream({
+    start(ctrl) {
+      ctrl.enqueue(encoder.encode(raw))
+      ctrl.close()
+    },
+  })
+}
+
+function mockFetchSSE(...events: Array<[string, unknown]>) {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn().mockResolvedValueOnce(
+      new Response(makeSseStream(...events), {
+        status: 200,
+        headers: { 'content-type': 'text/event-stream' },
+      }),
+    ),
+  )
+}
+
+function mockFetchError(status: number, code: string, message: string, retryable = false) {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn().mockResolvedValueOnce(
+      new Response(JSON.stringify({ code, message, retryable }), {
+        status,
+        headers: { 'content-type': 'application/json' },
+      }),
+    ),
+  )
+}
+
+afterEach(() => vi.unstubAllGlobals())
+
+/** Mount a component that uses the composable and exposes its return value */
+function mountComposable() {
+  let exposed: ReturnType<typeof useSalesBot>
+  const Wrapper = defineComponent({
+    setup() {
+      exposed = useSalesBot({ embedKey: EMBED_KEY, baseUrl: BASE_URL })
+      return exposed
+    },
+    template: '<div></div>',
+  })
+  const wrapper = mount(Wrapper)
+  return { wrapper, composable: exposed! }
+}
+
+describe('useSalesBot (Vue)', () => {
+  it('returns reactive refs', () => {
+    const { composable } = mountComposable()
+    expect(composable.messages.value).toBeInstanceOf(Array)
+    expect(typeof composable.isStreaming.value).toBe('boolean')
+    expect(composable.error.value).toBeNull()
+    expect(typeof composable.ask).toBe('function')
+    expect(typeof composable.reset).toBe('function')
+  })
+
+  it('starts with empty messages and not streaming', () => {
+    const { composable } = mountComposable()
+    expect(composable.messages.value).toHaveLength(0)
+    expect(composable.isStreaming.value).toBe(false)
+  })
+
+  it('ask appends user message immediately', async () => {
+    mockFetchSSE(['done', { turnId: 't' }])
+    const { composable } = mountComposable()
+    await composable.ask('Hello!')
+    await nextTick()
+    const userMsg = composable.messages.value.find((m) => m.role === 'user')
+    expect(userMsg?.content).toBe('Hello!')
+  })
+
+  it('messages ref updates with delta content', async () => {
+    mockFetchSSE(
+      ['turn_started', { turnId: 't', conversationId: 'c', endUserId: 'e' }],
+      ['delta', { content: 'Hey ' }],
+      ['delta', { content: 'there' }],
+      ['message_complete', { messageId: 'm', content: 'Hey there', modelId: 'x', promptTokens: 3, completionTokens: 3 }],
+      ['done', { turnId: 't' }],
+    )
+    const { composable } = mountComposable()
+    await composable.ask('hi')
+    await nextTick()
+
+    const assistantMsg = composable.messages.value.find((m) => m.role === 'assistant')
+    expect(assistantMsg?.content).toBe('Hey there')
+  })
+
+  it('conversationId ref set from turn_started', async () => {
+    mockFetchSSE(
+      ['turn_started', { turnId: 't', conversationId: 'vue-conv', endUserId: 'e' }],
+      ['done', { turnId: 't' }],
+    )
+    const { composable } = mountComposable()
+    await composable.ask('hi')
+    await nextTick()
+    expect(composable.conversationId.value).toBe('vue-conv')
+  })
+
+  it('isStreaming transitions correctly', async () => {
+    mockFetchSSE(
+      ['delta', { content: 'x' }],
+      ['done', { turnId: 't' }],
+    )
+    const { composable } = mountComposable()
+    const askPromise = composable.ask('hi')
+    // isStreaming should be true while asking
+    expect(composable.isStreaming.value).toBe(true)
+    await askPromise
+    expect(composable.isStreaming.value).toBe(false)
+  })
+
+  it('error ref is set on failure', async () => {
+    mockFetchError(429, 'rate_limited', 'Too fast', true)
+    const { composable } = mountComposable()
+    await composable.ask('hi')
+    await nextTick()
+    expect(composable.error.value).toBeInstanceOf(SalesBotError)
+    expect(composable.error.value?.code).toBe('rate_limited')
+  })
+
+  it('reset clears messages, error, and conversationId', async () => {
+    mockFetchError(500, 'internal', 'oops')
+    const { composable } = mountComposable()
+    await composable.ask('hi')
+    await nextTick()
+    expect(composable.messages.value.length).toBeGreaterThan(0)
+
+    composable.reset()
+    await nextTick()
+    expect(composable.messages.value).toHaveLength(0)
+    expect(composable.error.value).toBeNull()
+    expect(composable.conversationId.value).toBeNull()
+  })
+
+  it('unmounting unsubscribes handlers (no memory leak)', async () => {
+    mockFetchSSE(['done', { turnId: 't' }])
+    const { wrapper, composable } = mountComposable()
+    await composable.ask('hi')
+
+    // After unmount, handlers should be cleaned up
+    wrapper.unmount()
+    // No assertion on behavior — just verify it doesn't throw
+    expect(true).toBe(true)
+  })
+})