@apollo/client-ai-apps 0.6.4 → 0.7.0

package/src/openai/index.ts

@@ -1,2 +1 @@
 export { ApolloClient } from "./core/ApolloClient.js";
-export { ToolCallLink } from "./link/ToolCallLink.js";

package/src/openai/react/index.ts

@@ -1,8 +1 @@
-export { useApp } from "./hooks/useApp.js";
-export { useHostContext } from "./hooks/useHostContext.js";
-export { useToolName } from "./hooks/useToolName.js";
-export { useToolMetadata } from "./hooks/useToolMetadata.js";
-export { useToolInput } from "./hooks/useToolInput.js";
-export { useToolInfo } from "./hooks/useToolInfo.js";
-export { createHydrationUtils } from "./hooks/createHydrationUtils.js";
 export { useWidgetState } from "./hooks/useWidgetState.js";

package/src/react/ApolloProvider.tsx

@@ -1,7 +1,6 @@
 import type { ReactNode } from "react";
 import { use } from "react";
 import { ApolloProvider as BaseApolloProvider } from "@apollo/client/react";
-import type { ApolloClient as BaseApolloClient } from "@apollo/client";
 import { ApolloClient as OpenAiApolloClient } from "../openai/core/ApolloClient.js";
 import { ApolloClient as McpApolloClient } from "../mcp/core/ApolloClient.js";
 import type { ApolloClient as FallbackApolloClient } from "../core/ApolloClient.js";
@@ -27,9 +26,5 @@ export function ApolloProvider({ children, client }: ApolloProvider.Props) {
 
   use(client.connect());
 
-  return (
-    <BaseApolloProvider client={client as BaseApolloClient}>
-      {children}
-    </BaseApolloProvider>
-  );
+  return <BaseApolloProvider client={client}>{children}</BaseApolloProvider>;
 }

package/src/react/__tests__/ApolloProvider/mcp.test.tsx

@@ -4,48 +4,80 @@ import { ApolloProvider } from "../../ApolloProvider.js";
 import { waitFor } from "@testing-library/react";
 import { ApolloClient } from "../../../mcp/core/ApolloClient.js";
 import { gql, InMemoryCache } from "@apollo/client";
-import { print } from "@apollo/client/utilities";
 import {
   minimalHostContextWithToolName,
   mockApplicationManifest,
   mockMcpHost,
+  parseManifestOperation,
   renderAsync,
   spyOnConsole,
 } from "../../../testing/internal/index.js";
 
