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

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

@@ -0,0 +1,187 @@
+import type { AIConversationRequest, AIMessage } from '..';
+import { AIConversationExchange } from '../conversation-state/controller/AIConversationExchange';
+
+const user = (id: string, text = 'Plan a weekend in Lisbon'): AIMessage => ({
+  id,
+  role: 'user',
+  text,
+});
+
+const reply = (id: string, text = 'Here’s a plan', generating = false): AIMessage => ({
+  id,
+  isGenerating: generating,
+  role: 'assistant',
+  text,
+});
+
+const conversation = [user('u1'), reply('a1'), user('u2'), reply('a2')];
+
+const request = (overrides: Partial<AIConversationRequest>): AIConversationRequest => ({
+  attachments: [],
+  kind: 'message',
+  messageId: 'm1',
+  text: 'Hi',
+  ...overrides,
+});
+
+const exchangeOf = (overrides: Partial<AIConversationRequest>, messages = conversation) =>
+  new AIConversationExchange(1, request(overrides), messages);
+
+describe('AIConversationExchange', () => {
+  it('has a message on its way that replaces nothing', () => {
+    const photo = { type: 'image/jpeg', uri: 'file:///tmp/alfama.jpg' };
+    const exchange = exchangeOf({ attachments: [photo] });
+
+    expect(exchange.pending?.id).toBe('m1');
+    expect(exchange.pending?.text).toBe('Hi');
+    expect(exchange.pending?.attachments?.map(({ url }) => url)).toEqual([photo.uri]);
+    expect(exchange.replaced.size).toBe(0);
+    expect([...exchange.known]).toEqual(['u1', 'a1', 'u2', 'a2']);
+  });
+
+  it('has a request of a kind of its own on its way like a message', () => {
+    const exchange = exchangeOf({ kind: 'ui_action', message: reply('a2'), text: 'Picked Alfama' });
+
+    expect(exchange.pending?.text).toBe('Picked Alfama');
+    expect(exchange.replaced.size).toBe(0);
+  });
+
+  it('replaces the reply it regenerates and those after it', () => {
+    const exchange = exchangeOf({ kind: 'regenerate', message: reply('a1'), text: '' });
+
+    expect(exchange.pending).toBeUndefined();
+    expect([...exchange.replaced.keys()]).toEqual(['a1', 'u2', 'a2']);
+  });
+
+  it('replaces nothing when it regenerates a reply not in the conversation', () => {
+    const exchange = exchangeOf({ kind: 'regenerate', message: reply('gone'), text: '' });
+
+    expect(exchange.replaced.size).toBe(0);
+  });
+
+  it('replaces the message it edits and those after it', () => {
+    const exchange = exchangeOf({ kind: 'edit', message: user('u2'), text: 'Porto for two' });
+
+    expect([...exchange.replaced.keys()]).toEqual(['u2', 'a2']);
+    expect(exchange.pending?.text).toBe('Porto for two');
+  });
+
+  it('starts its reply when a new reply shows something', () => {
+    const exchange = exchangeOf({});
+
+    // The latest reply was there before.
+    expect(exchange.hasReplyStarted(conversation)).toBe(false);
+    expect(exchange.hasReplyStarted([...conversation, user('u3')])).toBe(false);
+    expect(exchange.hasReplyStarted([...conversation, user('u3'), reply('a3', '', true)])).toBe(
+      false,
+    );
+    expect(exchange.hasReplyStarted([...conversation, user('u3'), reply('a3', 'Sure', true)])).toBe(
+      true,
+    );
+    expect(exchange.hasReplyStarted([...conversation, user('u3'), reply('a3', 'Sure')])).toBe(true);
+    // Finished, with nothing to show.
+    expect(exchange.hasReplyStarted([...conversation, user('u3'), reply('a3', '')])).toBe(true);
+    expect(exchange.hasReplyStarted([])).toBe(false);
+  });
+
+  it('starts its reply when the one written again is rewritten', () => {
+    const exchange = exchangeOf({ kind: 'regenerate', message: reply('a2'), text: '' });
+    const rewriting = conversation.slice(0, -1);
+
+    // Not rewritten yet.
+    expect(exchange.hasReplyStarted(conversation)).toBe(false);
+    expect(exchange.hasReplyStarted([...rewriting, reply('a2', '', true)])).toBe(false);
+    // It is the reply, which shows nothing yet.
+    expect(exchange.reply([...rewriting, reply('a2', '', true)])).toBeDefined();
+    expect(exchange.hasReplyStarted([...rewriting, reply('a2', 'Another', true)])).toBe(true);
+  });
+
+  it('starts its reply when the one written again arrives finished', () => {
+    const exchange = exchangeOf({ kind: 'regenerate', message: reply('a2'), text: '' });
+    const rewriting = conversation.slice(0, -1);
+
+    // An agent that doesn't stream.
+    expect(exchange.hasReplyStarted([...rewriting, reply('a2', 'Another plan')])).toBe(true);
+    // The reply as it was.
+    expect(exchange.hasReplyStarted([...rewriting, reply('a2')])).toBe(false);
+  });
+
+  it('starts its reply when an edit’s reply is rewritten', () => {
+    const exchange = exchangeOf({ kind: 'edit', message: user('u2'), text: 'Porto for two' });
+    const edited = [user('u1'), reply('a1'), user('u2', 'Porto for two')];
+
+    // Nothing changed yet.
+    expect(exchange.hasReplyStarted(conversation)).toBe(false);
+    // The person's message isn't the reply.
+    expect(exchange.hasReplyStarted(edited)).toBe(false);
+    // The reply as it was.
+    expect(exchange.hasReplyStarted([...edited, reply('a2')])).toBe(false);
+    expect(exchange.hasReplyStarted([...edited, reply('a2', 'For two', true)])).toBe(true);
+    expect(exchange.hasReplyStarted([...edited, reply('a2', 'For two')])).toBe(true);
+  });
+
+  it('doesn’t take an answer that failed midway as rewritten until it changes', () => {
+    const writing = [user('u1'), reply('a1', 'Day one', true)];
+    const exchange = exchangeOf({ kind: 'regenerate', message: writing[1], text: '' }, writing);
+
+    expect(exchange.reply(writing)).toBeUndefined();
+    expect(exchange.reply([user('u1'), reply('a1', 'Day one')])).toBeUndefined();
+    expect(exchange.reply([user('u1'), reply('a1', 'Day one, day two', true)])).toBeDefined();
+  });
+
+  it('finds the person’s message by its id, or as their first new message', () => {
+    const exchange = exchangeOf({});
+
+    expect(exchange.hasMessageArrived(conversation)).toBe(false);
+    expect(exchange.hasMessageArrived([...conversation, user('m1')])).toBe(true);
+    expect(exchange.hasMessageArrived([...conversation, user('u3')])).toBe(true);
+    // Older messages loaded above.
+    expect(exchange.hasMessageArrived([user('u0'), reply('a0'), ...conversation])).toBe(false);
+    expect(exchange.hasMessageArrived([...conversation, reply('a3')])).toBe(false);
+  });
+
+  it('retries the request, unless the agent couldn’t answer a message it has', () => {
+    const exchange = exchangeOf({});
+    exchange.state = 'failed';
+
+    // The same message, which the transport can tell.
+    expect(exchange.retryRequest([...conversation, user('m1')]).messageId).toBe('m1');
+    expect(exchange.retryRequest([...conversation, user('m1')]).kind).toBe('message');
+
+    exchange.state = 'unanswered';
+
+    // Its message never arrived.
+    expect(exchange.retryRequest(conversation).kind).toBe('message');
+    const again = exchange.retryRequest([...conversation, user('m1')]);
+    expect(again.kind).toBe('regenerate');
+    expect(again.text).toBe('Hi');
+    // A reply to the latest message.
+    expect(again.message).toBeUndefined();
+    expect(again.messageId).not.toBe('m1');
+  });
+
+  it('shows the person’s message until its reply, and afterwards only for a new message', () => {
+    const send = exchangeOf({});
+    const edit = exchangeOf({ kind: 'edit', message: user('u2'), text: 'Porto for two' });
+
+    expect(send.shownPending).toBeDefined();
+    expect(edit.shownPending).toBeDefined();
+    for (const state of ['stopped', 'failed', 'unanswered'] as const) {
+      send.state = state;
+      edit.state = state;
+      expect(send.shownPending).toBeDefined();
+      // The edited message comes back.
+      expect(edit.shownPending).toBeUndefined();
+      expect(send.hasFailed).toBe(state !== 'stopped');
+    }
+  });
+
+  it('doesn’t take an old reply still being written as the new one', () => {
+    const writing = [user('u1'), reply('a1', 'Day one', true)];
+    const exchange = exchangeOf({ text: 'Make it three days' }, writing);
+
+    expect(exchange.hasReplyStarted([user('u1'), reply('a1', 'Day one, day two', true)])).toBe(
+      false,
+    );
+  });
+});

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

