@apollo/client-ai-apps 0.6.5 → 0.7.0

package/src/mcp/core/McpAppManager.ts

@@ -1,136 +0,0 @@
-import {
-  App,
-  PostMessageTransport,
-  type McpUiHostContextChangedNotification,
-} from "@modelcontextprotocol/ext-apps";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import type { ApplicationManifest } from "../../types/application-manifest";
-import type { FormattedExecutionResult } from "graphql";
-import type { DocumentNode, OperationVariables } from "@apollo/client";
-import { print } from "@apollo/client/utilities";
-import { cacheAsync, promiseWithResolvers } from "../../utilities";
-import type { ApolloMcpServerApps } from "../../core/types";
-
-type ExecuteQueryCallToolResult = Omit<CallToolResult, "structuredContent"> & {
-  structuredContent: FormattedExecutionResult;
-  _meta?: { structuredContent?: FormattedExecutionResult };
-};
-
-/** @internal */
-export class McpAppManager {
-  readonly app: App;
-
-  #toolName: string | undefined;
-  #toolMetadata: ApolloMcpServerApps.CallToolResult["_meta"] | undefined;
-  #toolInput: Record<string, unknown> | undefined;
-
-  #hostContextCallbacks = new Set<
-    (params: McpUiHostContextChangedNotification["params"]) => void
-  >();
-
-  constructor(manifest: ApplicationManifest) {
-    this.app = new App({ name: manifest.name, version: manifest.appVersion });
-  }
-
-  get toolName() {
-    return this.#toolName;
-  }
-
-  get toolMetadata() {
-    return this.#toolMetadata;
-  }
-
-  get toolInput() {
-    return this.#toolInput;
-  }
-
-  onHostContextChanged(
-    cb: (params: McpUiHostContextChangedNotification["params"]) => void
-  ) {
-    this.#hostContextCallbacks.add(cb);
-
-    return () => {
-      this.#hostContextCallbacks.delete(cb);
-    };
-  }
-
-  connect = cacheAsync(async () => {
-    let toolResult = promiseWithResolvers<ApolloMcpServerApps.CallToolResult>();
-    let toolInput = promiseWithResolvers<Parameters<App["ontoolinput"]>[0]>();
-
-    this.app.ontoolresult = (params) => {
-      toolResult.resolve(
-        params as unknown as ApolloMcpServerApps.CallToolResult
-      );
-    };
-
-    this.app.ontoolinput = (params) => {
-      toolInput.resolve(params);
-    };
-
-    this.app.onhostcontextchanged = (params) => {
-      this.#hostContextCallbacks.forEach((cb) => cb(params));
-    };
-
-    await this.connectToHost();
-
-    const { structuredContent, _meta } = await toolResult.promise;
-    const { arguments: args } = await toolInput.promise;
-
-    // Some hosts do not provide toolInfo in the ui/initialize response, so we
-    // fallback to `_meta.toolName` provided by Apollo MCP server if the value
-    // is not available.
-    this.#toolName =
-      this.app.getHostContext()?.toolInfo?.tool.name ??
-      _meta?.toolName ??
-      // Some hosts do not forward `_meta` nor do they provide `toolInfo`. Our
-      // MCP server provides `toolName` in `structuredContent` as a workaround
-      // that we can use if all else fails
-      structuredContent.toolName;
-    this.#toolMetadata = _meta;
-    this.#toolInput = args;
-
-    return {
-      structuredContent: {
-        ...structuredContent,
-        ..._meta?.structuredContent,
-      },
-      toolName: this.toolName,
-      args,
-    };
-  });
-
-  close() {
-    return this.app.close();
-  }
-
-  async executeQuery({
-    query,
-    variables,
-  }: {
-    query: DocumentNode;
-    variables: OperationVariables | undefined;
-  }) {
-    const result = (await this.app.callServerTool({
-      name: "execute",
-      arguments: { query: print(query), variables },
-    })) as ExecuteQueryCallToolResult;
-
-    return {
-      ...result.structuredContent,
-      ...result._meta?.structuredContent,
-    };
-  }
-
-  private async connectToHost() {
-    try {
-      return await this.app.connect(
-        new PostMessageTransport(window.parent, window.parent)
-      );
-    } catch (e) {
-      const error = e instanceof Error ? e : new Error("Failed to connect");
-
-      throw error;
-    }
-  }
-}

package/src/mcp/link/ToolCallLink.ts

