stream-chat-react-native-core 9.12.1 → 9.13.0

package/src/ai-components/__tests__/messageViews.test.tsx

@@ -0,0 +1,321 @@
+import React, { type ReactElement } from 'react';
+import { Linking, Share, Text } from 'react-native';
+
+import { act, fireEvent, render, screen } from '@testing-library/react-native';
+
+import {
+  AIAssistantMessage,
+  type AIIcon,
+  AIMessageAttachment,
+  type AIMessageAttachmentProps,
+  AIReplyActions,
+  AIUserMessage,
+  attachmentDetails,
+  defaultAIIcons,
+  formatFileSize,
+  mergeThemes,
+  parseMessageParts,
+  StreamTheme,
+} from '../index';
+import { forgetCallStates } from '../message-parts/callStates';
+import { setClipboardString } from '../services/clipboard-service';
+
+// Each test's questions start unanswered, though tests reuse calls.
+afterEach(forgetCallStates);
+
+jest.mock('../services/clipboard-service', () => ({ setClipboardString: jest.fn() }));
+
+const renderWithTheme = (ui: ReactElement) => render(<StreamTheme>{ui}</StreamTheme>);
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  jest.useRealTimers();
+});
+
+describe('formatFileSize', () => {
+  it('writes three significant digits in the largest unit that fits', () => {
+    expect(formatFileSize(0)).toBe('0.00 B');
+    expect(formatFileSize(512)).toBe('512 B');
+    expect(formatFileSize(2_453_000)).toBe('2.34 MB');
+  });
+
+  it('rounds a size just below the next unit instead of turning exponential', () => {
+    expect(formatFileSize(1000)).toBe('1000 B');
+    expect(formatFileSize(1023 * 1024)).toBe('1023 kB');
+  });
+});
+
+describe('attachmentDetails', () => {
+  it('joins the type and the size', () => {
+    expect(attachmentDetails({ kind: 'file', name: 'report.pdf', size: 2_453_000 })).toBe(
+      'PDF · 2.34 MB',
+    );
+  });
+
+  it('takes the type from the URL, then the media type', () => {
+    expect(attachmentDetails({ kind: 'file', url: 'https://x.io/a/notes.txt?v=1' })).toBe('TXT');
+    expect(attachmentDetails({ kind: 'file', mimeType: 'image/svg+xml' })).toBe('SVG');
+  });
+
+  it('is empty with nothing to say', () => {
+    expect(attachmentDetails({ kind: 'file' })).toBe('');
+  });
+});
+
+describe('AIMessageAttachment', () => {
+  it('shows an image as a thumbnail named for it, which does not open', () => {
+    const openURL = jest.spyOn(Linking, 'openURL').mockResolvedValue(undefined);
+    renderWithTheme(
+      <AIMessageAttachment attachment={{ kind: 'image', url: 'https://x.io/cat.png' }} />,
+    );
+    expect(screen.getByLabelText('cat.png')).toBeTruthy();
+    expect(screen.queryByRole('imagebutton')).toBeNull();
+    expect(screen.queryByRole('link')).toBeNull();
+    expect(openURL).not.toHaveBeenCalled();
+  });
+
+  it('shows an image without a URL as a file', () => {
+    renderWithTheme(<AIMessageAttachment attachment={{ kind: 'image', name: 'photo.png' }} />);
+    expect(screen.getByText('photo.png')).toBeTruthy();
+    expect(screen.getByText('PNG')).toBeTruthy();
+  });
+
+  it('shows a file with its name, type and size, and opens one at a web URL', () => {
+    const openURL = jest.spyOn(Linking, 'openURL').mockResolvedValue(undefined);
+    renderWithTheme(
+      <AIMessageAttachment
+        attachment={{ kind: 'file', name: 'report.pdf', size: 2_453_000, url: 'https://x.io/r' }}
+      />,
+    );
+    expect(screen.getByText('report.pdf')).toBeTruthy();
+    expect(screen.getByText('PDF · 2.34 MB')).toBeTruthy();
+    fireEvent.press(screen.getByRole('link'));
+    expect(openURL).toHaveBeenCalledWith('https://x.io/r');
+  });
+
+  it("doesn't open anything but a web URL", () => {
+    renderWithTheme(
+      <AIMessageAttachment attachment={{ kind: 'file', name: 'x', url: 'javascript:alert(1)' }} />,
+    );
+    expect(screen.queryByRole('link')).toBeNull();
+  });
+
+  it('names one without a name by its kind, and shows a kind it does not know as a file', () => {
+    renderWithTheme(<AIMessageAttachment attachment={{ kind: 'image' }} />);
+    expect(screen.getByText('Image')).toBeTruthy();
+    renderWithTheme(<AIMessageAttachment attachment={{ kind: 'audio' }} />);
+    expect(screen.getByText('File')).toBeTruthy();
+  });
+});
+
+describe('AIUserMessage', () => {
+  it('shows the text and the attachments', () => {
+    renderWithTheme(
+      <AIUserMessage attachments={[{ kind: 'file', name: 'a.pdf' }]} text='Summarise this' />,
+    );
+    expect(screen.getByText('Summarise this')).toBeTruthy();
+    expect(screen.getByText('a.pdf')).toBeTruthy();
+  });
+
+  it('offers editing only with onEdit', () => {
+    const onEdit = jest.fn();
+    const { rerender } = renderWithTheme(<AIUserMessage text='Hi' />);
+    expect(screen.queryByRole('button', { name: 'Edit' })).toBeNull();
+    rerender(
+      <StreamTheme>
+        <AIUserMessage onEdit={onEdit} text='Hi' />
+      </StreamTheme>,
+    );
+    fireEvent.press(screen.getByRole('button', { name: 'Edit' }));
+    expect(onEdit).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows no bubble for a message of attachments alone', () => {
+    renderWithTheme(<AIUserMessage attachments={[{ kind: 'file', name: 'a.pdf' }]} text='' />);
+    expect(screen.queryByRole('button', { name: 'Edit' })).toBeNull();
+    expect(screen.getByText('a.pdf')).toBeTruthy();
+  });
+});
+
+describe('AIAssistantMessage', () => {
+  it('shows the steps, then the answer, then the attachments', () => {
+    const parts = parseMessageParts([
+      { id: 'r1', status: 'completed', summary: 'Looked it up', type: 'ai_reasoning' },
+    ]);
+    renderWithTheme(
+      <AIAssistantMessage
+        attachments={[{ kind: 'file', name: 'chart.csv' }]}
+        parts={parts}
+        text='The answer'
+      />,
+    );
+    expect(screen.getByTestId('ai-message-parts')).toBeTruthy();
+    expect(screen.getByText('The answer')).toBeTruthy();
+    expect(screen.getByText('chart.csv')).toBeTruthy();
+  });
+
+  it('starts its steps afresh for another message, whose step ids may repeat', () => {
+    // Every reply's first reasoning step can be `r1`: only the message tells them apart.
+    const parts = parseMessageParts([
+      { id: 'r1', status: 'completed', summary: 'Looked it up', type: 'ai_reasoning' },
+    ]);
+    const view = (id: string) => (
+      <StreamTheme>
+        <AIAssistantMessage
+          id={id}
+          parts={parts}
+          reasoningText={() => 'The whole thought'}
+          text='The answer'
+        />
+      </StreamTheme>
+    );
+    const { rerender } = render(view('a'));
+    fireEvent.press(screen.getByRole('button', { expanded: false }));
+    expect(screen.getByText('The whole thought')).toBeTruthy();
+
+    rerender(view('a'));
+    expect(screen.getByRole('button', { expanded: true })).toBeTruthy();
+
+    // As when a list reuses the view for another reply.
+    rerender(view('b'));
+    expect(screen.getByRole('button', { expanded: false })).toBeTruthy();
+    expect(screen.queryByText('The whole thought')).toBeNull();
+  });
+
+  it('is busy while the agent writes it', () => {
+    renderWithTheme(<AIAssistantMessage isGenerating text='Partial' />);
+    expect(screen.getByTestId('ai-assistant-message').props.accessibilityState).toEqual({
+      busy: true,
+    });
+  });
+
+  it('shows nothing of the answer before it has text', () => {
+    renderWithTheme(<AIAssistantMessage text='' />);
+    expect(screen.queryByTestId('ai-message-parts')).toBeNull();
+  });
+});
+
+describe('AIReplyActions', () => {
+  it('copies the text and shows it was copied for a moment', () => {
+    jest.useFakeTimers();
+    renderWithTheme(<AIReplyActions text='The answer' />);
+    fireEvent.press(screen.getByRole('button', { name: 'Copy' }));
+    expect(setClipboardString).toHaveBeenCalledWith('The answer');
+    expect(screen.getByRole('button', { name: 'Copied' })).toBeTruthy();
+    act(() => {
+      jest.advanceTimersByTime(1500);
+    });
+    expect(screen.getByRole('button', { name: 'Copy' })).toBeTruthy();
+  });
+
+  it('shares the text through the system share sheet', () => {
+    const share = jest
+      .spyOn(Share, 'share')
+      .mockResolvedValue({ action: 'sharedAction', activityType: undefined });
+    renderWithTheme(<AIReplyActions text='The answer' />);
+    fireEvent.press(screen.getByRole('button', { name: 'Share' }));
+    expect(share).toHaveBeenCalledWith({ message: 'The answer' });
+  });
+
+  it('offers regenerating and rating only when given what they do', () => {
+    renderWithTheme(<AIReplyActions text='x' />);
+    expect(screen.queryByRole('button', { name: 'Regenerate' })).toBeNull();
+    expect(screen.queryByRole('button', { name: 'Good response' })).toBeNull();
+  });
+
+  it('regenerates', () => {
+    const onRegenerate = jest.fn();
+    renderWithTheme(<AIReplyActions onRegenerate={onRegenerate} text='x' />);
+    fireEvent.press(screen.getByRole('button', { name: 'Regenerate' }));
+    expect(onRegenerate).toHaveBeenCalledTimes(1);
+  });
+
+  it('rates, and takes a rating back', () => {
+    const onRate = jest.fn();
+    const { rerender } = renderWithTheme(<AIReplyActions onRate={onRate} text='x' />);
+    fireEvent.press(screen.getByRole('button', { name: 'Bad response' }));
+    expect(onRate).toHaveBeenLastCalledWith('negative');
+
+    rerender(
+      <StreamTheme>
+        <AIReplyActions onRate={onRate} rating='positive' text='x' />
+      </StreamTheme>,
+    );
+    const good = screen.getByRole('button', { name: 'Good response' });
+    expect(good.props.accessibilityState).toEqual({ selected: true });
+    fireEvent.press(good);
+    expect(onRate).toHaveBeenLastCalledWith(null);
+  });
+});
+
+const iconNamed =
+  (name: string): AIIcon =>
+  () => <Text>{`icon:${name}`}</Text>;
+
+describe('icons', () => {
+  it('draws with the theme’s icons over the defaults', () => {
+    render(
+      <StreamTheme style={{ icons: { Copy: iconNamed('Copy'), Share: iconNamed('Share') } }}>
+        <AIReplyActions onRate={jest.fn()} text='x' />
+      </StreamTheme>,
+    );
+    expect(screen.getByText('icon:Copy')).toBeTruthy();
+    expect(screen.getByText('icon:Share')).toBeTruthy();
+    expect(screen.queryByText('icon:ThumbsUp')).toBeNull();
+  });
+
+  it('keeps icons as they are when themes merge', () => {
+    const Copy = iconNamed('Copy');
+    const Share = iconNamed('Share');
+    const theme = mergeThemes({ style: { icons: { Copy } } });
+    expect(theme.icons?.Copy).toBe(Copy);
+    const merged = mergeThemes({ style: { icons: { Share } }, theme });
+    expect(merged.icons).toEqual({ Copy, Share });
+    expect(merged.colors).toEqual(theme.colors);
+  });
+
+  it.each([
+    [{ kind: 'file', name: 'report.pdf' }, 'Pdf'],
+    [{ kind: 'file', mimeType: 'application/pdf', name: 'report' }, 'Pdf'],
+    [{ kind: 'file', name: 'song.mp3' }, 'Audio'],
+    [{ kind: 'file', mimeType: 'video/mp4', name: 'clip' }, 'Video'],
+    [{ kind: 'file', name: 'backup.zip' }, 'Archive'],
+    [{ kind: 'file', mimeType: 'application/vnd.rar', name: 'x' }, 'Archive'],
+    [{ kind: 'image', name: 'photo' }, 'Image'],
+    [{ kind: 'file', name: 'notes.txt' }, 'File'],
+  ])('gives a file of %o the %s icon', (attachment, icon) => {
+    const icons = Object.fromEntries(
+      Object.keys(defaultAIIcons).map((name) => [name, iconNamed(name)]),
+    );
+    render(
+      <StreamTheme style={{ icons }}>
+        <AIMessageAttachment attachment={attachment} />
+      </StreamTheme>,
+    );
+    expect(screen.getByText(`icon:${icon}`)).toBeTruthy();
+  });
+});
+
+describe('Attachment slot', () => {
+  const Mine = ({ attachment, role }: AIMessageAttachmentProps) => (
+    <Text>{`mine:${role}:${attachment.name}`}</Text>
+  );
+
+  it('shows the person’s attachments with a view of your own', () => {
+    renderWithTheme(
+      <AIUserMessage Attachment={Mine} attachments={[{ kind: 'file', name: 'a.pdf' }]} text='' />,
+    );
+    expect(screen.getByText('mine:user:a.pdf')).toBeTruthy();
+  });
+
+  it('shows the agent’s attachments with a view of your own', () => {
+    renderWithTheme(
+      <AIAssistantMessage
+        Attachment={Mine}
+        attachments={[{ kind: 'file', name: 'b.csv' }]}
+        text='x'
+      />,
+    );
+    expect(screen.getByText('mine:assistant:b.csv')).toBeTruthy();
+  });
+});

