stream-chat-react-native-core 9.12.1-beta.1 → 9.13.0

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

@@ -0,0 +1,343 @@
+import React, { type ReactElement } from 'react';
+import { I18nManager } from 'react-native';
+
+import { act, fireEvent, render, screen } from '@testing-library/react-native';
+
+import {
+  AIMessagePart,
+  type AIMessagePartData,
+  AIMessageParts,
+  AIReasoning,
+  AIThinking,
+  AIToolApproval,
+  AIToolApprovalCard,
+  type AIToolApprover,
+  AIToolCall,
+  type AIToolCallPart,
+  parseMessagePart,
+  StreamTheme,
+} from '../index';
+import { forgetCallStates } from '../message-parts/callStates';
+
+// Each test's questions start unanswered, though tests reuse calls.
+afterEach(forgetCallStates);
+
+const renderWithTheme = (ui: ReactElement) => {
+  const result = render(<StreamTheme>{ui}</StreamTheme>);
+  return {
+    ...result,
+    rerender: (next: ReactElement) => result.rerender(<StreamTheme>{next}</StreamTheme>),
+  };
+};
+
+const toolCall = (overrides: Partial<AIToolCallPart> = {}): AIToolCallPart => ({
+  executor: 'server',
+  id: 'call_1',
+  name: 'get_weather',
+  status: 'running',
+  ...overrides,
+});
+
+describe('AIToolCall', () => {
+  it('names the call from its display title, else its name', () => {
+    const { rerender } = renderWithTheme(
+      <AIToolCall part={toolCall({ displayTitle: 'Checking the weather' })} />,
+    );
+    expect(screen.getByText('Checking the weather')).toBeTruthy();
+    rerender(<AIToolCall part={toolCall()} />);
+    expect(screen.getByText('get weather')).toBeTruthy();
+  });
+
+  it.each([
+    ['awaiting_approval', 'Waiting for approval'],
+    ['awaiting_authorization', 'Waiting for you to sign in'],
+    ['awaiting_client', 'Waiting for the device'],
+    ['failed', "Didn't complete"],
+    ['cancelled', 'Cancelled'],
+  ])('says what a %s call waits for', (status, detail) => {
+    renderWithTheme(<AIToolCall part={toolCall({ status })} />);
+    expect(screen.getByText(detail)).toBeTruthy();
+  });
+
+  it('prefers the summary, and says a declined call was declined', () => {
+    const { rerender } = renderWithTheme(
+      <AIToolCall part={toolCall({ status: 'failed', summary: 'No network' })} />,
+    );
+    expect(screen.getByText('No network')).toBeTruthy();
+    rerender(
+      <AIToolCall
+        part={toolCall({
+          approval: { decision: 'declined', title: 'Share?' },
+          status: 'cancelled',
+        })}
+      />,
+    );
+    expect(screen.getByText('Declined')).toBeTruthy();
+  });
+
+  it('shows how long a finished call took', () => {
+    const { rerender } = renderWithTheme(
+      <AIToolCall part={toolCall({ durationMs: 420, status: 'completed' })} />,
+    );
+    expect(screen.getByText('0.4s')).toBeTruthy();
+    rerender(<AIToolCall part={toolCall({ durationMs: 65_000, status: 'completed' })} />);
+    expect(screen.getByText('1m 5s')).toBeTruthy();
+    rerender(<AIToolCall part={toolCall({ durationMs: 65_000, status: 'running' })} />);
+    expect(screen.queryByText('1m 5s')).toBeNull();
+  });
+});
+
+describe('AIToolApprovalCard', () => {
+  it('asks with the reason as a sentence and the agent’s own button titles', () => {
+    const onDecide = jest.fn();
+    renderWithTheme(
+      <AIToolApprovalCard
+        approval={{
+          allowTitle: 'Share',
+          message: 'Only your city is shared.',
+          reason: 'to check the local weather',
+          title: 'Share your location?',
+        }}
+        onDecide={onDecide}
+      />,
+    );
+    expect(screen.getByText('To check the local weather.')).toBeTruthy();
+    expect(screen.getByText('Only your city is shared.')).toBeTruthy();
+    fireEvent.press(screen.getByRole('button', { name: 'Share' }));
+    fireEvent.press(screen.getByRole('button', { name: "Don't Allow" }));
+    expect(onDecide.mock.calls).toEqual([[true], [false]]);
+  });
+});
+
+describe('AIToolApproval', () => {
+  const asking = toolCall({
+    approval: { title: 'Share your location?' },
+    executor: 'client',
+    status: 'awaiting_approval',
+    targetClientId: 'ios-1',
+    targetUserId: 'alex',
+  });
+  const approver = (decide: AIToolApprover['decide']): AIToolApprover => ({
+    clientId: 'ios-1',
+    decide,
+    userId: 'alex',
+  });
+
+  it('asks only the targeted person on the targeted install', () => {
+    const decide = jest.fn(() => Promise.resolve());
+    const { rerender } = renderWithTheme(<AIToolApproval part={asking} />);
+    expect(screen.queryByText('Share your location?')).toBeNull();
+    rerender(<AIToolApproval approver={{ ...approver(decide), userId: 'sam' }} part={asking} />);
+    expect(screen.queryByText('Share your location?')).toBeNull();
+    rerender(<AIToolApproval approver={approver(decide)} part={asking} />);
+    expect(screen.getByText('Share your location?')).toBeTruthy();
+  });
+
+  it('keeps an answer on its way when a list remounts or reuses the row', () => {
+    const decide = jest.fn(() => new Promise<void>(() => undefined));
+    const other = { ...asking, id: 'call-2' };
+    const { rerender, unmount } = renderWithTheme(
+      <AIToolApproval approver={approver(decide)} part={asking} />,
+    );
+    fireEvent.press(screen.getByRole('button', { name: 'Allow' }));
+    // The row now shows another call: its question starts unanswered.
+    rerender(<AIToolApproval approver={approver(decide)} part={other} />);
+    expect(screen.getByRole('button', { name: 'Allow' })).toBeEnabled();
+    unmount();
+    // The first call's row comes back: its answer is still on its way, so it can't be sent twice.
+    renderWithTheme(<AIToolApproval approver={approver(decide)} part={asking} />);
+    expect(screen.getByRole('button', { name: 'Allow' })).toBeDisabled();
+    fireEvent.press(screen.getByRole('button', { name: "Don't Allow" }));
+    expect(decide).toHaveBeenCalledTimes(1);
+  });
+
+  it('sends the answer once, and lets the person answer again when it fails', async () => {
+    let fail: () => void = () => undefined;
+    const decide = jest.fn(
+      () =>
+        new Promise<void>((_, reject) => {
+          fail = () => reject(new Error('offline'));
+        }),
+    );
+    renderWithTheme(<AIToolApproval approver={approver(decide)} part={asking} />);
+
+    fireEvent.press(screen.getByRole('button', { name: 'Allow' }));
+    fireEvent.press(screen.getByRole('button', { name: 'Allow' }));
+    expect(decide).toHaveBeenCalledTimes(1);
+    expect(decide).toHaveBeenCalledWith(asking, true);
+    expect(screen.getByRole('button', { name: 'Allow' })).toBeDisabled();
+
+    await act(async () => {
+      fail();
+      await Promise.resolve();
+    });
+    expect(screen.getByText("Your answer couldn't be sent. Try again.")).toBeTruthy();
+    expect(screen.getByRole('button', { name: 'Allow' })).toBeEnabled();
+  });
+});
+
+describe('AIMessagePart', () => {
+  it('shows a placeholder for a step it cannot show', () => {
+    renderWithTheme(<AIMessagePart part={parseMessagePart({ id: 'x', type: 'ai_citation' })!} />);
+    expect(screen.getByText("A step this app version can't show")).toBeTruthy();
+  });
+});
+
+describe('AIReasoning', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  it('counts the seconds while thinking, and folds when done', () => {
+    jest.useFakeTimers();
+    const text = 'First thought.\n\n## Plan\nSecond thought.';
+    const { rerender } = renderWithTheme(<AIReasoning isThinking text={text} />);
+    expect(screen.getByRole('button', { expanded: true, name: /Thinking\.\.\./ })).toBeTruthy();
+    expect(screen.getByText('Plan')).toBeTruthy();
+
+    act(() => jest.advanceTimersByTime(7_000));
+    expect(screen.getByText('Thinking... 7s')).toBeTruthy();
+
+    rerender(
+      <AIReasoning duration={12} isThinking={false} summary='Planned the day' text={text} />,
+    );
+    expect(screen.getByRole('button', { expanded: false, name: /Thought for 12s/ })).toBeTruthy();
+    expect(screen.getByText('Planned the day')).toBeTruthy();
+    expect(screen.queryByText('Plan')).toBeNull();
+
+    fireEvent.press(screen.getByRole('button', { name: /Thought for 12s/ }));
+    expect(screen.getByRole('button', { expanded: true, name: /Thought for 12s/ })).toBeTruthy();
+    expect(screen.getByText('Plan')).toBeTruthy();
+  });
+
+  it('shows a step’s live text, else its preview', () => {
+    const part = { durationMs: 2000, id: 'r1', preview: 'The opening', status: 'completed' };
+    const { rerender } = renderWithTheme(
+      <AIReasoning initiallyExpanded part={part} reasoningText={() => 'The whole thought'} />,
+    );
+    expect(screen.getByText('The whole thought')).toBeTruthy();
+    expect(screen.getByRole('button', { name: /Thought for 2s/ })).toBeTruthy();
+    rerender(<AIReasoning initiallyExpanded part={part} />);
+    expect(screen.getByText('The opening')).toBeTruthy();
+  });
+
+  it('starts afresh for another step, as when a list reuses the view', () => {
+    const step = (id: string, preview: string) => ({
+      durationMs: 3000,
+      id,
+      preview,
+      status: 'completed',
+    });
+    const { rerender } = renderWithTheme(
+      <AIReasoning part={step('r1', 'First')} stepKey='m1:r1' />,
+    );
+    fireEvent.press(screen.getByRole('button', { name: /Thought for 3s/ }));
+    expect(screen.getByText('First')).toBeTruthy();
+
+    // The same step id in another message is another step: folded until its reader opens it.
+    rerender(<AIReasoning part={step('r1', 'Second')} stepKey='m2:r1' />);
+    expect(screen.getByRole('button', { expanded: false, name: /Thought for 3s/ })).toBeTruthy();
+    expect(screen.queryByText('Second')).toBeNull();
+
+    // While the step stays the same, what its reader chose stays too.
+    fireEvent.press(screen.getByRole('button', { name: /Thought for 3s/ }));
+    rerender(<AIReasoning part={step('r1', 'Second, longer')} stepKey='m2:r1' />);
+    expect(screen.getByText('Second, longer')).toBeTruthy();
+  });
+
+  it('keeps the chevron that turns for another step, folded', () => {
+    const step = (id: string, preview: string) => ({
+      durationMs: 3000,
+      id,
+      preview,
+      status: 'completed',
+    });
+    const turning = () =>
+      screen.UNSAFE_root.findAll(
+        (node) =>
+          typeof node.type !== 'string' &&
+          JSON.stringify(node.props?.style ?? '').includes('rotate'),
+      );
+    const { rerender } = renderWithTheme(
+      <AIReasoning part={step('r1', 'First')} stepKey='m1:r1' />,
+    );
+    expect(turning()).toHaveLength(0);
+    fireEvent.press(screen.getByRole('button', { name: /Thought for 3s/ }));
+    const [chevron] = turning();
+    expect(chevron).toBeTruthy();
+
+    rerender(<AIReasoning part={step('r1', 'Second')} stepKey='m2:r1' />);
+    expect(screen.getByRole('button', { expanded: false, name: /Thought for 3s/ })).toBeTruthy();
+    expect(screen.queryByText('Second')).toBeNull();
+    expect(turning()[0]).toBe(chevron);
+
+    // And it opens the other step as it did the first.
+    fireEvent.press(screen.getByRole('button', { name: /Thought for 3s/ }));
+    expect(screen.getByText('Second')).toBeTruthy();
+    expect(turning()[0]).toBe(chevron);
+  });
+
+  it('says Thinking... for thinking that shows nothing yet', () => {
+    renderWithTheme(<AIThinking />);
+    expect(screen.getByRole('button', { expanded: false, name: 'Thinking...' })).toBeTruthy();
+  });
+
+  it('counts afresh for thinking that began later, in the same view', () => {
+    const { rerender } = renderWithTheme(<AIThinking since={Date.now() - 5000} />);
+    const view = screen.getByTestId('ai-reasoning');
+    expect(screen.getByRole('button', { name: 'Thinking... 5s' })).toBeTruthy();
+
+    rerender(<AIThinking since={Date.now()} />);
+    expect(screen.getByTestId('ai-reasoning')).toBe(view);
+    expect(screen.getByRole('button', { name: 'Thinking...' })).toBeTruthy();
+  });
+
+  it('turns the open chevron the other way in RTL', () => {
+    const rotatedBy = (degrees: string) =>
+      screen.UNSAFE_root.findAll((node) =>
+        JSON.stringify(node.props?.style ?? '').includes(`"rotate":"${degrees}"`),
+      ).length > 0;
+    const originalIsRTL = I18nManager.isRTL;
+    const setRTL = (value: boolean) =>
+      Object.defineProperty(I18nManager, 'isRTL', { configurable: true, value });
+
+    try {
+      setRTL(false);
+      const { unmount } = renderWithTheme(<AIReasoning initiallyExpanded text='A thought' />);
+      expect(rotatedBy('90deg')).toBe(true);
+      unmount();
+
+      setRTL(true);
+      renderWithTheme(<AIReasoning initiallyExpanded text='A thought' />);
+      expect(rotatedBy('-90deg')).toBe(true);
+    } finally {
+      setRTL(originalIsRTL);
+    }
+  });
+});
+
+describe('AIMessageParts', () => {
+  const reasoning = (id: string, preview: string): AIMessagePartData => ({
+    id,
+    kind: 'ai_reasoning',
+    payload: {},
+    reasoning: { durationMs: 3000, id, preview, status: 'completed' },
+    version: 1,
+  });
+
+  it('updates its views for another message’s steps, each starting afresh', () => {
+    const { rerender } = renderWithTheme(
+      <AIMessageParts messageId='m1' parts={[reasoning('r1', 'First')]} />,
+    );
+    const view = screen.getByTestId('ai-reasoning');
+    fireEvent.press(screen.getByRole('button', { name: /Thought for 3s/ }));
+    expect(screen.getByText('First')).toBeTruthy();
+
+    rerender(<AIMessageParts messageId='m2' parts={[reasoning('r1', 'Second')]} />);
+    // The same view, not one built again, showing the other step folded.
+    expect(screen.getByTestId('ai-reasoning')).toBe(view);
+    expect(screen.getByRole('button', { expanded: false, name: /Thought for 3s/ })).toBeTruthy();
+    expect(screen.queryByText('Second')).toBeNull();
+  });
+});