-test("writes to the cache as soon as toolOutput is available", async () => {
+test("writes prefetch data to the cache when immediately available", async () => {
+  using _ = spyOnConsole("debug");
+
+  const query = gql`
+    query GreetingQuery @tool(description: "Fetches a greeting") @prefetch {
+      greeting
+    }
+  `;
+
+  const client = new ApolloClient({
+    cache: new InMemoryCache(),
+    manifest: mockApplicationManifest({
+      operations: [parseManifestOperation(query)],
+    }),
+  });
+
+  using host = await mockMcpHost({
+    hostContext: minimalHostContextWithToolName("OtherTool"),
+  });
+  host.onCleanup(() => client.stop());
+
+  host.sendToolInput({ arguments: {} });
+  host.sendToolResult({
+    structuredContent: {
+      result: {
+        data: null,
+      },
+      prefetch: {
+        __anonymous: { data: { greeting: "hello" } },
+      },
+    },
+  });
+
+  await renderAsync(<ApolloProvider client={client} />, {
+    wrapper: ({ children }) => <Suspense>{children}</Suspense>,
+  });
+
+  await waitFor(() => {
+    expect(client.extract()).toStrictEqual({
+      ROOT_QUERY: {
+        __typename: "Query",
+        greeting: "hello",
+      },
+    });
+  });
+});
+
+test("hydrates the tool result and writes to the cache when query first executes", async () => {
   using _ = spyOnConsole("debug");
 
-  const toolName = "GreetingQuery";
   using host = await mockMcpHost({
-    hostContext: minimalHostContextWithToolName(toolName),
+    hostContext: minimalHostContextWithToolName("GreetingQuery"),
   });
   host.onCleanup(() => client.stop());
 
   const query = gql`
-    query GreetingQuery {
+    query GreetingQuery @tool(description: "Fetches a greeting") {
       greeting
     }
   `;
-  const data = {
-    greeting: "hello",
-  };
 
   const client = new ApolloClient({
     cache: new InMemoryCache(),
     manifest: mockApplicationManifest({
-      operations: [
-        {
-          id: "1",
-          name: "GreetingQuery",
-          body: print(query),
-          prefetch: true,
-          prefetchID: "__anonymous",
-          type: "query",
-          variables: {},
-          tools: [{ name: toolName, description: "Fetches a greeting" }],
-        },
-      ],
+      operations: [parseManifestOperation(query)],
     }),
   });
 
@@ -59,16 +91,21 @@ test("writes to the cache as soon as toolOutput is available", async () => {
 
   host.sendToolInput({ arguments: {} });
   host.sendToolResult({
-    content: [{ type: "text", text: JSON.stringify({ result: { data } }) }],
-    structuredContent: { result: { data } },
+    structuredContent: { result: { data: { greeting: "hello" } } },
   });
 
-  await waitFor(() => {
-    expect(client.extract()).toEqual({
-      ROOT_QUERY: {
-        __typename: "Query",
-        greeting: "hello",
-      },
-    });
+  await expect(
+    waitFor(() => expect(client.extract()).not.toEqual({}))
+  ).rejects.toThrow();
+
+  await expect(client.query({ query })).resolves.toStrictEqual({
+    data: { greeting: "hello" },
+  });
+
+  expect(client.extract()).toStrictEqual({
+    ROOT_QUERY: {
+      __typename: "Query",
+      greeting: "hello",
+    },
   });
 });

package/src/react/__tests__/ApolloProvider/openai.test.tsx

@@ -4,22 +4,22 @@ import { ApolloProvider } from "../../ApolloProvider.js";
 import { waitFor } from "@testing-library/react";
 import { ApolloClient } from "../../../openai/core/ApolloClient.js";
 import { gql, InMemoryCache } from "@apollo/client";
-import { print } from "@apollo/client/utilities";
 import {
   minimalHostContextWithToolName,
   mockApplicationManifest,
   mockMcpHost,
+  parseManifestOperation,
   renderAsync,
   spyOnConsole,
   stubOpenAiGlobals,
 } from "../../../testing/internal/index.js";
 
-test("writes data to the cache when immediately available", async () => {
+test("writes prefetch data to the cache when immediately available", async () => {
   stubOpenAiGlobals();
   using _ = spyOnConsole("debug");
 
   const query = gql`
-    query GreetingQuery {
+    query GreetingQuery @tool(description: "Fetches a greeting") @prefetch {
       greeting
     }
   `;
@@ -31,18 +31,7 @@ test("writes data to the cache when immediately available", async () => {
   const client = new ApolloClient({
     cache: new InMemoryCache(),
     manifest: mockApplicationManifest({
-      operations: [
-        {
-          id: "1",
-          name: "GreetingQuery",
-          body: print(query),
-          prefetch: true,
-          prefetchID: "__anonymous",
-          type: "query",
-          variables: {},
-          tools: [],
-        },
-      ],
+      operations: [parseManifestOperation(query)],
     }),
   });
 
@@ -53,7 +42,6 @@ test("writes data to the cache when immediately available", async () => {
 
   host.sendToolInput({ arguments: {} });
   host.sendToolResult({
-    content: [],
     structuredContent: {
       result: {
         data: null,
@@ -78,36 +66,20 @@ test("writes data to the cache when immediately available", async () => {
   });
 });
 
-test("writes to the cache as soon as toolOutput is available", async () => {
+test("hydrates the tool result and writes to the cache when query first executes", async () => {
   stubOpenAiGlobals();
   using _ = spyOnConsole("debug");
 
-  stubOpenAiGlobals();
-
   const query = gql`
-    query GreetingQuery {
+    query GreetingQuery @tool(description: "Fetches a greeting") {
       greeting
     }
   `;
-  const data = {
-    greeting: "hello",
-  };
 
   const client = new ApolloClient({
     cache: new InMemoryCache(),
     manifest: mockApplicationManifest({
-      operations: [
-        {
-          id: "1",
-          name: "GreetingQuery",
-          body: print(query),
-          prefetch: true,
-          prefetchID: "__anonymous",
-          type: "query",
-          variables: {},
-          tools: [],
-        },
-      ],
+      operations: [parseManifestOperation(query)],
     }),
   });
 
@@ -127,12 +99,15 @@ test("writes to the cache as soon as toolOutput is available", async () => {
   ).rejects.toThrow();
 
   host.sendToolResult({
-    content: [],
-    structuredContent: {
-      prefetch: {
-        __anonymous: { data },
-      },
-    },
+    structuredContent: { result: { data: { greeting: "hello" } } },
+  });
+
+  await expect(
+    waitFor(() => expect(client.extract()).not.toEqual({}))
+  ).rejects.toThrow();
+
+  await expect(client.query({ query })).resolves.toStrictEqual({
+    data: { greeting: "hello" },
   });
 
   await waitFor(() => {