@@ -1,40 +0,0 @@
-import { ApolloLink, Observable } from "@apollo/client";
-import { from } from "rxjs";
-import type { ApolloClient as McpApolloClient } from "../core/ApolloClient";
-
-/**
- * A terminating link that sends a GraphQL request through an agent tool call.
- * When providing a custom link chain to `ApolloClient`, `ApolloClient` will
- * validate that the terminating link is an instance of this link.
- *
- * @example Providing a custom link chain
- *
- * ```ts
- * import { ApolloLink } from "@apollo/client";
- * import { ApolloClient, ToolCallLink } from "@apollo/client-ai-apps";
- *
- * const link = ApolloLink.from([
- *   ...otherLinks,
- *   new ToolCallLink()
- * ]);
- *
- * const client = new ApolloClient({
- *   link,
- *   // ...
- * });
- * ```
- */
-export class ToolCallLink extends ApolloLink {
-  readonly name = "ToolCallLink";
-
-  request(operation: ApolloLink.Operation): Observable<ApolloLink.Result> {
-    const client = operation.client as McpApolloClient;
-
-    return from(
-      client["appManager"].executeQuery({
-        query: operation.query,
-        variables: operation.variables,
-      })
-    );
-  }
-}

package/src/mcp/link/__tests__/ToolCallLink.test.ts

@@ -1,113 +0,0 @@
-import { expect, test } from "vitest";
-import { gql, InMemoryCache } from "@apollo/client";
-import { execute } from "@apollo/client/link";
-import { ApolloClient } from "../../core/ApolloClient.js";
-import {
-  minimalHostContextWithToolName,
-  mockApplicationManifest,
-  mockMcpHost,
-  ObservableStream,
-  spyOnConsole,
-} from "../../../testing/internal/index.js";
-import { ToolCallLink } from "../ToolCallLink.js";
-
-test("merges _meta.structuredContent into result for @private fields", async () => {
-  using _ = spyOnConsole("debug");
-  const query = gql`
-    query GreetingQuery {
-      greeting @private
-    }
-  `;
-
-  const client = new ApolloClient({
-    cache: new InMemoryCache(),
-    manifest: mockApplicationManifest(),
-  });
-
-  using host = await mockMcpHost({
-    hostContext: minimalHostContextWithToolName("GetProduct"),
-  });
-  host.onCleanup(() => client.stop());
-
-  host.sendToolInput({ arguments: {} });
-  host.sendToolResult({
-    _meta: { toolName: "GetProduct" },
-    content: [],
-    structuredContent: {
-      result: {
-        data: {
-          product: null,
-        },
-      },
-    },
-  });
-
-  host.mockToolCall("execute", () => ({
-    content: [],
-    structuredContent: {},
-    _meta: {
-      structuredContent: { data: { greeting: "Hello, private world" } },
-    },
-  }));
-
-  await client.connect();
-
-  const observable = execute(new ToolCallLink(), { query }, { client });
-  const stream = new ObservableStream(observable);
-
-  await expect(stream).toEmitValue({
-    data: { greeting: "Hello, private world" },
-  });
-
-  await expect(stream).toComplete();
-});
-
-test("delegates query execution to MCP host", async () => {
-  using _ = spyOnConsole("debug");
-  const query = gql`
-    query GreetingQuery {
-      greeting
-    }
-  `;
-
-  const client = new ApolloClient({
-    cache: new InMemoryCache(),
-    manifest: mockApplicationManifest(),
-  });
-
-  using host = await mockMcpHost({
-    hostContext: minimalHostContextWithToolName("GetProduct"),
-  });
-  host.onCleanup(() => client.stop());
-
-  host.sendToolInput({ arguments: {} });
-  host.sendToolResult({
-    _meta: { toolName: "GetProduct" },
-    content: [],
-    structuredContent: {
-      result: {
-        data: {
-          product: null,
-        },
-      },
-    },
-  });
-
-  host.mockToolCall("execute", () => ({
-    content: [],
-    structuredContent: {
-      data: { greeting: "Hello, world" },
-    },
-  }));
-
-  await client.connect();
-
-  const observable = execute(new ToolCallLink(), { query }, { client });
-  const stream = new ObservableStream(observable);
-
-  await expect(stream).toEmitValue({
-    data: { greeting: "Hello, world" },
-  });
-
-  await expect(stream).toComplete();
-});