@@ -0,0 +1,207 @@
+import { renderHook } from '@testing-library/react-native';
+
+import {
+  type ConversationRow,
+  useConversationRows,
+  type UseConversationRowsOptions,
+} from '../conversation/useConversationRows';
+import type { AIMessage, AIPendingMessage } from '../conversation-state/types';
+import type { AIMessagePartData } from '../message-parts/types';
+
+const user = (id: string, text: string): AIMessage => ({ id, role: 'user', text });
+const reply = (id: string, text: string, extra: Partial<AIMessage> = {}): AIMessage => ({
+  id,
+  role: 'assistant',
+  text,
+  ...extra,
+});
+
+const render = (options: UseConversationRowsOptions) =>
+  renderHook((props: UseConversationRowsOptions) => useConversationRows(props), {
+    initialProps: options,
+  });
+
+const shapeOf = (row: ConversationRow) =>
+  row.kind === 'tail'
+    ? `tail:${row.turnKey}${row.isThinking ? ':thinking' : ''}`
+    : `${row.key}:${row.position}:${row.turnKey}`;
+
+describe('useConversationRows', () => {
+  it('lists the messages by turn and anchors the latest turn', () => {
+    const { result } = render({
+      messages: [user('q1', 'One?'), reply('a1', 'One.'), user('q2', 'Two?'), reply('a2', 'Two.')],
+    });
+
+    expect(result.current.rows.map(shapeOf)).toEqual([
+      'q1:turn:q1',
+      'a1:message:q1',
+      'q2:turn:q2',
+      'a2:message:q2',
+    ]);
+    expect(result.current.anchorKey).toBe('q2');
+    expect(result.current.isEmpty).toBe(false);
+  });
+
+  it('is empty without messages, with nothing to anchor', () => {
+    const { result } = render({ messages: [] });
+
+    expect(result.current.rows).toEqual([]);
+    expect(result.current.anchorKey).toBeUndefined();
+    expect(result.current.isEmpty).toBe(true);
+  });
+
+  it('ends the latest turn with a row while the agent thinks or there is a footer', () => {
+    const messages = [user('q1', 'One?')];
+    const { rerender, result } = render({ messages });
+    expect(result.current.rows.map(shapeOf)).toEqual(['q1:turn:q1']);
+
+    rerender({ isThinking: true, messages });
+    expect(result.current.rows.map(shapeOf)).toEqual(['q1:turn:q1', 'tail:q1:thinking']);
+
+    rerender({ footer: 'Working', messages: [...messages, reply('a1', 'One.')] });
+    expect(result.current.rows.map(shapeOf)).toEqual(['q1:turn:q1', 'a1:message:q1', 'tail:q1']);
+  });
+
+  describe('between the steps of a reply being written', () => {
+    const reasoning = (id: string, status = 'completed'): AIMessagePartData => ({
+      id,
+      kind: 'ai_reasoning',
+      payload: {},
+      reasoning: { id, status },
+      version: 1,
+    });
+    const call = (id: string, status: string): AIMessagePartData => ({
+      id,
+      kind: 'ai_tool_call',
+      payload: {},
+      toolCall: { executor: 'server', id, name: 'search', status },
+      version: 1,
+    });
+    const writing = (parts: AIMessagePartData[], extra: Partial<AIMessage> = {}) => [
+      user('q1', 'Weather?'),
+      reply('a1', '', { isGenerating: true, parts, ...extra }),
+    ];
+    const tailOf = (rows: ConversationRow[]) => rows.find((row) => row.kind === 'tail');
+    // When the reply's row says the agent started thinking again, if it is.
+    const thinkingOf = (rows: ConversationRow[]) => {
+      const row = rows.find((candidate) => candidate.key === 'a1');
+      return row?.kind === 'entry' ? row.thinkingSince : undefined;
+    };
+
+    beforeEach(() => jest.useFakeTimers({ now: 1000 }));
+    afterEach(() => jest.useRealTimers());
+
+    it('thinks under the reply once every step so far is over, counting from then', () => {
+      const { rerender, result } = render({
+        messages: writing([reasoning('r1'), call('c1', 'running')]),
+      });
+      // The search shows itself while it runs.
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+
+      jest.setSystemTime(5000);
+      rerender({ messages: writing([reasoning('r1'), call('c1', 'completed')]) });
+      expect(thinkingOf(result.current.rows)).toBe(5000);
+      // In the reply's row, which the thinking moves with as the steps fold, not a row of its own.
+      expect(tailOf(result.current.rows)).toBeUndefined();
+
+      // Still thinking, still counting from when it began.
+      jest.setSystemTime(7000);
+      rerender({ messages: writing([reasoning('r1'), call('c1', 'completed')]) });
+      expect(thinkingOf(result.current.rows)).toBe(5000);
+
+      // A step that ends starts the next run.
+      jest.setSystemTime(9000);
+      rerender({ messages: writing([reasoning('r1'), call('c1', 'completed'), reasoning('r2')]) });
+      expect(thinkingOf(result.current.rows)).toBe(9000);
+    });
+
+    it('stops thinking once the answer starts, or the reply is done', () => {
+      const parts = [reasoning('r1'), call('c1', 'completed')];
+      const { rerender, result } = render({ messages: writing(parts) });
+      expect(thinkingOf(result.current.rows)).toBe(1000);
+
+      rerender({ messages: writing(parts, { text: 'It is sunny.' }) });
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+
+      // The answer pausing doesn't count as thinking again.
+      rerender({ messages: writing(parts, { text: 'It is sunny.' }) });
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+
+      rerender({ messages: writing(parts, { isGenerating: false, text: 'It is sunny.' }) });
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+    });
+
+    it('thinks after a step that follows what the agent wrote first, until it writes more', () => {
+      const intro = { text: "I'll look it up." };
+      const { rerender, result } = render({
+        messages: writing([call('c1', 'running')], intro),
+      });
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+
+      // With the break that follows what came before the step.
+      rerender({ messages: writing([call('c1', 'completed')], { text: `${intro.text}\n\n` }) });
+      expect(thinkingOf(result.current.rows)).toBe(1000);
+
+      rerender({
+        messages: writing([call('c1', 'completed')], { text: "I'll look it up. It is" }),
+      });
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+    });
+
+    it('does not think for a step that ends together with more of the answer', () => {
+      const { rerender, result } = render({
+        messages: writing([call('c1', 'running')], { text: 'Looking.' }),
+      });
+      rerender({
+        messages: writing([call('c1', 'completed')], { text: 'Looking. Found it:' }),
+      });
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+    });
+
+    it('leaves a step that is still going to show itself', () => {
+      for (const parts of [
+        [reasoning('r1', 'streaming')],
+        [reasoning('r1'), call('c1', 'awaiting_approval')],
+        [],
+      ]) {
+        const { result } = render({ messages: writing(parts) });
+        expect(thinkingOf(result.current.rows)).toBeUndefined();
+      }
+    });
+
+    it('times thinking before the reply shows anything by the turn', () => {
+      const { result } = render({ isThinking: true, messages: writing([reasoning('r1')]) });
+      expect(tailOf(result.current.rows)).toMatchObject({ isThinking: true });
+      expect(thinkingOf(result.current.rows)).toBeUndefined();
+    });
+  });
+
+  it('anchors a message on its way, and keeps its row for its copy', () => {
+    const pending: AIPendingMessage = { id: 'local-1', text: 'Three?' };
+    const messages = [user('q1', 'One?'), reply('a1', 'One.')];
+    const { rerender, result } = render({ messages, pendingMessage: pending });
+    expect(result.current.anchorKey).toBe('local-1');
+    const pendingRow = result.current.rows[2];
+    expect(pendingRow && shapeOf(pendingRow)).toBe('local-1:turn:local-1');
+
+    // The copy arrives under the server's id, and takes over the row and its key.
+    rerender({ messages: [...messages, user('q3', 'Three?')], pendingMessage: pending });
+    expect(result.current.anchorKey).toBe('local-1');
+    expect(result.current.rows.map(shapeOf)).toEqual([
+      'q1:turn:q1',
+      'a1:message:q1',
+      'local-1:turn:local-1',
+      'tail:local-1:thinking',
+    ]);
+  });
+
+  it('keeps the object of every row that did not change', () => {
+    const q1 = user('q1', 'One?');
+    const { rerender, result } = render({ messages: [q1, reply('a1', 'On')] });
+    const [firstRow, firstReply] = result.current.rows;
+
+    rerender({ messages: [q1, reply('a1', 'One.')] });
+    expect(result.current.rows[0]).toBe(firstRow);
+    expect(result.current.rows[1]).not.toBe(firstReply);
+  });
+});