package/src/ai-components/__tests__/messageParts.test.ts

@@ -0,0 +1,336 @@
+import {
+  isAuthorizationExpired,
+  isAwaitingApproval,
+  isAwaitingAuthorization,
+  isAwaitingClient,
+  isDeclined,
+  isSupportedPart,
+  isToolCallFinished,
+  parseMessagePart,
+  parseMessageParts,
+} from '../message-parts';
+import type { AIToolCallPart } from '../message-parts';
+
+// Shaped as the router writes them (acceleration/internal/conversation/parts.go).
+const reasoning = {
+  duration_ms: 4200,
+  finished_at: '2026-11-02T10:00:04Z',
+  id: 'r1',
+  preview: 'Let me check the calendar first.',
+  started_at: '2026-11-02T10:00:00Z',
+  status: 'completed',
+  summary: 'Checked the calendar',
+  type: 'ai_reasoning',
+  v: 1,
+};
+
+const approvalCall = {
+  approval: {
+    allow_title: 'Share',
+    decline_title: 'Not now',
+    message: 'Only your city is shared.',
+    reason: 'to check the local weather',
+    title: 'Share your location?',
+  },
+  arguments: { reason: 'to check the local weather' },
+  display_title: 'Checking your location',
+  executor: 'client',
+  id: 'call_1',
+  name: 'get_location',
+  status: 'awaiting_approval',
+  target_client_id: 'ios-1',
+  target_user_id: 'alex',
+  type: 'ai_tool_call',
+  v: 1,
+};
+
+const authorizationCall = {
+  authorization: {
+    expires_at: '2026-11-02T10:10:00.123Z',
+    handoff_token: 'tok',
+    message: 'The agent needs your Linear account to file the issue.',
+    provider: 'linear',
+    provider_name: 'Linear',
+    title: 'Connect Linear',
+    type: 'oauth',
+    url: 'https://router.example.com/v1/agents/connectors/oauth/launch/abc',
+  },
+  display_title: 'Filing a Linear issue',
+  executor: 'server',
+  id: 'call_2',
+  name: 'linear_create_issue',
+  status: 'awaiting_authorization',
+  target_user_id: 'alex',
+  type: 'ai_tool_call',
+  v: 1,
+};
+
+const signInWithUrl = (url: string) =>
+  parseMessagePart({
+    ...authorizationCall,
+    authorization: { ...authorizationCall.authorization, url },
+  })?.toolCall?.authorization;
+
+describe('parseMessageParts', () => {
+  it('reads the steps in order and skips other attachments', () => {
+    const parts = parseMessageParts([
+      reasoning,
+      { image_url: 'https://example.com/a.png', type: 'image' },
+      approvalCall,
+      authorizationCall,
+    ]);
+    expect(parts.map((part) => part.id)).toEqual(['r1', 'call_1', 'call_2']);
+    expect(parts.map((part) => part.kind)).toEqual([
+      'ai_reasoning',
+      'ai_tool_call',
+      'ai_tool_call',
+    ]);
+    expect(parts.every(isSupportedPart)).toBe(true);
+  });
+
+  it('reads a reply as a local Vision-Agents router wrote it', () => {
+    // The attachments of one real reply, copied from the channel (2026-11-03, xai/grok-4.7).
+    const parts = parseMessageParts([
+      {
+        duration_ms: 2387,
+        finished_at: '2026-11-03T14:20:45.15695058Z',
+        id: 'r1',
+        preview: "Searching for today's top tech headline.",
+        started_at: '2026-11-03T14:20:45.156092748Z',
+        status: 'completed',
+        summary: "Searching for today's top tech headline.",
+        type: 'ai_reasoning',
+        v: 1,
+      },
+      {
+        display_title: 'Searching the web',
+        duration_ms: 687,
+        executor: 'server',
+        finished_at: '2026-11-03T14:20:45.844631174Z',
+        id: 'call-b1352079-bc55-4229-ab07-8f9c2fc5d4d7-0',
+        name: 'search',
+        started_at: '2026-11-03T14:20:45.15688333Z',
+        status: 'completed',
+        type: 'ai_tool_call',
+        v: 1,
+      },
+      {
+        duration_ms: 1884,
+        finished_at: '2026-11-03T14:20:47.729154697Z',
+        id: 'r2',
+        preview: "I will search for today's top tech headline and summarize it in one sentence.",
+        started_at: '2026-11-03T14:20:47.72908728Z',
+        status: 'completed',
+        summary: "I will search for today's top tech headline and summarize it in one sentence.",
+        type: 'ai_reasoning',
+        v: 1,
+      },
+    ]);
+    expect(parts.map((part) => part.id)).toEqual([
+      'r1',
+      'call-b1352079-bc55-4229-ab07-8f9c2fc5d4d7-0',
+      'r2',
+    ]);
+    expect(parts[0].reasoning).toEqual({
+      durationMs: 2387,
+      id: 'r1',
+      preview: "Searching for today's top tech headline.",
+      status: 'completed',
+      summary: "Searching for today's top tech headline.",
+    });
+    expect(parts[1].toolCall).toMatchObject({
+      displayTitle: 'Searching the web',
+      durationMs: 687,
+      executor: 'server',
+      name: 'search',
+      status: 'completed',
+    });
+    expect(parts.every(isSupportedPart)).toBe(true);
+  });
+
+  it('reads a reasoning step', () => {
+    expect(parseMessagePart(reasoning)?.reasoning).toEqual({
+      durationMs: 4200,
+      id: 'r1',
+      preview: 'Let me check the calendar first.',
+      status: 'completed',
+      summary: 'Checked the calendar',
+    });
+  });
+
+  it('reads a tool call with its approval', () => {
+    const call = parseMessagePart(approvalCall)?.toolCall;
+    expect(call).toMatchObject({
+      approval: {
+        allowTitle: 'Share',
+        declineTitle: 'Not now',
+        message: 'Only your city is shared.',
+        reason: 'to check the local weather',
+        title: 'Share your location?',
+      },
+      arguments: { reason: 'to check the local weather' },
+      displayTitle: 'Checking your location',
+      executor: 'client',
+      id: 'call_1',
+      name: 'get_location',
+      status: 'awaiting_approval',
+      targetClientId: 'ios-1',
+      targetUserId: 'alex',
+    });
+  });
+
+  it('reads a tool call with its authorization', () => {
+    const call = parseMessagePart(authorizationCall)?.toolCall;
+    expect(call?.authorization).toEqual({
+      expiresAt: Date.parse('2026-11-02T10:10:00.123Z'),
+      handoffToken: 'tok',
+      message: 'The agent needs your Linear account to file the issue.',
+      provider: 'linear',
+      providerName: 'Linear',
+      status: undefined,
+      title: 'Connect Linear',
+      type: 'oauth',
+      url: 'https://router.example.com/v1/agents/connectors/oauth/launch/abc',
+    });
+  });
+
+  it('defaults missing fields', () => {
+    const part = parseMessagePart({ type: 'ai_tool_call' }, 3);
+    expect(part?.id).toBe('ai_tool_call-3');
+    expect(part?.version).toBe(1);
+    expect(part?.toolCall).toMatchObject({
+      executor: 'server',
+      name: '',
+      status: 'running',
+    });
+    expect(parseMessagePart({ type: 'ai_reasoning' })?.reasoning?.status).toBe('completed');
+  });
+
+  it('reads fields of the wrong type as missing', () => {
+    const call = parseMessagePart({
+      approval: { message: 'no title' },
+      authorization: { title: 'Connect', url: 'ftp://example.com/launch' },
+      duration_ms: '12',
+      id: 7,
+      name: ['x'],
+      status: '',
+      type: 'ai_tool_call',
+    })?.toolCall;
+    expect(call).toMatchObject({ durationMs: undefined, id: 'ai_tool_call-0', name: '' });
+    expect(call?.status).toBe('running');
+    // a question with no title asks nothing, and a sign-in needs a web page
+    expect(call?.approval).toBeUndefined();
+    expect(call?.authorization).toBeUndefined();
+  });
+
+  it('opens a sign-in only on a web page with a host', () => {
+    expect(
+      signInWithUrl('http://localhost:8080/v1/agents/connectors/oauth/launch/abc'),
+    ).toBeDefined();
+    expect(signInWithUrl('HTTPS://router.example.com')).toBeDefined();
+    expect(signInWithUrl('https://user@router.example.com/launch')).toBeDefined();
+    expect(signInWithUrl('https://')).toBeUndefined();
+    expect(signInWithUrl('https:///launch')).toBeUndefined();
+    expect(signInWithUrl('javascript:alert(1)')).toBeUndefined();
+    expect(signInWithUrl('router.example.com/launch')).toBeUndefined();
+  });
+
+  it('reads a sign-in where URL does not implement protocol or host', () => {
+    // React Native before 0.80 throws "not implemented" from these getters.
+    const OriginalURL = globalThis.URL;
+    class LimitedURL {
+      get host(): string {
+        throw new Error('URL.host is not implemented');
+      }
+      get protocol(): string {
+        throw new Error('URL.protocol is not implemented');
+      }
+    }
+    globalThis.URL = LimitedURL as unknown as typeof URL;
+    try {
+      expect(parseMessagePart(authorizationCall)?.toolCall?.authorization).toBeDefined();
+    } finally {
+      globalThis.URL = OriginalURL;
+    }
+  });
+
+  it('keeps steps it cannot read, without a typed view', () => {
+    const newer = parseMessagePart({ id: 'x', type: 'ai_tool_call', v: 2 });
+    expect(newer?.toolCall).toBeUndefined();
+    expect(newer && isSupportedPart(newer)).toBe(false);
+    const custom = parseMessagePart({ id: 'c', type: 'ai_citation', url: 'u' });
+    expect(custom?.kind).toBe('ai_citation');
+    expect(custom?.payload).toMatchObject({ url: 'u' });
+    expect(custom && isSupportedPart(custom)).toBe(false);
+  });
+
+  it('ignores what is not an AI step', () => {
+    expect(parseMessageParts(undefined)).toEqual([]);
+    expect(parseMessageParts([null, 'x', { type: 'file' }, {}])).toEqual([]);
+  });
+});
+
+describe('tool call addressing', () => {
+  const call = (overrides: Partial<AIToolCallPart>): AIToolCallPart => ({
+    ...(parseMessagePart(approvalCall)?.toolCall as AIToolCallPart),
+    ...overrides,
+  });
+
+  it('asks the targeted person on the targeted install', () => {
+    expect(isAwaitingApproval(call({}), 'alex', 'ios-1')).toBe(true);
+    expect(isAwaitingApproval(call({}), 'alex', 'android-2')).toBe(false);
+    expect(isAwaitingApproval(call({}), 'sam', 'ios-1')).toBe(false);
+  });
+
+  it('asks a server tool on any of the person’s installs', () => {
+    const server = call({ executor: 'server', targetClientId: undefined });
+    expect(isAwaitingApproval(server, 'alex', 'ios-1')).toBe(true);
+    expect(isAwaitingApproval(server, 'alex', 'android-9')).toBe(true);
+  });
+
+  it('asks nothing once answered or without a question', () => {
+    expect(isAwaitingApproval(call({ status: 'running' }), 'alex', 'ios-1')).toBe(false);
+    expect(isAwaitingApproval(call({ approval: undefined }), 'alex', 'ios-1')).toBe(false);
+  });
+
+  it('waits for this device to run a client tool', () => {
+    const device = call({ status: 'awaiting_client' });
+    expect(isAwaitingClient(device, 'alex', 'ios-1')).toBe(true);
+    expect(isAwaitingClient(device, 'alex', 'ios-2')).toBe(false);
+    expect(isAwaitingClient(call({ executor: 'server' }), 'alex', 'ios-1')).toBe(false);
+  });
+
+  it('asks the targeted person to sign in from any install', () => {
+    const signIn = parseMessagePart(authorizationCall)?.toolCall as AIToolCallPart;
+    expect(isAwaitingAuthorization(signIn, 'alex')).toBe(true);
+    expect(isAwaitingAuthorization(signIn, 'sam')).toBe(false);
+    expect(isAwaitingAuthorization({ ...signIn, status: 'completed' }, 'alex')).toBe(false);
+  });
+
+  it('knows a declined call', () => {
+    const declinedApproval = call({
+      approval: { decision: 'declined', title: 'Share?' },
+      status: 'cancelled',
+    });
+    expect(isDeclined(declinedApproval)).toBe(true);
+    const signIn = parseMessagePart(authorizationCall)?.toolCall as AIToolCallPart;
+    expect(
+      isDeclined({
+        ...signIn,
+        authorization: { ...signIn.authorization!, status: 'declined' },
+      }),
+    ).toBe(true);
+    expect(isDeclined(call({}))).toBe(false);
+  });
+
+  it('knows finished statuses and expired sign-ins', () => {
+    expect(['completed', 'failed', 'cancelled'].every(isToolCallFinished)).toBe(true);
+    expect(isToolCallFinished('awaiting_client')).toBe(false);
+    const signIn = parseMessagePart(authorizationCall)?.toolCall?.authorization as NonNullable<
+      AIToolCallPart['authorization']
+    >;
+    expect(isAuthorizationExpired(signIn, signIn.expiresAt! - 1)).toBe(false);
+    expect(isAuthorizationExpired(signIn, signIn.expiresAt!)).toBe(true);
+    expect(isAuthorizationExpired({ ...signIn, status: 'connected' }, Infinity)).toBe(false);
+  });
+});