@apollo/client-ai-apps 0.6.5 → 0.7.0

package/src/openai/core/__tests__/ApolloClient.test.ts

@@ -1,14 +1,21 @@
 import { expect, test, describe, vi } from "vitest";
 import { ApolloClient } from "../ApolloClient.js";
-import { parse } from "graphql";
-import { ApolloLink, HttpLink, InMemoryCache, gql } from "@apollo/client";
-import { print } from "@apollo/client/utilities";
-import { ToolCallLink } from "../../link/ToolCallLink.js";
+import { parse, type DocumentNode } from "graphql";
+import {
+  ApolloLink,
+  HttpLink,
+  InMemoryCache,
+  NetworkStatus,
+  gql,
+} from "@apollo/client";
+import { ToolCallLink } from "../../../link/ToolCallLink.js";
 import {
   graphqlToolResult,
   minimalHostContextWithToolName,
   mockApplicationManifest,
   mockMcpHost,
+  ObservableStream,
+  parseManifestOperation,
   spyOnConsole,
   stubOpenAiGlobals,
 } from "../../../testing/internal/index.js";
@@ -152,19 +159,27 @@ describe("prefetchData", () => {
   test("caches tool response when data is provided", async () => {
     stubOpenAiGlobals({ toolInput: { id: 1 } });
     using _ = spyOnConsole("debug");
-    const client = new ApolloClient({
-      cache: new InMemoryCache(),
-      manifest: mockApplicationManifest(),
-    });
-    using host = await mockMcpHost({
-      hostContext: minimalHostContextWithToolName("GetProduct"),
-    });
 
-    host.onCleanup(() => client.stop());
+    const query = gql`
+      query Product($id: ID!)
+      @tool(name: "GetProduct", description: "Get a product") {
+        product(id: $id) {
+          id
+          title
+          rating
+          price
+          description
+          images
+          __typename
+        }
+      }
+    `;
+
+    const { client, host } = await setup({ query });
+    using _host = host;
 
     host.sendToolInput({ arguments: { id: 1 } });
     host.sendToolResult({
-      content: [],
       structuredContent: {
         result: {
           data: {
@@ -184,25 +199,39 @@ describe("prefetchData", () => {
 
     await client.connect();
 
-    expect(client.extract()).toMatchInlineSnapshot(`
-      {
-        "Product:1": {
-          "__typename": "Product",
-          "description": "Awesome pen",
-          "id": "1",
-          "images": [],
-          "price": 1,
-          "rating": 5,
-          "title": "Pen",
+    await expect(
+      client.query({ query, variables: { id: 1 } })
+    ).resolves.toStrictEqual({
+      data: {
+        product: {
+          id: "1",
+          title: "Pen",
+          rating: 5,
+          price: 1.0,
+          description: "Awesome pen",
+          images: [],
+          __typename: "Product",
         },
-        "ROOT_QUERY": {
-          "__typename": "Query",
-          "product({"id":1})": {
-            "__ref": "Product:1",
-          },
+      },
+    });
+
+    expect(client.extract()).toStrictEqual({
+      "Product:1": {
+        __typename: "Product",
+        description: "Awesome pen",
+        id: "1",
+        images: [],
+        price: 1,
+        rating: 5,
+        title: "Pen",
+      },
+      ROOT_QUERY: {
+        __typename: "Query",
+        'product({"id":1})': {
+          __ref: "Product:1",
         },
-      }
-    `);
+      },
+    });
   });
 
   test("caches prefetched data when prefetched data is provided", async () => {
@@ -286,39 +315,42 @@ describe("prefetchData", () => {
   test("caches both prefetch and tool response when both are provided", async () => {
     stubOpenAiGlobals({ toolInput: { id: 1 } });
     using _ = spyOnConsole("debug");
+
+    const prefetchQuery = gql`
+      query TopProducts
+      @tool(description: "Shows the currently highest rated products.")
+      @prefetch {
+        topProducts {
+          id
+          title
+          rating
+          price
+          __typename
+        }
+      }
+    `;
+
+    const query = gql`
+      query Product($id: ID!)
+      @tool(name: "GetProduct", description: "Get a product") {
+        product(id: $id) {
+          id
+          title
+          rating
+          price
+          description
+          images
+          __typename
+        }
+      }
+    `;
+
     const client = new ApolloClient({
       cache: new InMemoryCache(),
       manifest: mockApplicationManifest({
         operations: [
-          {
-            id: "c43af26552874026c3fb346148c5795896aa2f3a872410a0a2621cffee25291c",
-            name: "Product",
-            type: "query",
-            body: "query Product($id: ID!) {\n  product(id: $id) {\n    id\n    title\n    rating\n    price\n    description\n    images\n    __typename\n  }\n}",
-            variables: { id: "ID" },
-            prefetch: false,
-            tools: [
-              {
-                name: "GetProduct",
-                description: "Shows the details page for a specific product.",
-              },
-            ],
-          },
-          {
-            id: "cd0d52159b9003e791de97c6a76efa03d34fe00cee278d1a3f4bfcec5fb3e1e6",
-            name: "TopProducts",
-            type: "query",
-            body: "query TopProducts {\n  topProducts {\n    id\n    title\n    rating\n    price\n    __typename\n  }\n}",
-            variables: {},
-            prefetch: true,
-            prefetchID: "__anonymous",
-            tools: [
-              {
-                name: "TopProducts",
-                description: "Shows the currently highest rated products.",
-              },
-            ],
-          },
+          parseManifestOperation(prefetchQuery),
+          parseManifestOperation(query),
         ],
       }),
     });
@@ -330,7 +362,6 @@ describe("prefetchData", () => {
 
     host.sendToolInput({ arguments: { id: 1 } });
     host.sendToolResult({
-      content: [],
       structuredContent: {
         result: {
           data: {
@@ -367,7 +398,53 @@ describe("prefetchData", () => {
 
     await client.connect();
 
-    expect(client.extract()).toMatchInlineSnapshot(`
+    await expect(
+      client.query({ query, variables: { id: 1 } })
+    ).resolves.toStrictEqual({
+      data: {
+        product: {
+          id: "1",
+          title: "Pen",
+          rating: 5,
+          price: 1.0,
+          description: "Awesome pen",
+          images: [],
+          __typename: "Product",
+        },
+      },
+    });
+
+    expect(client.extract()).toMatchInlineSnapshot(
+      {
+        "Product:1": {
+          __typename: "Product",
+          description: "Awesome pen",
+          id: "1",
+          images: [],
+          price: 1,
+          rating: 5,
+          title: "Pen",
+        },
+        "Product:2": {
+          __typename: "Product",
+          id: "2",
+          price: 999.99,
+          rating: 5,
+          title: "iPhone 17",
+        },
+        ROOT_QUERY: {
+          __typename: "Query",
+          'product({"id":1})': {
+            __ref: "Product:1",
+          },
+          topProducts: [
+            {
+              __ref: "Product:2",
+            },
+          ],
+        },
+      },
+      `
       {
         "Product:1": {
           "__typename": "Product",
@@ -397,21 +474,30 @@ describe("prefetchData", () => {
           ],
         },
       }
-    `);
+    `
+    );
   });
 
   test("excludes extra inputs when writing to cache", async () => {
     stubOpenAiGlobals({ toolInput: { id: 1, myOtherThing: 2 } });
     using _ = spyOnConsole("debug");
-    const client = new ApolloClient({
-      cache: new InMemoryCache(),
-      manifest: mockApplicationManifest(),
-    });
-    using host = await mockMcpHost({
-      hostContext: minimalHostContextWithToolName("GetProduct"),
-    });
 
-    host.onCleanup(() => client.stop());
+    const query = gql`
+      query Product($id: ID!)
+      @tool(name: "GetProduct", description: "Get a product") {
+        product(id: $id) {
+          id
+          title
+          rating
+          price
+          description
+          images
+          __typename
+        }
+      }
+    `;
+    const { client, host } = await setup({ query });
+    using _host = host;
 
     host.sendToolInput({ arguments: { id: 1, myOtherThing: 2 } });
     host.sendToolResult({
@@ -435,25 +521,39 @@ describe("prefetchData", () => {
 
     await client.connect();
 
-    expect(client.extract()).toMatchInlineSnapshot(`
-      {
-        "Product:1": {
-          "__typename": "Product",
-          "description": "Awesome pen",
-          "id": "1",
-          "images": [],
-          "price": 1,
-          "rating": 5,
-          "title": "Pen",
+    await expect(
+      client.query({ query, variables: { id: 1 } })
+    ).resolves.toStrictEqual({
+      data: {
+        product: {
+          id: "1",
+          title: "Pen",
+          rating: 5,
+          price: 1.0,
+          description: "Awesome pen",
+          images: [],
+          __typename: "Product",
         },
-        "ROOT_QUERY": {
-          "__typename": "Query",
-          "product({"id":1})": {
-            "__ref": "Product:1",
-          },
+      },
+    });
+
+    expect(client.extract()).toStrictEqual({
+      "Product:1": {
+        __typename: "Product",
+        description: "Awesome pen",
+        id: "1",
+        images: [],
+        price: 1,
+        rating: 5,
+        title: "Pen",
+      },
+      ROOT_QUERY: {
+        __typename: "Query",
+        'product({"id":1})': {
+          __ref: "Product:1",
         },
-      }
-    `);
+      },
+    });
   });
 });
 
@@ -473,7 +573,8 @@ test("reads result data from toolResponseMetadata.structuredContent", async () =
   using _ = spyOnConsole("debug");
 
   const query = gql`
-    query Product($id: ID!) {
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
       product(id: $id) @private {
         id
         title
@@ -482,36 +583,23 @@ test("reads result data from toolResponseMetadata.structuredContent", async () =
     }
   `;
 
-  const client = new ApolloClient({
-    cache: new InMemoryCache(),
-    manifest: mockApplicationManifest({
-      operations: [
-        {
-          id: "c43af26552874026c3fb346148c5795896aa2f3a872410a0a2621cffee25291c",
-          name: "Product",
-          type: "query",
-          body: print(query),
-          variables: { id: "ID" },
-          prefetch: false,
-          tools: [{ name: "GetProduct", description: "Get a product" }],
-        },
-      ],
-    }),
-  });
-  using host = await mockMcpHost({
-    hostContext: minimalHostContextWithToolName("GetProduct"),
-  });
-  host.onCleanup(() => client.stop());
+  const { client, host } = await setup({ query });
+  using _host = host;
 
   host.sendToolInput({ arguments: { id: "1" } });
   host.sendToolResult({
-    content: [],
     structuredContent: {},
   });
 
   await client.connect();
 
-  expect(client.extract()).toEqual({
+  await expect(
+    client.query({ query, variables: { id: "1" } })
+  ).resolves.toStrictEqual({
+    data: { product: { id: "1", title: "Pen", __typename: "Product" } },
+  });
+
+  expect(client.extract()).toStrictEqual({
     "Product:1": {
       __typename: "Product",
       id: "1",
@@ -540,7 +628,9 @@ test("merges prefetch from structuredContent and result from toolResponseMetadat
   using _ = spyOnConsole("debug");
 
   const prefetchQuery = gql`
-    query TopProducts {
+    query TopProducts
+    @tool(description: "Shows the currently highest rated products.")
+    @prefetch {
       topProducts {
         id
         title
@@ -550,7 +640,8 @@ test("merges prefetch from structuredContent and result from toolResponseMetadat
   `;
 
   const query = gql`
-    query Product($id: ID!) {
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
       product(id: $id) @private {
         id
         title
@@ -563,30 +654,8 @@ test("merges prefetch from structuredContent and result from toolResponseMetadat
     cache: new InMemoryCache(),
     manifest: mockApplicationManifest({
       operations: [
-        {
-          id: "1",
-          name: "TopProducts",
-          body: print(prefetchQuery),
-          type: "query",
-          variables: {},
-          prefetch: true,
-          prefetchID: "__anonymous",
-          tools: [
-            {
-              name: "TopProducts",
-              description: "Shows the currently highest rated products.",
-            },
-          ],
-        },
-        {
-          id: "2",
-          name: "Product",
-          body: print(query),
-          type: "query",
-          variables: { id: "ID" },
-          prefetch: false,
-          tools: [{ name: "GetProduct", description: "Get a product" }],
-        },
+        parseManifestOperation(prefetchQuery),
+        parseManifestOperation(query),
       ],
     }),
   });
@@ -597,7 +666,6 @@ test("merges prefetch from structuredContent and result from toolResponseMetadat
 
   host.sendToolInput({ arguments: { id: "2" } });
   host.sendToolResult({
-    content: [],
     structuredContent: {
       prefetch: {
         __anonymous: {
@@ -611,6 +679,12 @@ test("merges prefetch from structuredContent and result from toolResponseMetadat
 
   await client.connect();
 
+  await expect(
+    client.query({ query, variables: { id: "2" } })
+  ).resolves.toStrictEqual({
+    data: { product: { id: "2", title: "iPad", __typename: "Product" } },
+  });
+
   expect(client.extract()).toEqual({
     "Product:1": {
       __typename: "Product",
@@ -646,7 +720,8 @@ test("toolResponseMetadata.structuredContent wins over structuredContent", async
   using _ = spyOnConsole("debug");
 
   const query = gql`
-    query Product($id: ID!) {
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
       product(id: $id) {
         id
         title @private
@@ -655,30 +730,11 @@ test("toolResponseMetadata.structuredContent wins over structuredContent", async
     }
   `;
 
-  const client = new ApolloClient({
-    cache: new InMemoryCache(),
-    manifest: mockApplicationManifest({
-      operations: [
-        {
-          id: "1",
-          name: "Product",
-          body: print(query),
-          type: "query",
-          variables: { id: "ID" },
-          prefetch: false,
-          tools: [{ name: "GetProduct", description: "Get a product" }],
-        },
-      ],
-    }),
-  });
-  using host = await mockMcpHost({
-    hostContext: minimalHostContextWithToolName("GetProduct"),
-  });
-  host.onCleanup(() => client.stop());
+  const { client, host } = await setup({ query });
+  using _host = host;
 
   host.sendToolInput({ arguments: { id: "1" } });
   host.sendToolResult({
-    content: [],
     structuredContent: {
       result: {
         data: {
@@ -690,7 +746,13 @@ test("toolResponseMetadata.structuredContent wins over structuredContent", async
 
   await client.connect();
 
-  expect(client.extract()).toEqual({
+  await expect(
+    client.query({ query, variables: { id: "1" } })
+  ).resolves.toStrictEqual({
+    data: { product: { id: "1", title: "Meta title", __typename: "Product" } },
+  });
+
+  expect(client.extract()).toStrictEqual({
     "Product:1": {
       __typename: "Product",
       id: "1",
@@ -723,14 +785,24 @@ test("connects using window.openai.toolOutput when tool-result notification is n
     toolInput: { id: "1" },
   });
   using _ = spyOnConsole("debug");
-  const client = new ApolloClient({
-    cache: new InMemoryCache(),
-    manifest: mockApplicationManifest(),
-  });
-  using host = await mockMcpHost({
-    hostContext: minimalHostContextWithToolName("GetProduct"),
-  });
-  host.onCleanup(() => client.stop());
+
+  const query = gql`
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
+      product(id: $id) {
+        id
+        title
+        rating
+        price
+        description
+        images
+        __typename
+      }
+    }
+  `;
+
+  const { client, host } = await setup({ query });
+  using _host = host;
 
   host.sendToolInput({ arguments: { id: "1" } });
   // No host.sendToolResult() — simulates page reload where ChatGPT does not
@@ -742,25 +814,39 @@ test("connects using window.openai.toolOutput when tool-result notification is n
   // before `using host` disposes and closes the app connection.
   await new Promise((resolve) => setImmediate(resolve));
 
-  expect(client.extract()).toMatchInlineSnapshot(`
-    {
-      "Product:1": {
-        "__typename": "Product",
-        "description": "Awesome pen",
-        "id": "1",
-        "images": [],
-        "price": 1,
-        "rating": 5,
-        "title": "Pen",
+  await expect(
+    client.query({ query, variables: { id: "1" } })
+  ).resolves.toStrictEqual({
+    data: {
+      product: {
+        id: "1",
+        title: "Pen",
+        rating: 5,
+        price: 1.0,
+        description: "Awesome pen",
+        images: [],
+        __typename: "Product",
       },
-      "ROOT_QUERY": {
-        "__typename": "Query",
-        "product({"id":"1"})": {
-          "__ref": "Product:1",
-        },
+    },
+  });
+
+  expect(client.extract()).toStrictEqual({
+    "Product:1": {
+      __typename: "Product",
+      description: "Awesome pen",
+      id: "1",
+      images: [],
+      price: 1,
+      rating: 5,
+      title: "Pen",
+    },
+    ROOT_QUERY: {
+      __typename: "Query",
+      'product({"id":"1"})': {
+        __ref: "Product:1",
       },
-    }
-  `);
+    },
+  });
 });
 
 describe("custom links", () => {
@@ -900,6 +986,392 @@ describe("custom links", () => {
   });
 });
 
+test("serves tool result data on network-only query without calling execute tool", async () => {
+  stubOpenAiGlobals({ toolInput: { id: "1" } });
+  using _ = spyOnConsole("debug");
+  const query = gql`
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
+      product(id: $id) {
+        id
+        title
+        __typename
+      }
+    }
+  `;
+
+  const data = {
+    product: { id: "1", title: "Pen", __typename: "Product" },
+  };
+
+  const { client, host } = await setup({ query });
+  using _host = host;
+
+  const execute = vi.fn();
+  host.mockToolCall("execute", execute);
+
+  host.sendToolResult({ structuredContent: { result: { data } } });
+  host.sendToolInput({ arguments: { id: "1" } });
+
+  await client.connect();
+
+  await expect(
+    client.query({
+      query,
+      variables: { id: "1" },
+      fetchPolicy: "network-only",
+    })
+  ).resolves.toStrictEqual({ data });
+  expect(execute).not.toHaveBeenCalled();
+});
+
+test("calls execute tool on second network-only query after hydration is consumed", async () => {
+  stubOpenAiGlobals({ toolInput: { id: "1" } });
+  using _ = spyOnConsole("debug");
+  const query = gql`
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
+      product(id: $id) {
+        id
+        title
+        __typename
+      }
+    }
+  `;
+
+  const { client, host } = await setup({ query });
+  using _host = host;
+
+  host.mockToolCall("execute", () => ({
+    structuredContent: {
+      data: {
+        product: { id: "1", title: "Updated Pen", __typename: "Product" },
+      },
+    },
+  }));
+
+  host.sendToolResult({
+    structuredContent: {
+      result: {
+        data: {
+          product: { id: "1", title: "Pen", __typename: "Product" },
+        },
+      },
+    },
+  });
+  host.sendToolInput({ arguments: { id: "1" } });
+
+  await client.connect();
+
+  await client.query({
+    query,
+    variables: { id: "1" },
+    fetchPolicy: "network-only",
+  });
+
+  await expect(
+    client.query({
+      query,
+      variables: { id: "1" },
+      fetchPolicy: "network-only",
+    })
+  ).resolves.toStrictEqual({
+    data: {
+      product: { id: "1", title: "Updated Pen", __typename: "Product" },
+    },
+  });
+});
+
+test("serves tool result data on cache-and-network query without calling execute tool", async () => {
+  stubOpenAiGlobals({ toolInput: { id: "1" } });
+  using _ = spyOnConsole("debug");
+  const query = gql`
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
+      product(id: $id) {
+        id
+        title
+        __typename
+      }
+    }
+  `;
+
+  const { client, host } = await setup({ query });
+  using _host = host;
+
+  const execute = vi.fn();
+  host.mockToolCall("execute", execute);
+
+  host.sendToolResult({
+    structuredContent: {
+      result: {
+        data: {
+          product: { id: "1", title: "Pen", __typename: "Product" },
+        },
+      },
+    },
+  });
+  host.sendToolInput({ arguments: { id: "1" } });
+
+  await client.connect();
+
+  const stream = new ObservableStream(
+    client.watchQuery({
+      query,
+      variables: { id: "1" },
+      fetchPolicy: "cache-and-network",
+    })
+  );
+
+  // The hydrated result is emitted synchronously so we won't observe a loading
+  // state like we normally would with `cache-and-network`
+  await expect(stream).toEmitValue({
+    data: { product: { id: "1", title: "Pen", __typename: "Product" } },
+    dataState: "complete",
+    loading: false,
+    networkStatus: NetworkStatus.ready,
+    partial: false,
+  });
+
+  await expect(stream).not.toEmitAnything();
+
+  expect(execute).not.toHaveBeenCalled();
+});
+
+test("serves tool result data on no-cache query without calling execute tool and does not write to cache", async () => {
+  stubOpenAiGlobals({ toolInput: { id: "1" } });
+  using _ = spyOnConsole("debug");
+  const query = gql`
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
+      product(id: $id) {
+        id
+        title
+        __typename
+      }
+    }
+  `;
+
+  const data = {
+    product: { id: "1", title: "Pen", __typename: "Product" },
+  };
+
+  const { client, host } = await setup({ query });
+  using _host = host;
+
+  const execute = vi.fn();
+  host.mockToolCall("execute", execute);
+
+  host.sendToolInput({ arguments: { id: "1" } });
+  host.sendToolResult({ structuredContent: { result: { data } } });
+
+  await client.connect();
+
+  await expect(
+    client.query({ query, variables: { id: "1" }, fetchPolicy: "no-cache" })
+  ).resolves.toStrictEqual({ data });
+  expect(execute).not.toHaveBeenCalled();
+  expect(client.extract()).toStrictEqual({});
+});
+
+test("hydrates prefetch query with network-only fetch policy", async () => {
+  stubOpenAiGlobals({ toolInput: {} });
+  using _ = spyOnConsole("debug");
+
+  const query = gql`
+    query TopProducts @tool(description: "Shows top products") @prefetch {
+      topProducts {
+        id
+        title
+        __typename
+      }
+    }
+  `;
+
+  const data = {
+    topProducts: [{ id: "1", title: "iPhone", __typename: "Product" }],
+  };
+
+  const { client, host } = await setup({ query, toolName: "OtherTool" });
+  using _host = host;
+
+  const execute = vi.fn();
+  host.mockToolCall("execute", execute);
+
+  host.sendToolResult({
+    structuredContent: {
+      prefetch: { __anonymous: { data } },
+    },
+  });
+  host.sendToolInput({ arguments: {} });
+
+  await client.connect();
+
+  await expect(
+    client.query({ query, fetchPolicy: "network-only" })
+  ).resolves.toStrictEqual({ data });
+  expect(execute).not.toHaveBeenCalled();
+});
+
+test("serves hydrated query from tool result while other network-only queries call execute", async () => {
+  stubOpenAiGlobals({ toolInput: { id: "1" } });
+  using _ = spyOnConsole("debug");
+
+  const productQuery = gql`
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
+      product(id: $id) {
+        id
+        title
+        __typename
+      }
+    }
+  `;
+
+  const cartQuery = gql`
+    query Cart @tool(name: "GetCart", description: "Get the cart") {
+      cart {
+        id
+        __typename
+      }
+    }
+  `;
+
+  const productOperation = parseManifestOperation(productQuery);
+  const cartOperation = parseManifestOperation(cartQuery);
+
+  const client = new ApolloClient({
+    cache: new InMemoryCache(),
+    manifest: mockApplicationManifest({
+      operations: [productOperation, cartOperation],
+    }),
+  });
+
+  using host = await mockMcpHost({
+    hostContext: minimalHostContextWithToolName("GetProduct"),
+  });
+  host.onCleanup(() => client.stop());
+
+  const execute = vi.fn(() => ({
+    structuredContent: {
+      data: { cart: { id: "1", __typename: "Cart" } },
+    },
+  }));
+  host.mockToolCall("execute", execute);
+
+  host.sendToolResult({
+    structuredContent: {
+      result: {
+        data: { product: { id: "1", title: "Pen", __typename: "Product" } },
+      },
+    },
+  });
+  host.sendToolInput({ arguments: { id: "1" } });
+
+  await client.connect();
+
+  const [productResult, cartResult] = await Promise.all([
+    client.query({
+      query: productQuery,
+      variables: { id: "1" },
+      fetchPolicy: "network-only",
+    }),
+    client.query({
+      query: cartQuery,
+      fetchPolicy: "network-only",
+    }),
+  ]);
+
+  expect(productResult).toStrictEqual({
+    data: { product: { id: "1", title: "Pen", __typename: "Product" } },
+  });
+  expect(cartResult).toStrictEqual({
+    data: { cart: { id: "1", __typename: "Cart" } },
+  });
+  expect(execute).toHaveBeenCalledOnce();
+});
+
+test("serves hydrated query after tool result while earlier-queued non-matching query calls execute", async () => {
+  stubOpenAiGlobals({ toolInput: { id: "1" } });
+  using _ = spyOnConsole("debug");
+
+  const productQuery = gql`
+    query Product($id: ID!)
+    @tool(name: "GetProduct", description: "Get a product") {
+      product(id: $id) {
+        id
+        title
+        __typename
+      }
+    }
+  `;
+
+  const cartQuery = gql`
+    query Cart @tool(name: "GetCart", description: "Get the cart") {
+      cart {
+        id
+        __typename
+      }
+    }
+  `;
+
+  const productOperation = parseManifestOperation(productQuery);
+  const cartOperation = parseManifestOperation(cartQuery);
+
+  const client = new ApolloClient({
+    cache: new InMemoryCache(),
+    manifest: mockApplicationManifest({
+      operations: [productOperation, cartOperation],
+    }),
+  });
+
+  using host = await mockMcpHost({
+    hostContext: minimalHostContextWithToolName("GetProduct"),
+  });
+  host.onCleanup(() => client.stop());
+
+  const execute = vi.fn(() => ({
+    structuredContent: {
+      data: { cart: { id: "1", __typename: "Cart" } },
+    },
+  }));
+  host.mockToolCall("execute", execute);
+
+  const connectPromise = client.connect();
+
+  const cartPromise = client.query({
+    query: cartQuery,
+    fetchPolicy: "network-only",
+  });
+
+  host.sendToolResult({
+    structuredContent: {
+      result: {
+        data: { product: { id: "1", title: "Pen", __typename: "Product" } },
+      },
+    },
+  });
+  host.sendToolInput({ arguments: { id: "1" } });
+
+  await connectPromise;
+
+  await expect(cartPromise).resolves.toStrictEqual({
+    data: { cart: { id: "1", __typename: "Cart" } },
+  });
+
+  await expect(
+    client.query({
+      query: productQuery,
+      variables: { id: "1" },
+      fetchPolicy: "network-only",
+    })
+  ).resolves.toStrictEqual({
+    data: { product: { id: "1", title: "Pen", __typename: "Product" } },
+  });
+
+  expect(execute).toHaveBeenCalledOnce();
+});
+
 describe("watchQuery dev warnings", () => {
   const query = gql`
     query Products($category: String!, $page: Int!, $sortBy: String!)
@@ -1004,3 +1476,26 @@ describe("watchQuery dev warnings", () => {
     expect(console.warn).toHaveBeenCalledTimes(1);
   });
 });
+
+async function setup({
+  query,
+  toolName,
+}: {
+  query: DocumentNode;
+  toolName?: string;
+}) {
+  const operation = parseManifestOperation(query);
+  const client = new ApolloClient({
+    cache: new InMemoryCache(),
+    manifest: mockApplicationManifest({ operations: [operation] }),
+  });
+
+  const host = await mockMcpHost({
+    hostContext: minimalHostContextWithToolName(
+      toolName ?? operation.tools[0].name
+    ),
+  });
+  host.onCleanup(() => client.stop());
+
+  return { client, host };
+}