package/src/ai-components/__tests__/signIn.test.tsx

@@ -0,0 +1,324 @@
+import React, { type ReactElement } from 'react';
+
+import { act, fireEvent, render, screen } from '@testing-library/react-native';
+
+import {
+  AIClientIdentity,
+  AIConnectorSignInError,
+  AIMessagePart,
+  type AIToolApprover,
+  AIToolApproverProvider,
+  AIToolAuthorization,
+  AIToolAuthorizationCard,
+  type AIToolAuthorizer,
+  type AIToolCallPart,
+  createAuthSessionAuthorizer,
+  parseMessagePart,
+  readConnectorSignInResult,
+  signInLaunchUrl,
+  StreamTheme,
+} from '../index';
+import { forgetCallStates } from '../message-parts/callStates';
+import NativeAIAgent from '../native-specs/NativeAIAgent';
+
+// Each test's questions start unanswered, though tests reuse calls.
+afterEach(forgetCallStates);
+
+jest.mock('../native-specs/NativeAIAgent', () => ({
+  __esModule: true,
+  default: { installId: jest.fn(), openAuthSession: jest.fn() },
+}));
+
+const native = NativeAIAgent as unknown as {
+  installId: jest.Mock;
+  openAuthSession: jest.Mock;
+};
+
+const renderWithTheme = (ui: ReactElement) => {
+  const result = render(<StreamTheme>{ui}</StreamTheme>);
+  return {
+    ...result,
+    rerender: (next: ReactElement) => result.rerender(<StreamTheme>{next}</StreamTheme>),
+  };
+};
+
+const signIn = parseMessagePart({
+  authorization: {
+    handoff_token: 'tok',
+    provider: 'linear',
+    provider_name: 'Linear',
+    title: 'Connect Linear',
+    type: 'oauth',
+    url: 'https://router.example.com/launch/abc',
+  },
+  id: 'call_2',
+  name: 'linear_create_issue',
+  status: 'awaiting_authorization',
+  target_user_id: 'alex',
+  type: 'ai_tool_call',
+})?.toolCall as AIToolCallPart;
+
+const approverWith = (authorizer?: AIToolAuthorizer): AIToolApprover => ({
+  authorizer,
+  clientId: 'ios-1',
+  decide: jest.fn(() => Promise.resolve()),
+  userId: 'alex',
+});
+
+describe('AIToolAuthorization', () => {
+  it('asks nothing without an authorizer, or of another person', () => {
+    const { rerender } = renderWithTheme(
+      <AIToolAuthorization approver={approverWith()} part={signIn} />,
+    );
+    expect(screen.queryByText('Connect Linear')).toBeNull();
+    rerender(
+      <AIToolAuthorization
+        approver={{ ...approverWith({ connect: jest.fn(), decline: jest.fn() }), userId: 'sam' }}
+        part={signIn}
+      />,
+    );
+    expect(screen.queryByText('Connect Linear')).toBeNull();
+  });
+
+  it('connects, and lets the person try again when the sign-in ends unconnected', async () => {
+    let finish: (connected: boolean) => void = () => undefined;
+    const connect = jest.fn(
+      () =>
+        new Promise<boolean>((resolve) => {
+          finish = resolve;
+        }),
+    );
+    renderWithTheme(
+      <AIToolAuthorization
+        approver={approverWith({ connect, decline: jest.fn() })}
+        part={signIn}
+      />,
+    );
+    fireEvent.press(screen.getByRole('button', { name: 'Connect' }));
+    expect(connect).toHaveBeenCalledWith(signIn);
+    expect(screen.getByRole('button', { name: 'Connecting...' })).toBeDisabled();
+    // Not now stays available while the sign-in is open.
+    expect(screen.getByRole('button', { name: 'Not now' })).toBeEnabled();
+
+    await act(async () => {
+      finish(false);
+      await Promise.resolve();
+    });
+    expect(screen.getByRole('button', { name: 'Connect' })).toBeEnabled();
+  });
+
+  it('declines a sign-in the person closed, which cannot be opened again', async () => {
+    const decline = jest.fn(() => Promise.reject(new Error('offline')));
+    renderWithTheme(
+      <AIToolAuthorization
+        approver={approverWith({ connect: () => Promise.resolve('closed'), decline })}
+        part={signIn}
+      />,
+    );
+    fireEvent.press(screen.getByRole('button', { name: 'Connect' }));
+    await act(() => Promise.resolve());
+    expect(decline).toHaveBeenCalledWith(signIn);
+
+    // As with "Not now", an answer that couldn't be sent can be given again.
+    await act(() => Promise.resolve());
+    expect(screen.getByText("Your answer couldn't be sent. Try again.")).toBeTruthy();
+    expect(screen.getByRole('button', { name: 'Not now' })).toBeEnabled();
+  });
+
+  it('keeps connecting once connected, until the step changes', async () => {
+    renderWithTheme(
+      <AIToolAuthorization
+        approver={approverWith({ connect: () => Promise.resolve(true), decline: jest.fn() })}
+        part={signIn}
+      />,
+    );
+    fireEvent.press(screen.getByRole('button', { name: 'Connect' }));
+    await act(() => Promise.resolve());
+    expect(screen.getByRole('button', { name: 'Connecting...' })).toBeDisabled();
+  });
+
+  it('says when the sign-in could not open, and lets the person try again', async () => {
+    const connect = jest.fn(() => Promise.reject(new AIConnectorSignInError('failed')));
+    renderWithTheme(
+      <AIToolAuthorization
+        approver={approverWith({ connect, decline: jest.fn() })}
+        part={signIn}
+      />,
+    );
+    fireEvent.press(screen.getByRole('button', { name: 'Connect' }));
+    await act(() => Promise.resolve());
+    expect(screen.getByText("The sign-in couldn't be opened. Try again.")).toBeTruthy();
+    expect(screen.getByRole('button', { name: 'Connect' })).toBeEnabled();
+  });
+
+  it('declines, and lets the person answer again when that fails', async () => {
+    const decline = jest.fn(() => Promise.reject(new Error('offline')));
+    renderWithTheme(
+      <AIToolAuthorization
+        approver={approverWith({ connect: jest.fn(), decline })}
+        part={signIn}
+      />,
+    );
+    fireEvent.press(screen.getByRole('button', { name: 'Not now' }));
+    expect(decline).toHaveBeenCalledWith(signIn);
+    expect(screen.getByRole('button', { name: 'Not now' })).toBeDisabled();
+    await act(() => Promise.resolve());
+    expect(screen.getByText("Your answer couldn't be sent. Try again.")).toBeTruthy();
+    expect(screen.getByRole('button', { name: 'Not now' })).toBeEnabled();
+  });
+
+  it.each([
+    ['connected', 'Connected to Linear'],
+    ['declined', 'Not connected'],
+    ['failed', "The sign-in didn't complete."],
+    ['expired', 'This sign-in has expired.'],
+  ])('says how a %s sign-in ended, without buttons', (status, outcome) => {
+    renderWithTheme(
+      <AIToolAuthorizationCard
+        authorization={{ ...signIn.authorization!, status }}
+        onConnect={jest.fn()}
+        onDecline={jest.fn()}
+      />,
+    );
+    expect(screen.getByText(outcome)).toBeTruthy();
+    expect(screen.queryByRole('button', { name: 'Connect' })).toBeNull();
+  });
+
+  it('can no longer be opened past its expiry', () => {
+    renderWithTheme(
+      <AIToolAuthorizationCard
+        authorization={{ ...signIn.authorization!, expiresAt: Date.now() - 1 }}
+        onConnect={jest.fn()}
+        onDecline={jest.fn()}
+      />,
+    );
+    expect(screen.getByText('This sign-in has expired.')).toBeTruthy();
+    expect(screen.queryByRole('button', { name: 'Connect' })).toBeNull();
+    expect(screen.getByRole('button', { name: 'Not now' })).toBeEnabled();
+  });
+
+  it('is asked under its tool call, with the approver of the provider', () => {
+    renderWithTheme(
+      <AIToolApproverProvider approver={approverWith({ connect: jest.fn(), decline: jest.fn() })}>
+        <AIMessagePart part={parseMessagePart({ ...signInAttachment, type: 'ai_tool_call' })!} />
+      </AIToolApproverProvider>,
+    );
+    expect(screen.getByText('Connect Linear')).toBeTruthy();
+    expect(screen.getByText('Waiting for you to sign in')).toBeTruthy();
+  });
+});
+
+const signInAttachment = {
+  authorization: {
+    handoff_token: 'tok',
+    provider: 'linear',
+    title: 'Connect Linear',
+    type: 'oauth',
+    url: 'https://router.example.com/launch/abc',
+  },
+  id: 'call_3',
+  name: 'linear_list_issues',
+  status: 'awaiting_authorization',
+  target_user_id: 'alex',
+};
+
+describe('createAuthSessionAuthorizer', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('puts the handoff token in the launch page’s fragment, encoded', () => {
+    expect(signInLaunchUrl({ ...signIn.authorization!, handoffToken: 'a+b&c=d/e' })).toBe(
+      'https://router.example.com/launch/abc#handoff_token=a%2Bb%26c%3Dd%2Fe',
+    );
+    expect(signInLaunchUrl({ ...signIn.authorization!, handoffToken: undefined })).toBe(
+      'https://router.example.com/launch/abc',
+    );
+  });
+
+  it('opens the sign-in for the app’s scheme, and reads how it ended', async () => {
+    const decline = jest.fn(() => Promise.resolve());
+    const authorizer = createAuthSessionAuthorizer({ callbackScheme: 'myapp', decline });
+
+    native.openAuthSession.mockResolvedValueOnce(
+      'myapp://signed-in?connection_id=c1&status=connected',
+    );
+    await expect(authorizer.connect(signIn)).resolves.toBe(true);
+    expect(native.openAuthSession).toHaveBeenCalledWith(
+      'https://router.example.com/launch/abc#handoff_token=tok',
+      'myapp',
+    );
+
+    native.openAuthSession.mockResolvedValueOnce(
+      'myapp://signed-in?connection_id=c1&status=denied',
+    );
+    await expect(authorizer.connect(signIn)).resolves.toBe(false);
+
+    // The person closed the sheet: the sign-in can't be opened again.
+    native.openAuthSession.mockResolvedValueOnce('');
+    await expect(authorizer.connect(signIn)).resolves.toBe('closed');
+
+    await authorizer.decline(signIn);
+    expect(decline).toHaveBeenCalledWith(signIn);
+  });
+
+  it('takes the app’s scheme written as the start of a URL', async () => {
+    for (const written of ['myapp://', 'myapp:', ' myapp:/ ']) {
+      const authorizer = createAuthSessionAuthorizer({
+        callbackScheme: written,
+        decline: jest.fn(),
+      });
+      expect(authorizer.callbackScheme).toBe('myapp');
+      native.openAuthSession.mockResolvedValueOnce('');
+      await authorizer.connect(signIn);
+      expect(native.openAuthSession).toHaveBeenLastCalledWith(expect.any(String), 'myapp');
+    }
+  });
+
+  it('lets a closed sign-in be tried again with declineOnClose off', async () => {
+    const authorizer = createAuthSessionAuthorizer({
+      callbackScheme: 'myapp',
+      decline: jest.fn(),
+      declineOnClose: false,
+    });
+    native.openAuthSession.mockResolvedValueOnce('');
+    await expect(authorizer.connect(signIn)).resolves.toBe(false);
+  });
+
+  it('rejects when the sign-in could not be opened', async () => {
+    const authorizer = createAuthSessionAuthorizer({ callbackScheme: 'myapp', decline: jest.fn() });
+
+    native.openAuthSession.mockRejectedValueOnce(new Error('No browser'));
+    await expect(authorizer.connect(signIn)).rejects.toMatchObject({
+      message: 'No browser',
+      reason: 'failed',
+    });
+    await expect(authorizer.connect({ ...signIn, authorization: undefined })).rejects.toMatchObject(
+      { reason: 'unavailable' },
+    );
+  });
+
+  it('reads only an outcome the router sends', () => {
+    expect(readConnectorSignInResult('myapp://x?status=connected&connection_id=conn-1')).toEqual({
+      connectionId: 'conn-1',
+      status: 'connected',
+    });
+    expect(readConnectorSignInResult('myapp://x?status=maybe&connection_id=conn-1')).toBeNull();
+    expect(readConnectorSignInResult('myapp://x?status=connected')).toBeNull();
+    expect(readConnectorSignInResult('myapp://x')).toBeNull();
+  });
+});
+
+describe('AIClientIdentity', () => {
+  it('is the install id the native module keeps', () => {
+    native.installId.mockReturnValue('ios-ABC');
+    expect(AIClientIdentity.installId()).toBe('ios-ABC');
+  });
+
+  it('lives in memory, unchanged, when the native module has none', () => {
+    native.installId.mockImplementation(() => {
+      throw new Error('not linked');
+    });
+    const first = AIClientIdentity.installId();
+    expect(first).toMatch(/^(ios|android)-[0-9a-f]{32}$/);
+    expect(AIClientIdentity.installId()).toBe(first);
+  });
+});

package/src/ai-components/__tests__/theme.test.tsx

@@ -38,4 +38,22 @@ describe('ai-components theme', () => {
     });
     expect(preMerged.current.theme).toBe(mergedStyle);
   });
+  it('draws the conversation’s parts in the app’s palette when it changes it, as for dark mode', () => {
+    const dark = mergeThemes({
+      style: {
+        colors: { black: '#FFFFFF', grey_whisper: '#27272F', white: '#050509' },
+        suggestions: { text: '#FF0000' },
+      },
+    });
+    expect(dark.message?.userMessageBackground).toBe('#27272F');
+    expect(dark.message?.userMessageText).toBe('#FFFFFF');
+    expect(dark.conversation?.scrollButtonBackground).toBe('#050509');
+    // A part the style sets keeps its own; one drawn in a color it left alone keeps the design's.
+    expect(dark.suggestions?.text).toBe('#FF0000');
+    expect(dark.chatOptions?.chipText).toBe(defaultTheme.chatOptions?.chipText);
+    // Without palette changes, the design's own colors stay.
+    expect(mergeThemes({ style: { conversation: {} } }).message?.userMessageBackground).toBe(
+      defaultTheme.message?.userMessageBackground,
+    );
+  });
 });