@@ -15,8 +15,9 @@ import type { ComparisonTableTranslations } from './createGroundedComparisonTabl
  * The agent triggers this client-side tool when it detects a comparison
  * request. Its arguments name ONLY the products (by objectID) and the attribute
  * *keys* to compare — never the values. Every cell is hydrated from the chat
- * records store (`context.records`, filled by the search tools), so the model
- * physically cannot type (and therefore cannot hallucinate) a price or spec.
+ * records store (`context.records`, filled by the shopper's comparison
+ * selection and by the search tools), so the model physically cannot type
+ * (and therefore cannot hallucinate) a price or spec.
  * This is the "grounded table" fix from the agentic-evals comparison study,
  * promoted from the display-block prototype to a first-class tool.
  *
 
@@ -683,8 +683,9 @@ export type ClientSideToolContext<
 > = ChatComponentContext<TMessage> & {
   message: ChatToolMessage;
   /**
-   * The records the chat's tools have fetched. A tool handed plain object IDs
-   * hydrates them with `records.get(objectID)`.
+   * The records the conversation holds (fetched by tools or selected for a
+   * comparison). A tool handed plain object IDs hydrates them with
+   * `records.get(objectID)`.
    */
   records?: ChatRecordsStore;
   insightsEventContext?: ChatInsightsEventContext;
 
@@ -135,6 +135,68 @@ describe('createChatRecordsStore', () => {
 });
 
 describe('collectChatRecords', () => {
+  const compareMessage = (id: string, selectedProducts: unknown) =>
+    ({
+      id,
+      role: 'user',
+      parts: [
+        { type: 'text', text: 'Compare these products: Runner vs Trail' },
+      ],
+      metadata: { turnContext: { selected_products: selectedProducts } },
+    }) as ChatMessageBase;
+
+  test('collects the records a comparison selection carries', () => {
+    // The compare connector attaches the selected records to its user message
+    // (JSON-encoded, per the Agent Studio contract), so the comparison table
+    // can be built from them without the agent searching for them again.
+    const store = collectChatRecords([
+      compareMessage(
+        '1',
+        JSON.stringify([
+          { objectID: '1', name: 'Runner', price: 120 },
+          { objectID: '3', name: 'Trail', price: 140 },
+        ])
+      ),
+    ]);
+
+    expect(store.getAll()).toEqual({
+      1: { objectID: '1', name: 'Runner', price: 120 },
+      3: { objectID: '3', name: 'Trail', price: 140 },
+    });
+  });
+
+  test('lets a record the agent re-fetched after the selection win', () => {
+    const store = collectChatRecords([
+      compareMessage('1', JSON.stringify([{ objectID: '1', name: 'Runner' }])),
+      assistantMessage('2', [
+        searchPart('search', [{ objectID: '1', name: 'Runner Pro' }]),
+      ]),
+    ]);
+
+    expect(store.get('1')).toEqual({ objectID: '1', name: 'Runner Pro' });
+  });
+
+  test('ignores a malformed or absent selection', () => {
+    const store = collectChatRecords([
+      compareMessage('1', 'not json'),
+      compareMessage('2', JSON.stringify({ objectID: 'not-an-array' })),
+      compareMessage('3', JSON.stringify(['1', null, { name: 'no objectID' }])),
+      compareMessage('4', undefined),
+      { id: '5', role: 'user', parts: [{ type: 'text', text: 'hi' }] },
+      // Only the user's own selection counts, not a look-alike on a reply.
+      {
+        ...assistantMessage('6', []),
+        metadata: {
+          turnContext: {
+            selected_products: JSON.stringify([{ objectID: '9' }]),
+          },
+        },
+      },
+    ]);
+
+    expect(store.getAll()).toEqual({});
+  });
+
   test('combines the records of every tool call of the conversation', () => {
     const store = collectChatRecords([
       assistantMessage('1', [
 
@@ -8,7 +8,8 @@ export type ChatRecord = Record<string, unknown> & { objectID: string };
 export type ChatRecords = Record<string, ChatRecord>;
 
 /**
- * The records the chat's tools have fetched, keyed by `objectID`: the shared
+ * The records the conversation holds, keyed by `objectID`: what the chat's
+ * tools fetched plus what the shopper selected for a comparison — the shared
  * lookup between the tools that search and the tools handed only identifiers.
  */
 export type ChatRecordsStore = {
@@ -51,19 +52,64 @@ export function createChatRecordsStore(): ChatRecordsStore {
   };
 }
 
+/**
+ * Turn-context key under which the compare connector attaches the shopper's
+ * selection to its user message (`metadata.turnContext.selected_products`), as
+ * a JSON-encoded array of records — the Agent Studio comparison contract.
+ */
+const SELECTED_PRODUCTS_KEY = 'selected_products';
+
+/**
+ * The records a user message carries as a comparison selection, or `[]` when
+ * it carries none. The payload is client-authored, so anything unexpected
+ * (not JSON, not an array) is treated as "no records" rather than thrown.
+ */
+function selectedRecords(message: ChatMessageBase): ChatRecord[] {
+  if (message.role !== 'user') {
+    return [];
+  }
+
+  const turnContext = (
+    message.metadata as
+      | { turnContext?: Record<string, unknown> | null }
+      | undefined
+      | null
+  )?.turnContext;
+  const raw = turnContext?.[SELECTED_PRODUCTS_KEY];
+
+  if (typeof raw !== 'string') {
+    return [];
+  }
+
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    return Array.isArray(parsed) ? (parsed as ChatRecord[]) : [];
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Collects into `store` the records of every completed tool call in `messages`
- * whose output holds `hits`. Matching on the output rather than on a tool name
- * means any tool that fetches records contributes them by returning them.
+ * whose output holds `hits`, plus the records a user message carries as a
+ * comparison selection. Matching on the output rather than on a tool name
+ * means any tool that fetches records contributes them by returning them; the
+ * selection counts because the compare flow already hands the agent the very
+ * records it is asked to compare, so the table can be built from them without
+ * a search round-trip.
  *
  * Idempotent, so it can re-run over the whole conversation on every update:
  * streaming deltas and a conversation restored from storage are one code path.
+ * Later messages win per `objectID`, so a record the agent re-fetched after the
+ * selection replaces the selected copy.
  */
 export function collectChatRecords(
   messages: ChatMessageBase[] | undefined,
   store: ChatRecordsStore = createChatRecordsStore()
 ): ChatRecordsStore {
   messages?.forEach((message) => {
+    store.merge(selectedRecords(message));
+
     message.parts.forEach((part) => {
       if (!isPartTool(part) || part.state !== 'output-available') {
         return;
 
@@ -125,9 +125,10 @@ export type ChatRenderState<TUiMessage extends UIMessage = UIMessage> = {
    */
   tools: ClientSideTools;
   /**
-   * The records the chat's tools have fetched, keyed by `objectID`: every tool
-   * call that returned `hits` contributes them, last write winning. Attached to
-   * every tool too, which is how a `layoutComponent` reads it.
+   * The records the conversation holds, keyed by `objectID`: every tool call
+   * that returned `hits` contributes them, as does the selection a `compare`
+   * widget attaches to its message, last write winning. Attached to every tool
+   * too, which is how a `layoutComponent` reads it.
    */
   records: ChatRecordsStore;
   /**
 
@@ -138,11 +138,11 @@ export function getComparisonPlaceholderMessage(
 }
 
 /**
- * Builds the default comparison message. It names each selected item so the
- * agent can ground the comparison: it re-retrieves the records with
- * `algolia_search_index` and renders them with the builtin
- * `algolia_compare_products` tool. Works with the default shopping assistant
- * prompt — no agent configuration required.
+ * Builds the default comparison message. It names each selected item; the
+ * records themselves travel in the turn context (`selected_products`), where
+ * both the agent and the builtin `algolia_compare_products` table read them,
+ * so no search round-trip is needed to render the comparison. Works with the
+ * default shopping assistant prompt — no agent configuration required.
  */
 export function getDefaultComparisonMessage(items: CompareItem[]): string {
   const labels = items.map((item) => {
 
@@ -14,8 +14,9 @@ import type { ComparisonTableTranslations } from 'instantsearch-ui-components';
  *
  * Registered by default in the chat widget so the agent can trigger a grounded
  * side-by-side comparison: its tool call names only the product objectIDs and
- * the attribute keys, and every cell is hydrated client-side from the real
- * `algolia_search_index` hits. The model never types a value, so it cannot
+ * the attribute keys, and every cell is hydrated client-side from real records
+ * (the shopper's selection and `algolia_search_index` hits). The model never
+ * types a value, so it cannot
  * hallucinate one. See `instantsearch-ui-components` `CompareProductsTool` for
  * the contract.
  */
 
@@ -13,8 +13,9 @@ import type {
  *
  * Registered by default in the chat widget so the agent can trigger a grounded
  * side-by-side comparison: its tool call names only the product objectIDs and
- * the attribute keys, and every cell is hydrated client-side from the real
- * `algolia_search_index` hits. The model never types a value, so it cannot
+ * the attribute keys, and every cell is hydrated client-side from real records
+ * (the shopper's selection and `algolia_search_index` hits). The model never
+ * types a value, so it cannot
  * hallucinate one. See `instantsearch-ui-components` `CompareProductsTool` for
  * the contract, and `comparison-eval/README.md` for the study behind it.
  */