@apollo/client-ai-apps 0.1.0

package/.changeset/README.md

@@ -0,0 +1,8 @@
+# Changesets
+
+Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
+with multi-package repos, or single-package repos to help you version and publish your code. You can
+find the full documentation for it [in our repository](https://github.com/changesets/changesets)
+
+We have a quick list of common questions to get you started engaging with this project in
+[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "restricted",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/.github/workflows/pr.yaml

@@ -0,0 +1,24 @@
+name: Build on PR
+
+on:
+    pull_request:
+        types: [opened, synchronize, reopened]
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Set up Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 20.x
+
+            - name: Install dependencies
+              run: npm ci
+
+            - name: Run build
+              run: npm run build

package/.github/workflows/release.yaml

@@ -0,0 +1,36 @@
+name: Release new Version
+
+on:
+    workflow_dispatch:
+
+jobs:
+    release:
+        name: Release
+        if: github.repository == 'apollographql/apollo-ai-apps-client'
+        runs-on: ubuntu-latest
+        permissions:
+            contents: write # to create release (changesets/action)
+            issues: write # to post issue comments (changesets/action)
+            pull-requests: write # to create pull request (changesets/action)
+            id-token: write # to use OpenID Connect token for provenance (changesets/action)
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Setup Node.js 20.x
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 20.x
+
+            - name: Install dependencies
+              shell: bash
+              run: npm ci
+
+            - name: Create Release Pull Request or Publish to npm
+              uses: changesets/action@v1
+              with:
+                  publish: npm run build
+                  version: changeset:version
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+                  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+                  NPM_CONFIG_PROVENANCE: true

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Apollo GraphQL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/apollo_client/client.d.ts

@@ -0,0 +1,14 @@
+import { ApolloClient } from "@apollo/client";
+import "../types/openai";
+import { ApplicationManifest } from "../types/application-manifest";
+type ExtendedApolloClientOptions = Omit<ApolloClient.Options, "link" | "cache"> & {
+    link?: ApolloClient.Options["link"];
+    cache?: ApolloClient.Options["cache"];
+    manifest: ApplicationManifest;
+};
+export declare class ExtendedApolloClient extends ApolloClient {
+    manifest: ApplicationManifest;
+    constructor(options: ExtendedApolloClientOptions);
+    prefetchData(): Promise<void>;
+}
+export {};

package/dist/apollo_client/provider.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ExtendedApolloClient } from "./client";
+export declare const ExtendedApolloProvider: ({ children, client, }: React.PropsWithChildren<{
+    client: ExtendedApolloClient;
+}>) => React.JSX.Element;

package/dist/hooks/useOpenAiGlobal.d.ts

@@ -0,0 +1,2 @@
+import { OpenAiGlobals } from "../types/openai";
+export declare function useOpenAiGlobal<K extends keyof OpenAiGlobals>(key: K): OpenAiGlobals[K];

package/dist/hooks/useRequestDisplayMode.d.ts

@@ -0,0 +1,4 @@
+import { DisplayMode } from "../types/openai";
+export declare const useRequestDisplayMode: () => (args: {
+    mode: DisplayMode;
+}) => Promise<void>;

package/dist/hooks/useSendFollowUpMessage.d.ts

@@ -0,0 +1 @@
+export declare const useSendFollowUpMessage: () => (prompt: string) => Promise<void>;

package/dist/hooks/useToolEffect.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare function ToolUseProvider({ children, appName }: {
+    children: any;
+    appName: string;
+}): React.JSX.Element;
+export declare const useToolEffect: (toolName: string | string[], effect: (toolInput: any) => void, deps?: React.DependencyList) => void;

package/dist/hooks/useToolInput.d.ts

@@ -0,0 +1 @@
+export declare const useToolInput: () => any;

package/dist/hooks/useToolName.d.ts

@@ -0,0 +1 @@
+export declare const useToolName: () => any;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./types/openai";
+export * from "./types/application-manifest";
+export * from "./hooks/useOpenAiGlobal";
+export * from "./hooks/useToolName";
+export * from "./hooks/useToolInput";
+export * from "./hooks/useSendFollowUpMessage";
+export * from "./hooks/useRequestDisplayMode";
+export * from "./hooks/useToolEffect";
+export * from "@apollo/client";
+export { ExtendedApolloClient as ApolloClient } from "./apollo_client/client";
+export { ExtendedApolloProvider as ApolloProvider } from "./apollo_client/provider";

package/dist/index.js

@@ -0,0 +1,177 @@
+// src/types/openai.ts
+var SET_GLOBALS_EVENT_TYPE = "openai:set_globals";
+var SetGlobalsEvent = class extends CustomEvent {
+  type = SET_GLOBALS_EVENT_TYPE;
+};
+
+// src/hooks/useOpenAiGlobal.ts
+import { useSyncExternalStore } from "react";
+function useOpenAiGlobal(key) {
+  return useSyncExternalStore(
+    (onChange) => {
+      const handleSetGlobal = (event) => {
+        const value = event.detail.globals[key];
+        if (value === void 0) {
+          return;
+        }
+        onChange();
+      };
+      window.addEventListener(SET_GLOBALS_EVENT_TYPE, handleSetGlobal, {
+        passive: true
+      });
+      return () => {
+        window.removeEventListener(SET_GLOBALS_EVENT_TYPE, handleSetGlobal);
+      };
+    },
+    () => window.openai[key]
+  );
+}
+
+// src/hooks/useToolName.ts
+var useToolName = () => {
+  const toolResponseMetadata = useOpenAiGlobal("toolResponseMetadata");
+  return toolResponseMetadata?.toolName;
+};
+
+// src/hooks/useToolInput.ts
+var useToolInput = () => {
+  const toolInput = useOpenAiGlobal("toolInput");
+  return toolInput;
+};
+
+// src/hooks/useSendFollowUpMessage.ts
+var useSendFollowUpMessage = () => {
+  return async (prompt) => {
+    await window.openai?.sendFollowUpMessage({
+      prompt
+    });
+  };
+};
+
+// src/hooks/useRequestDisplayMode.ts
+var useRequestDisplayMode = () => {
+  return async (args) => {
+    await window.openai?.requestDisplayMode(args);
+  };
+};
+
+// src/hooks/useToolEffect.tsx
+import React, { useEffect, useState } from "react";
+var ToolUseContext = React.createContext(null);
+function ToolUseProvider({ children, appName }) {
+  const [hasNavigated, setHasNavigated] = useState(false);
+  return /* @__PURE__ */ React.createElement(ToolUseContext.Provider, { value: { hasNavigated, setHasNavigated, appName } }, children);
+}
+var useToolEffect = (toolName, effect, deps = []) => {
+  const ctx = React.useContext(ToolUseContext);
+  const fullToolName = useToolName();
+  const toolInput = useToolInput();
+  if (!ctx) throw new Error("useToolEffect must be used within ToolUseProvider");
+  const toolNames = Array.isArray(toolName) ? toolName : [toolName];
+  useEffect(() => {
+    const matches = toolNames.some((name) => fullToolName === `${ctx.appName}--${name}`);
+    if (!ctx.hasNavigated && matches) {
+      effect(toolInput);
+      ctx.setHasNavigated(true);
+    }
+  }, [ctx.hasNavigated, ctx.setHasNavigated, ctx.appName, toolNames, fullToolName, toolInput, ...deps]);
+};
+
+// src/index.ts
+export * from "@apollo/client";
+
+// src/apollo_client/client.ts
+import { ApolloClient, ApolloLink, InMemoryCache } from "@apollo/client";
+import * as Observable from "rxjs";
+import { selectHttpOptionsAndBody } from "@apollo/client/link/http";
+import { fallbackHttpConfig } from "@apollo/client/link/http";
+import { DocumentTransform } from "@apollo/client";
+import { removeDirectivesFromDocument } from "@apollo/client/utilities/internal";
+import { parse } from "graphql";
+var toolCallLink = new ApolloLink((operation) => {
+  const context = operation.getContext();
+  const contextConfig = {
+    http: context.http,
+    options: context.fetchOptions,
+    credentials: context.credentials,
+    headers: context.headers
+  };
+  const { query, variables } = selectHttpOptionsAndBody(operation, fallbackHttpConfig, contextConfig).body;
+  return Observable.from(window.openai.callTool("execute", { query, variables })).pipe(
+    Observable.map((result) => ({ data: result.structuredContent.data }))
+  );
+});
+var ExtendedApolloClient = class extends ApolloClient {
+  manifest;
+  constructor(options) {
+    super({
+      link: toolCallLink,
+      cache: options.cache ?? new InMemoryCache(),
+      // Strip out the prefetch/tool directives so they don't get sent with the operation to the server
+      documentTransform: new DocumentTransform((document) => {
+        return removeDirectivesFromDocument([{ name: "prefetch" }, { name: "tool" }], document);
+      })
+    });
+    this.manifest = options.manifest;
+  }
+  async prefetchData() {
+    this.manifest.operations.forEach((operation) => {
+      if (operation.prefetch && operation.prefetchID && window.openai.toolOutput.prefetch[operation.prefetchID]) {
+        this.writeQuery({
+          query: parse(operation.body),
+          data: window.openai.toolOutput.prefetch[operation.prefetchID].data
+        });
+      }
+      if (operation.tools?.find(
+        (tool) => `${this.manifest.name}--${tool.name}` === window.openai.toolResponseMetadata.toolName
+      )) {
+        const variables = Object.keys(window.openai.toolInput).reduce(
+          (obj, key) => operation.variables[key] ? { ...obj, [key]: window.openai.toolInput[key] } : obj,
+          {}
+        );
+        this.writeQuery({
+          query: parse(operation.body),
+          data: window.openai.toolOutput.result.data,
+          variables
+        });
+      }
+    });
+  }
+};
+
+// src/apollo_client/provider.tsx
+import React2, { useEffect as useEffect2, useState as useState2 } from "react";
+import { ApolloProvider } from "@apollo/client/react";
+var ExtendedApolloProvider = ({
+  children,
+  client
+}) => {
+  const [hasPreloaded, setHasPreloaded] = useState2(false);
+  useEffect2(() => {
+    const prefetchData = async () => {
+      await client.prefetchData();
+      setHasPreloaded(true);
+      window.removeEventListener(SET_GLOBALS_EVENT_TYPE, prefetchData);
+    };
+    window.addEventListener(SET_GLOBALS_EVENT_TYPE, prefetchData, {
+      passive: true
+    });
+    if (window.openai?.toolOutput) {
+      window.dispatchEvent(new CustomEvent(SET_GLOBALS_EVENT_TYPE));
+    }
+  }, [setHasPreloaded]);
+  return hasPreloaded ? /* @__PURE__ */ React2.createElement(ApolloProvider, { client }, children) : null;
+};
+export {
+  ExtendedApolloClient as ApolloClient,
+  ExtendedApolloProvider as ApolloProvider,
+  SET_GLOBALS_EVENT_TYPE,
+  SetGlobalsEvent,
+  ToolUseProvider,
+  useOpenAiGlobal,
+  useRequestDisplayMode,
+  useSendFollowUpMessage,
+  useToolEffect,
+  useToolInput,
+  useToolName
+};

package/dist/types/application-manifest.d.ts

@@ -0,0 +1,29 @@
+export type ApplicationManifest = {
+    format: "apollo-ai-app-manifest";
+    version: "1";
+    name: string;
+    description: string;
+    hash: string;
+    resource: string;
+    operations: ManifestOperation[];
+};
+export type ManifestOperation = {
+    id: string;
+    name: string;
+    type: "query" | "mutation";
+    body: string;
+    variables: Record<string, string>;
+    prefetch: boolean;
+    prefetchID?: string;
+    tools: ManifestTool[];
+};
+export type ManifestTool = {
+    name: string;
+    description: string;
+    extraInputs?: ManifestExtraInput[];
+};
+export type ManifestExtraInput = {
+    name: string;
+    description: string;
+    type: "string" | "boolean" | "number";
+};

package/dist/types/openai.d.ts

@@ -0,0 +1,73 @@
+type UnknownObject = any;
+declare global {
+    interface Window {
+        openai: API<any> & OpenAiGlobals;
+    }
+    interface WindowEventMap {
+        [SET_GLOBALS_EVENT_TYPE]: SetGlobalsEvent;
+    }
+}
+export type OpenAiGlobals<ToolInput extends UnknownObject = UnknownObject, ToolOutput extends UnknownObject = UnknownObject, ToolResponseMetadata extends UnknownObject = UnknownObject, WidgetState extends UnknownObject = UnknownObject> = {
+    theme: Theme;
+    userAgent: UserAgent;
+    locale: string;
+    maxHeight: number;
+    displayMode: DisplayMode;
+    safeArea: SafeArea;
+    toolInput: ToolInput;
+    toolOutput: ToolOutput | null;
+    toolResponseMetadata: ToolResponseMetadata | null;
+    widgetState: WidgetState | null;
+};
+export type API<WidgetState extends UnknownObject> = {
+    /** Calls a tool on your MCP. Returns the full response. */
+    callTool: (name: string, args: Record<string, unknown>) => Promise<any>;
+    /** Triggers a followup turn in the ChatGPT conversation */
+    sendFollowUpMessage: (args: {
+        prompt: string;
+    }) => Promise<void>;
+    /** Opens an external link, redirects web page or mobile app */
+    openExternal(payload: {
+        href: string;
+    }): void;
+    /** For transitioning an app from inline to fullscreen or pip */
+    requestDisplayMode: (args: {
+        mode: DisplayMode;
+    }) => Promise<{
+        /**
+         * The granted display mode. The host may reject the request.
+         * For mobile, PiP is always coerced to fullscreen.
+         */
+        mode: DisplayMode;
+    }>;
+    setWidgetState: (state: WidgetState) => Promise<void>;
+};
+export declare const SET_GLOBALS_EVENT_TYPE = "openai:set_globals";
+export declare class SetGlobalsEvent extends CustomEvent<{
+    globals: Partial<OpenAiGlobals>;
+}> {
+    readonly type = "openai:set_globals";
+}
+export type CallTool = (name: string, args: Record<string, unknown>) => Promise<any>;
+export type DisplayMode = "pip" | "inline" | "fullscreen";
+export type Theme = "light" | "dark";
+export type SafeAreaInsets = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+export type SafeArea = {
+    insets: SafeAreaInsets;
+};
+export type DeviceType = "mobile" | "tablet" | "desktop" | "unknown";
+export type UserAgent = {
+    device: {
+        type: DeviceType;
+    };
+    capabilities: {
+        hover: boolean;
+        touch: boolean;
+    };
+};
+export {};

package/dist/vite/index.d.ts

@@ -0,0 +1 @@
+export * from "./operation_manifest_plugin";

package/dist/vite/index.js

@@ -0,0 +1,210 @@
+// src/vite/operation_manifest_plugin.ts
+import { readFileSync, writeFileSync } from "fs";
+import { glob } from "glob";
+import { gqlPluckFromCodeStringSync } from "@graphql-tools/graphql-tag-pluck";
+import { createHash } from "crypto";
+import {
+  Kind,
+  parse,
+  print,
+  visit
+} from "graphql";
+import { ApolloClient, ApolloLink, InMemoryCache } from "@apollo/client";
+import Observable from "rxjs";
+import path from "path";
+import fs from "fs";
+var root = process.cwd();
+var getRawValue = (node) => {
+  switch (node.kind) {
+    case Kind.STRING:
+    case Kind.BOOLEAN:
+      return node.value;
+    case Kind.LIST:
+      return node.values.map(getRawValue);
+    case Kind.OBJECT:
+      return node.fields.reduce((acc, field) => {
+        acc[field.name.value] = getRawValue(field.value);
+        return acc;
+      }, {});
+  }
+};
+function getTypeName(type) {
+  let t = type;
+  while (t.kind === "NonNullType" || t.kind === "ListType") {
+    t = t.type;
+  }
+  return t.name.value;
+}
+var OperationManifestPlugin = () => {
+  const cache = /* @__PURE__ */ new Map();
+  let packageJson = null;
+  let config = null;
+  const clientCache = new InMemoryCache();
+  const client = new ApolloClient({
+    cache: clientCache,
+    link: new ApolloLink((operation) => {
+      const body = print(removeClientDirective(sortTopLevelDefinitions(operation.query)));
+      const name = operation.operationName;
+      const variables = operation.query.definitions.find((d) => d.kind === "OperationDefinition").variableDefinitions?.reduce(
+        (obj, varDef) => ({ ...obj, [varDef.variable.name.value]: getTypeName(varDef.type) }),
+        {}
+      );
+      const type = operation.query.definitions.find((d) => d.kind === "OperationDefinition").operation;
+      const prefetch = operation.query.definitions.find((d) => d.kind === "OperationDefinition").directives?.some((d) => d.name.value === "prefetch");
+      const id = createHash("sha256").update(body).digest("hex");
+      const prefetchID = prefetch ? "__anonymous" : void 0;
+      const tools = operation.query.definitions.find((d) => d.kind === "OperationDefinition").directives?.filter((d) => d.name.value === "tool").map((directive) => {
+        const directiveArguments = directive.arguments?.reduce((obj, arg) => ({ ...obj, [arg.name.value]: getRawValue(arg.value) }), {}) ?? {};
+        return {
+          name: directiveArguments["name"],
+          description: directiveArguments["description"],
+          extraInputs: directiveArguments["extraInputs"]
+        };
+      });
+      return Observable.of({ data: { id, name, type, body, variables, prefetch, prefetchID, tools } });
+    })
+  });
+  const processFile = async (file) => {
+    const code = readFileSync(file, "utf-8");
+    if (!code.includes("gql")) return;
+    const fileHash = createHash("md5").update(code).digest("hex");
+    if (cache.get("file")?.hash === fileHash) return;
+    const sources = await gqlPluckFromCodeStringSync(file, code, {
+      modules: [
+        { name: "graphql-tag", identifier: "gql" },
+        { name: "@apollo/client", identifier: "gql" }
+      ]
+    }).map((source) => ({
+      node: parse(source.body),
+      file,
+      location: source.locationOffset
+    }));
+    const operations = [];
+    for (const source of sources) {
+      const type = source.node.definitions.find((d) => d.kind === "OperationDefinition").operation;
+      let result;
+      if (type === "query") {
+        result = await client.query({ query: source.node, fetchPolicy: "no-cache" });
+      } else if (type === "mutation") {
+        result = await client.mutate({ mutation: source.node, fetchPolicy: "no-cache" });
+      } else {
+        throw new Error("Found an unsupported operation type. Only Query and Mutation are supported.");
+      }
+      operations.push(result.data);
+    }
+    cache.set(file, {
+      file,
+      hash: fileHash,
+      operations
+    });
+  };
+  const generateManifest = async () => {
+    const operations = Array.from(cache.values()).flatMap((entry) => entry.operations);
+    if (operations.filter((o) => o.prefetch).length > 1) {
+      throw new Error(
+        "Found multiple operations marked as `@prefetch`. You can only mark 1 operation with `@prefetch`."
+      );
+    }
+    let resource = "";
+    if (config.command === "serve") {
+      resource = packageJson.entry?.[config.mode] ?? `http${config.server.https ? "s" : ""}://${config.server.host ?? "localhost"}:${config.server.port}`;
+    } else {
+      let entryPoint = packageJson.entry?.[config.mode];
+      if (entryPoint) {
+        resource = entryPoint;
+      } else if (config.mode === "production") {
+        resource = "index.html";
+      } else {
+        throw new Error(
+          `No entry point found for mode "${config.mode}". Entry points other than "development" and "production" must be defined in package.json file.`
+        );
+      }
+    }
+    const manifest = {
+      format: "apollo-ai-app-manifest",
+      version: "1",
+      name: packageJson.name,
+      description: packageJson.description,
+      hash: createHash("sha256").update(Date.now().toString()).digest("hex"),
+      operations: Array.from(cache.values()).flatMap((entry) => entry.operations),
+      resource
+    };
+    if (config.command === "build") {
+      const dest = path.resolve(root, config.build.outDir, ".application-manifest.json");
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      writeFileSync(dest, JSON.stringify(manifest));
+    }
+    writeFileSync(".application-manifest.json", JSON.stringify(manifest));
+  };
+  return {
+    name: "OperationManifest",
+    async configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async buildStart() {
+      packageJson = JSON.parse(readFileSync("package.json", "utf-8"));
+      const files = await glob("src/**/*.{ts,tsx,js,jsx}");
+      for (const file of files) {
+        const fullPath = path.resolve(root, file);
+        await processFile(fullPath);
+      }
+      if (config.command === "serve") {
+        await generateManifest();
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configureServer(server) {
+      server.watcher.on("change", async (file) => {
+        if (file.endsWith("package.json")) {
+          packageJson = JSON.parse(readFileSync("package.json", "utf-8"));
+          await generateManifest();
+        } else if (file.match(/\.(jsx?|tsx?)$/)) {
+          await processFile(file);
+          await generateManifest();
+        }
+      });
+    },
+    async writeBundle() {
+      await generateManifest();
+    }
+  };
+};
+function sortTopLevelDefinitions(query) {
+  const definitions = [...query.definitions];
+  definitions.sort((a, b) => {
+    if (a.kind > b.kind) {
+      return -1;
+    }
+    if (a.kind < b.kind) {
+      return 1;
+    }
+    const aName = a.kind === "OperationDefinition" || a.kind === "FragmentDefinition" ? a.name?.value ?? "" : "";
+    const bName = b.kind === "OperationDefinition" || b.kind === "FragmentDefinition" ? b.name?.value ?? "" : "";
+    if (aName < bName) {
+      return -1;
+    }
+    if (aName > bName) {
+      return 1;
+    }
+    return 0;
+  });
+  return {
+    ...query,
+    definitions
+  };
+}
+function removeClientDirective(doc) {
+  return visit(doc, {
+    OperationDefinition(node) {
+      return {
+        ...node,
+        directives: node.directives?.filter((d) => d.name.value !== "prefetch" && d.name.value !== "tool")
+      };
+    }
+  });
+}
+export {
+  OperationManifestPlugin,
+  getTypeName,
+  sortTopLevelDefinitions
+};

package/dist/vite/operation_manifest_plugin.d.ts

@@ -0,0 +1,10 @@
+import { TypeNode, type DocumentNode } from "graphql";
+export declare function getTypeName(type: TypeNode): string;
+export declare const OperationManifestPlugin: () => {
+    name: string;
+    configResolved(resolvedConfig: any): Promise<void>;
+    buildStart(): Promise<void>;
+    configureServer(server: any): void;
+    writeBundle(): Promise<void>;
+};
+export declare function sortTopLevelDefinitions(query: DocumentNode): DocumentNode;