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

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

@@ -1,4 +1,5 @@
 import { colorFromLabel, hashLabel, parseJsonChart, parseMermaid, xorshift32 } from '../charts';
+import { formatTimeLabel } from '../charts/utils/format-time-label';
 
 describe('ai-components chart parsers', () => {
   describe('parseMermaid', () => {
@@ -84,6 +85,64 @@ describe('ai-components chart parsers', () => {
       expect(spec.data[0]?.dimension).toBeInstanceOf(Date);
     });
 
+    it('draws a layered chart from its first layer that draws data', () => {
+      // As an agent wrote it: the data on the chart, the encoding on its layers, and a rule layer
+      // marking a threshold.
+      const spec = parseJsonChart(
+        JSON.stringify({
+          $schema: 'https://vega.github.io/schema/vega-lite/v5.json',
+          data: {
+            values: [
+              { date: '2026-10-29', pollutant: 'PM2.5', value: 22.2 },
+              { date: '2026-10-29', pollutant: 'PM10', value: 26.23 },
+            ],
+          },
+          layer: [
+            {
+              encoding: {
+                color: { field: 'pollutant', type: 'nominal' },
+                x: { field: 'date', type: 'temporal' },
+                y: { field: 'value', type: 'quantitative' },
+              },
+              mark: { point: true, type: 'line' },
+            },
+            {
+              data: { values: [{ y: 15 }] },
+              encoding: { y: { field: 'y', type: 'quantitative' } },
+              mark: { strokeDash: [4, 4], type: 'rule' },
+            },
+          ],
+          title: 'Skopje air pollution',
+        }),
+      );
+
+      expect(spec.type).toBe('line');
+      expect(spec.isTemporalDim).toBe(true);
+      expect(spec.data.map(({ color, value }) => ({ color, value }))).toEqual([
+        { color: 'PM2.5', value: 22.2 },
+        { color: 'PM10', value: 26.23 },
+      ]);
+    });
+
+    it('takes a layer’s own data over the chart’s', () => {
+      const spec = parseJsonChart(
+        JSON.stringify({
+          data: { values: [{ a: 'x', b: 1 }] },
+          layer: [
+            {
+              data: { values: [{ a: 'y', b: 2 }] },
+              encoding: { x: { field: 'a' }, y: { field: 'b' } },
+              mark: 'bar',
+            },
+          ],
+        }),
+      );
+
+      expect(spec.data.map(({ dimension, value }) => ({ dimension, value }))).toEqual([
+        { dimension: 'y', value: 2 },
+      ]);
+    });
+
     it('rejects JSON that is not a supported chart', () => {
       expect(() => parseJsonChart(JSON.stringify({ hello: 'world' }))).toThrow(
         'Unknown type of JSON formatted chart.',
@@ -101,6 +160,22 @@ describe('ai-components chart parsers', () => {
     });
   });
 
+  describe('formatTimeLabel', () => {
+    const day = 24 * 60 * 60 * 1000;
+
+    it('labels a chart over days by day and month, and one within a day by time', () => {
+      const date = new Date(2026, 9, 29, 13, 5);
+      expect(formatTimeLabel(date, 7 * day)).toBe('29 Oct');
+      expect(formatTimeLabel(date.getTime(), 7 * day)).toBe('29 Oct');
+      expect(formatTimeLabel(date, day / 2)).toBe('13:05');
+    });
+
+    it('labels anything else as it is', () => {
+      expect(formatTimeLabel('Q1', day)).toBe('Q1');
+      expect(formatTimeLabel(new Date('nope'), day)).toBe('Invalid Date');
+    });
+  });
+
   describe('colours', () => {
     it('hashes labels case and whitespace insensitively', () => {
       expect(hashLabel(' Dogs ')).toBe(hashLabel('dogs'));

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

@@ -0,0 +1,239 @@
+import {
+  type AIClientTool,
+  AIClientToolRunner,
+  type AIClientToolSend,
+  type AIMessagePartData,
+  completedToolResult,
+  failedToolResult,
+  parseMessagePart,
+} from '../index';
+
+const step = (fields: Record<string, unknown>) =>
+  parseMessagePart({
+    executor: 'client',
+    id: 'toolu_01A',
+    name: 'device_location',
+    status: 'awaiting_client',
+    target_client_id: 'ios-1',
+    target_user_id: 'u_1',
+    type: 'ai_tool_call',
+    ...fields,
+  }) as AIMessagePartData;
+
+const awaiting = ({
+  client = 'ios-1',
+  id = 'toolu_01A',
+  name = 'device_location',
+  user = 'u_1',
+} = {}) => [step({ id, name, target_client_id: client, target_user_id: user })];
+
+const countingTool = () => {
+  const tool = {
+    definition: { name: 'device_location' },
+    run: jest.fn(() => completedToolResult({ city: 'Skopje' }, 'Shared approximate location')),
+  } satisfies AIClientTool;
+  return tool;
+};
+
+const settle = async () => {
+  for (let i = 0; i < 20; i += 1) await Promise.resolve();
+};
+
+const runnerWith = (tools: AIClientTool[], maxAttempts?: number) =>
+  new AIClientToolRunner({ clientId: 'ios-1', maxAttempts, tools, userId: 'u_1' });
+
+describe('AIClientToolRunner', () => {
+  it('runs a call once, and only on the device it is addressed to', async () => {
+    const tool = countingTool();
+    const runner = runnerWith([tool]);
+    const send = jest.fn<ReturnType<AIClientToolSend>, Parameters<AIClientToolSend>>(() =>
+      Promise.resolve(),
+    );
+
+    runner.run(awaiting(), send);
+    runner.run(awaiting(), send);
+    await settle();
+    runner.run(awaiting(), send);
+    runner.run(awaiting({ client: 'ios-2', id: 'toolu_02' }), send);
+    runner.run(awaiting({ id: 'toolu_03', user: 'u_2' }), send);
+    runner.run(awaiting({ id: 'toolu_04', name: 'unknown_tool' }), send);
+    await settle();
+
+    expect(tool.run).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(send.mock.calls[0][0].id).toBe('toolu_01A');
+    expect(send.mock.calls[0][1]).toEqual({
+      output: { city: 'Skopje' },
+      summary: 'Shared approximate location',
+    });
+  });
+
+  it('sends a result that could not be sent again, without running the tool again', async () => {
+    const tool = countingTool();
+    const runner = runnerWith([tool]);
+    let attempts = 0;
+    const send = () => {
+      attempts += 1;
+      return attempts === 1 ? Promise.reject(new Error('offline')) : Promise.resolve();
+    };
+
+    for (let i = 0; i < 3; i += 1) {
+      runner.run(awaiting(), send);
+      await settle();
+    }
+
+    expect(tool.run).toHaveBeenCalledTimes(1);
+    expect(attempts).toBe(2);
+  });
+
+  it('gives up on a result after its attempts', async () => {
+    const tool = countingTool();
+    const runner = runnerWith([tool], 2);
+    const send = jest.fn(() => Promise.reject(new Error('offline')));
+
+    for (let i = 0; i < 4; i += 1) {
+      runner.run(awaiting(), send);
+      await settle();
+    }
+
+    expect(tool.run).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not run a call again while it is still running', async () => {
+    let finish: () => void = () => undefined;
+    const tool: AIClientTool = {
+      definition: { name: 'device_location' },
+      run: jest.fn(
+        () =>
+          new Promise((resolve) => {
+            finish = () => resolve(completedToolResult({ city: 'Skopje' }));
+          }),
+      ),
+    };
+    const runner = runnerWith([tool]);
+    const send = jest.fn(() => Promise.resolve());
+
+    runner.run(awaiting(), send);
+    await settle();
+    runner.run(awaiting(), send);
+    finish();
+    await settle();
+
+    expect(tool.run).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not run a call that is finished', async () => {
+    const tool = countingTool();
+    const runner = runnerWith([tool]);
+
+    runner.run([step({ status: 'completed' })], jest.fn());
+    await settle();
+
+    expect(tool.run).not.toHaveBeenCalled();
+  });
+
+  it('reports a tool that throws as failed', async () => {
+    const tool: AIClientTool = {
+      definition: { name: 'device_location' },
+      run: () => Promise.reject(new Error('no GPS')),
+    };
+    const send = jest.fn(() => Promise.resolve());
+
+    runnerWith([tool]).run(awaiting(), send);
+    await settle();
+
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ id: 'toolu_01A' }), {
+      failure: "The tool couldn't run",
+    });
+  });
+
+  it('reports output that isn’t JSON as failed, and sends JSON as JSON', async () => {
+    const looped: Record<string, unknown> = {};
+    looped.self = looped;
+    const send = jest.fn(() => Promise.resolve());
+    const at = new Date('2026-11-05T09:00:00Z');
+    runnerWith([{ definition: { name: 'device_location' }, run: () => ({ output: looped }) }]).run(
+      awaiting(),
+      send,
+    );
+    await settle();
+    expect(send).toHaveBeenLastCalledWith(expect.anything(), {
+      failure: "The tool's output isn't JSON",
+    });
+
+    runnerWith([{ definition: { name: 'device_location' }, run: () => ({ output: { at } }) }]).run(
+      awaiting(),
+      send,
+    );
+    await settle();
+    expect(send).toHaveBeenLastCalledWith(expect.anything(), {
+      output: { at: '2026-11-05T09:00:00.000Z' },
+    });
+  });
+
+  it('sorts its tool names and keeps the first tool of a name', async () => {
+    const named = (name: string) =>
+      ({
+        definition: { name },
+        run: jest.fn(() => failedToolResult('Not now')),
+      }) satisfies AIClientTool;
+    const first = named('device_location');
+    const duplicate = named('device_location');
+    const runner = runnerWith([named('open_camera'), first, duplicate]);
+
+    runner.run(awaiting(), () => Promise.resolve());
+    await settle();
+
+    expect(runner.toolNames).toEqual(['device_location', 'open_camera']);
+    expect(first.run).toHaveBeenCalledTimes(1);
+    expect(duplicate.run).not.toHaveBeenCalled();
+  });
+
+  it('describes every tool to the agent', () => {
+    const weather: AIClientTool = {
+      definition: {
+        description: 'Gets the weather for a city.',
+        inputSchema: {
+          properties: { city: { type: 'string' } },
+          required: ['city'],
+          type: 'object',
+        },
+        name: 'get_weather',
+      },
+      instructions: 'Use it when the person asks about the weather.',
+      run: () => failedToolResult('Not now'),
+      showExternalSourcesIndicator: true,
+    };
+    const runner = runnerWith([weather, countingTool()]);
+
+    expect(runner.registrations).toEqual([
+      // A tool without a description or instructions.
+      { description: '', name: 'device_location', showExternalSourcesIndicator: false },
+      {
+        description: 'Gets the weather for a city.',
+        instructions: 'Use it when the person asks about the weather.',
+        name: 'get_weather',
+        parameters: {
+          properties: { city: { type: 'string' } },
+          required: ['city'],
+          type: 'object',
+        },
+        showExternalSourcesIndicator: true,
+      },
+    ]);
+  });
+
+  it('describes a tool without a description by its instructions', () => {
+    const location: AIClientTool = {
+      definition: { name: 'get_location' },
+      instructions: 'Ask before sharing the location.',
+      run: () => failedToolResult('Not now'),
+    };
+
+    expect(runnerWith([location]).registrations[0].description).toBe(
+      'Ask before sharing the location.',
+    );
+  });
+});