@graphql-hive/plugin-mcp 0.0.0

package/dist/index.cjs

@@ -0,0 +1,311 @@
+'use strict';
+
+var graphql = require('graphql');
+
+const SCALAR_MAP = {
+  String: "string",
+  Int: "integer",
+  Float: "number",
+  Boolean: "boolean",
+  ID: "string"
+};
+function graphqlTypeToJsonSchema(type, schema) {
+  if (graphql.isNonNullType(type)) {
+    return graphqlTypeToJsonSchema(type.ofType);
+  }
+  if (graphql.isListType(type)) {
+    return {
+      type: "array",
+      items: graphqlTypeToJsonSchema(type.ofType)
+    };
+  }
+  if (graphql.isEnumType(type)) {
+    return {
+      enum: type.getValues().map((v) => v.name)
+    };
+  }
+  if (graphql.isInputObjectType(type)) {
+    const fields = type.getFields();
+    const properties = {};
+    const required = [];
+    for (const [fieldName, field] of Object.entries(fields)) {
+      if (graphql.isNonNullType(field.type)) {
+        required.push(fieldName);
+      }
+      properties[fieldName] = graphqlTypeToJsonSchema(field.type);
+      if (field.description) {
+        properties[fieldName].description = field.description;
+      }
+    }
+    const result = {
+      type: "object",
+      properties
+    };
+    if (required.length > 0) {
+      result.required = required;
+    }
+    return result;
+  }
+  if (graphql.isScalarType(type)) {
+    const jsonType = SCALAR_MAP[type.name];
+    if (jsonType) {
+      return { type: jsonType };
+    }
+    return { type: "string" };
+  }
+  return { type: "object" };
+}
+function operationToInputSchema(operationSource, schema) {
+  const document = graphql.parse(operationSource);
+  const operationDef = document.definitions.find(
+    (def) => def.kind === graphql.Kind.OPERATION_DEFINITION
+  );
+  if (!operationDef || operationDef.kind !== graphql.Kind.OPERATION_DEFINITION) {
+    throw new Error("No operation definition found in document");
+  }
+  const variables = operationDef.variableDefinitions || [];
+  const properties = {};
+  const required = [];
+  for (const variable of variables) {
+    const varName = variable.variable.name.value;
+    const varType = graphql.typeFromAST(schema, variable.type);
+    if (!varType) {
+      throw new Error(`Unknown type for variable $${varName}`);
+    }
+    if (variable.type.kind === graphql.Kind.NON_NULL_TYPE) {
+      required.push(varName);
+    }
+    properties[varName] = graphqlTypeToJsonSchema(varType);
+  }
+  const result = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    result.required = required;
+  }
+  return result;
+}
+
+class ToolRegistry {
+  tools = /* @__PURE__ */ new Map();
+  constructor(configs, schema) {
+    for (const config of configs) {
+      const inputSchema = operationToInputSchema(config.query, schema);
+      const description = config.description || `Execute ${config.name}`;
+      this.tools.set(config.name, {
+        name: config.name,
+        description,
+        query: config.query,
+        inputSchema
+      });
+    }
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  getMCPTools() {
+    return Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+  }
+}
+
+function createMCPHandler(options) {
+  const { serverName, serverVersion, registry } = options;
+  return async function handleMCPRequest(request) {
+    const body = await request.json();
+    const { id, method, params } = body;
+    let response;
+    switch (method) {
+      case "initialize":
+        response = {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2025-11-25",
+            serverInfo: {
+              name: serverName,
+              version: serverVersion
+            },
+            capabilities: {
+              tools: {}
+            }
+          }
+        };
+        break;
+      case "tools/list":
+        response = {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: registry.getMCPTools()
+          }
+        };
+        break;
+      case "notifications/initialized":
+        return new Response(null, { status: 204 });
+      case "tools/call": {
+        const callParams = params;
+        const tool = registry.getTool(callParams.name);
+        if (!tool) {
+          response = {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{
+                type: "text",
+                text: JSON.stringify({ error: `Unknown tool: ${callParams.name}` })
+              }],
+              isError: true
+            }
+          };
+          break;
+        }
+        try {
+          const result = await options.execute(callParams.name, callParams.arguments || {});
+          response = {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }]
+            }
+          };
+        } catch (error) {
+          response = {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: error instanceof Error ? error.message : "Unknown error"
+                })
+              }],
+              isError: true
+            }
+          };
+        }
+        break;
+      }
+      default:
+        response = {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`
+          }
+        };
+    }
+    return new Response(JSON.stringify(response), {
+      headers: { "Content-Type": "application/json" }
+    });
+  };
+}
+
+function createGraphQLExecutor(registry, graphqlEndpoint) {
+  return async function executeToolCall(toolName, args, context) {
+    const tool = registry.getTool(toolName);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+    const response = await fetch(graphqlEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...context?.headers
+      },
+      body: JSON.stringify({
+        query: tool.query,
+        variables: args
+      })
+    });
+    const result = await response.json();
+    return result;
+  };
+}
+
+function useMCP(config) {
+  const mcpPath = config.path || "/mcp";
+  const graphqlPath = config.graphqlPath || "/graphql";
+  let registry = null;
+  let schema = null;
+  let schemaLoadingPromise = null;
+  return {
+    onSchemaChange({ schema: newSchema }) {
+      schema = newSchema;
+      registry = new ToolRegistry(config.tools, newSchema);
+    },
+    onRequest({ request, url, endResponse }) {
+      if (url.pathname !== mcpPath) {
+        return;
+      }
+      const graphqlEndpoint = `${url.protocol}//${url.host}${graphqlPath}`;
+      const ensureSchema = async () => {
+        if (registry && schema) {
+          return true;
+        }
+        if (!schemaLoadingPromise) {
+          schemaLoadingPromise = (async () => {
+            try {
+              await fetch(graphqlEndpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ query: "{ __typename }" })
+              });
+              await new Promise((resolve) => setTimeout(resolve, 100));
+            } finally {
+              schemaLoadingPromise = null;
+            }
+          })();
+        }
+        await schemaLoadingPromise;
+        return !!(registry && schema);
+      };
+      return ensureSchema().then((ready) => {
+        if (!ready || !registry || !schema) {
+          endResponse(new Response(JSON.stringify({
+            jsonrpc: "2.0",
+            id: null,
+            error: {
+              code: -32e3,
+              message: "MCP server not ready. Schema introspection failed."
+            }
+          }), {
+            status: 503,
+            headers: { "Content-Type": "application/json" }
+          }));
+          return;
+        }
+        const execute = createGraphQLExecutor(registry, graphqlEndpoint);
+        const handler = createMCPHandler({
+          serverName: config.name,
+          serverVersion: config.version || "1.0.0",
+          registry,
+          execute: async (toolName, args) => {
+            const headers = {};
+            const auth = request.headers.get("authorization");
+            if (auth) {
+              headers["authorization"] = auth;
+            }
+            return execute(toolName, args, { headers });
+          }
+        });
+        return handler(request).then((response) => {
+          endResponse(response);
+        });
+      });
+    }
+  };
+}
+
+exports.useMCP = useMCP;

package/dist/index.d.cts

@@ -0,0 +1,180 @@
+import { Logger } from '@graphql-hive/logger';
+import { DisposableSymbols } from '@whatwg-node/disposablestack';
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+import { UnifiedGraphPlugin, Instrumentation as Instrumentation$2 } from '@graphql-mesh/fusion-runtime';
+import { Plugin, YogaInitialContext, Instrumentation as Instrumentation$1 } from 'graphql-yoga';
+import { MeshFetch, KeyValueCache, MeshFetchRequestInit, Logger as Logger$1 } from '@graphql-mesh/types';
+import { FetchInstrumentation } from '@graphql-mesh/utils';
+import { ExecutionRequest, MaybePromise as MaybePromise$1 } from '@graphql-tools/utils';
+import { GraphQLResolveInfo } from 'graphql/type';
+
+type TopicDataMap = {
+    [topic: string]: any;
+};
+type PubSubListener<Data extends TopicDataMap, Topic extends keyof Data> = (data: Data[Topic]) => void;
+interface PubSub<M extends TopicDataMap = TopicDataMap> {
+    /**
+     * Publish {@link data} for a {@link topic}.
+     * @returns `void` or a `Promise` that resolves when the data has been successfully published
+     */
+    publish<Topic extends keyof M>(topic: Topic, data: M[Topic]): MaybePromise<void>;
+    /**
+     * A distinct list of all topics that are currently subscribed to.
+     * Can be a promise to accomodate distributed systems where subscribers exist on other
+     * locations and we need to know about all of them.
+     */
+    subscribedTopics(): MaybePromise<Iterable<keyof M>>;
+    /**
+     * Subscribe and listen to a {@link topic} receiving its data.
+     *
+     * If the {@link listener} is provided, it will be called whenever data is emitted for the {@link topic},
+     *
+     * @returns an unsubscribe function or a `Promise<unsubscribe function>` that resolves when the subscription is successfully established. the unsubscribe function returns `void` or a `Promise` that resolves on successful unsubscribe and subscription cleanup
+     *
+     * If the {@link listener} is not provided,
+     *
+     * @returns an `AsyncIterable` that yields data for the given {@link topic}
+     */
+    subscribe<Topic extends keyof M>(topic: Topic): AsyncIterable<M[Topic]>;
+    subscribe<Topic extends keyof M>(topic: Topic, listener: PubSubListener<M, Topic>): MaybePromise<() => MaybePromise<void>>;
+    /**
+     * Closes active subscriptions and disposes of all resources. Publishing and subscribing after disposal
+     * is not possible and will throw an error if attempted.
+     */
+    dispose(): MaybePromise<void>;
+    /** @see {@link dispose} */
+    [DisposableSymbols.asyncDispose](): Promise<void>;
+}
+
+interface GatewayConfigContext {
+    /**
+     * WHATWG compatible Fetch implementation.
+     */
+    fetch: MeshFetch;
+    /**
+     * The logger to use throught Hive and its plugins.
+     */
+    log: Logger;
+    /**
+     * Current working directory.
+     * Note that working directory does not exist in serverless environments and will therefore be empty.
+     */
+    cwd: string;
+    /**
+     * Event bus for pub/sub.
+     */
+    pubsub?: PubSub;
+    /**
+     * Cache Storage
+     */
+    cache?: KeyValueCache;
+}
+interface GatewayContext extends GatewayConfigContext, YogaInitialContext {
+    /**
+     * Environment agnostic HTTP headers provided with the request.
+     */
+    headers: Record<string, string>;
+    /**
+     * Runtime context available within WebSocket connections.
+     */
+    connectionParams?: Record<string, string>;
+}
+type GatewayPlugin<TPluginContext extends Record<string, any> = Record<string, any>, TContext extends Record<string, any> = Record<string, any>> = Plugin<Partial<TPluginContext> & GatewayContext & TContext, GatewayConfigContext> & UnifiedGraphPlugin<Partial<TPluginContext> & GatewayContext & TContext> & {
+    onFetch?: OnFetchHook<Partial<TPluginContext> & TContext>;
+    onCacheGet?: OnCacheGetHook;
+    onCacheSet?: OnCacheSetHook;
+    onCacheDelete?: OnCacheDeleteHook;
+    /**
+     * An Instrumentation instance that will wrap each phases of the request pipeline.
+     * This should be used primarily as an observability tool (for monitoring, tracing, etc...).
+     *
+     * Note: The wrapped functions in instrumentation should always be called. Use hooks to
+     *       conditionally skip a phase.
+     */
+    instrumentation?: Instrumentation<TPluginContext & TContext & GatewayContext>;
+};
+interface OnFetchHookPayload<TContext> {
+    url: string;
+    setURL(url: URL | string): void;
+    options: MeshFetchRequestInit;
+    setOptions(options: MeshFetchRequestInit): void;
+    /**
+     * The context is not available in cases where "fetch" is done in
+     * order to pull a supergraph or do some internal work.
+     *
+     * The logger will be available in all cases.
+     */
+    context: (GatewayContext & TContext) | {
+        log: Logger;
+    };
+    /** @deprecated Please use `log` from the {@link context} instead. */
+    logger: Logger$1;
+    info: GraphQLResolveInfo;
+    fetchFn: MeshFetch;
+    setFetchFn: (fetchFn: MeshFetch) => void;
+    executionRequest?: ExecutionRequest;
+    endResponse: (response$: MaybePromise$1<Response>) => void;
+}
+interface OnFetchHookDonePayload {
+    response: Response;
+    setResponse: (response: Response) => void;
+}
+type OnFetchHookDone = (payload: OnFetchHookDonePayload) => MaybePromise$1<void>;
+type OnFetchHook<TContext> = (payload: OnFetchHookPayload<TContext>) => MaybePromise$1<void | OnFetchHookDone>;
+type OnCacheGetHook = (payload: OnCacheGetHookEventPayload) => MaybePromise$1<OnCacheGetHookResult | void>;
+interface OnCacheGetHookEventPayload {
+    cache: KeyValueCache;
+    key: string;
+    ttl?: number;
+}
+interface OnCacheGetHookResult {
+    onCacheHit?: OnCacheHitHook;
+    onCacheMiss?: OnCacheMissHook;
+    onCacheGetError?: OnCacheErrorHook;
+}
+type OnCacheErrorHook = (payload: OnCacheErrorHookPayload) => void;
+interface OnCacheErrorHookPayload {
+    error: Error;
+}
+type OnCacheHitHook = (payload: OnCacheHitHookEventPayload) => void;
+interface OnCacheHitHookEventPayload {
+    value: any;
+}
+type OnCacheMissHook = () => void;
+type OnCacheSetHook = (payload: OnCacheSetHookEventPayload) => MaybePromise$1<OnCacheSetHookResult | void>;
+interface OnCacheSetHookResult {
+    onCacheSetDone?: () => void;
+    onCacheSetError?: OnCacheErrorHook;
+}
+interface OnCacheSetHookEventPayload {
+    cache: KeyValueCache;
+    key: string;
+    value: any;
+    ttl?: number;
+}
+type OnCacheDeleteHook = (payload: OnCacheDeleteHookEventPayload) => MaybePromise$1<OnCacheDeleteHookResult | void>;
+interface OnCacheDeleteHookResult {
+    onCacheDeleteDone?: () => void;
+    onCacheDeleteError?: OnCacheErrorHook;
+}
+interface OnCacheDeleteHookEventPayload {
+    cache: KeyValueCache;
+    key: string;
+}
+type Instrumentation<TContext extends Record<string, any>> = Instrumentation$1<TContext> & Instrumentation$2 & FetchInstrumentation;
+
+interface MCPToolConfig {
+    name: string;
+    description?: string;
+    query: string;
+}
+interface MCPConfig {
+    name: string;
+    version?: string;
+    path?: string;
+    graphqlPath?: string;
+    tools: MCPToolConfig[];
+}
+declare function useMCP(config: MCPConfig): GatewayPlugin;
+
+export { type MCPConfig, type MCPToolConfig, useMCP };

package/dist/index.d.ts

@@ -0,0 +1,180 @@
+import { Logger } from '@graphql-hive/logger';
+import { DisposableSymbols } from '@whatwg-node/disposablestack';
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+import { UnifiedGraphPlugin, Instrumentation as Instrumentation$2 } from '@graphql-mesh/fusion-runtime';
+import { Plugin, YogaInitialContext, Instrumentation as Instrumentation$1 } from 'graphql-yoga';
+import { MeshFetch, KeyValueCache, MeshFetchRequestInit, Logger as Logger$1 } from '@graphql-mesh/types';
+import { FetchInstrumentation } from '@graphql-mesh/utils';
+import { ExecutionRequest, MaybePromise as MaybePromise$1 } from '@graphql-tools/utils';
+import { GraphQLResolveInfo } from 'graphql/type';
+
+type TopicDataMap = {
+    [topic: string]: any;
+};
+type PubSubListener<Data extends TopicDataMap, Topic extends keyof Data> = (data: Data[Topic]) => void;
+interface PubSub<M extends TopicDataMap = TopicDataMap> {
+    /**
+     * Publish {@link data} for a {@link topic}.
+     * @returns `void` or a `Promise` that resolves when the data has been successfully published
+     */
+    publish<Topic extends keyof M>(topic: Topic, data: M[Topic]): MaybePromise<void>;
+    /**
+     * A distinct list of all topics that are currently subscribed to.
+     * Can be a promise to accomodate distributed systems where subscribers exist on other
+     * locations and we need to know about all of them.
+     */
+    subscribedTopics(): MaybePromise<Iterable<keyof M>>;
+    /**
+     * Subscribe and listen to a {@link topic} receiving its data.
+     *
+     * If the {@link listener} is provided, it will be called whenever data is emitted for the {@link topic},
+     *
+     * @returns an unsubscribe function or a `Promise<unsubscribe function>` that resolves when the subscription is successfully established. the unsubscribe function returns `void` or a `Promise` that resolves on successful unsubscribe and subscription cleanup
+     *
+     * If the {@link listener} is not provided,
+     *
+     * @returns an `AsyncIterable` that yields data for the given {@link topic}
+     */
+    subscribe<Topic extends keyof M>(topic: Topic): AsyncIterable<M[Topic]>;
+    subscribe<Topic extends keyof M>(topic: Topic, listener: PubSubListener<M, Topic>): MaybePromise<() => MaybePromise<void>>;
+    /**
+     * Closes active subscriptions and disposes of all resources. Publishing and subscribing after disposal
+     * is not possible and will throw an error if attempted.
+     */
+    dispose(): MaybePromise<void>;
+    /** @see {@link dispose} */
+    [DisposableSymbols.asyncDispose](): Promise<void>;
+}
+
+interface GatewayConfigContext {
+    /**
+     * WHATWG compatible Fetch implementation.
+     */
+    fetch: MeshFetch;
+    /**
+     * The logger to use throught Hive and its plugins.
+     */
+    log: Logger;
+    /**
+     * Current working directory.
+     * Note that working directory does not exist in serverless environments and will therefore be empty.
+     */
+    cwd: string;
+    /**
+     * Event bus for pub/sub.
+     */
+    pubsub?: PubSub;
+    /**
+     * Cache Storage
+     */
+    cache?: KeyValueCache;
+}
+interface GatewayContext extends GatewayConfigContext, YogaInitialContext {
+    /**
+     * Environment agnostic HTTP headers provided with the request.
+     */
+    headers: Record<string, string>;
+    /**
+     * Runtime context available within WebSocket connections.
+     */
+    connectionParams?: Record<string, string>;
+}
+type GatewayPlugin<TPluginContext extends Record<string, any> = Record<string, any>, TContext extends Record<string, any> = Record<string, any>> = Plugin<Partial<TPluginContext> & GatewayContext & TContext, GatewayConfigContext> & UnifiedGraphPlugin<Partial<TPluginContext> & GatewayContext & TContext> & {
+    onFetch?: OnFetchHook<Partial<TPluginContext> & TContext>;
+    onCacheGet?: OnCacheGetHook;
+    onCacheSet?: OnCacheSetHook;
+    onCacheDelete?: OnCacheDeleteHook;
+    /**
+     * An Instrumentation instance that will wrap each phases of the request pipeline.
+     * This should be used primarily as an observability tool (for monitoring, tracing, etc...).
+     *
+     * Note: The wrapped functions in instrumentation should always be called. Use hooks to
+     *       conditionally skip a phase.
+     */
+    instrumentation?: Instrumentation<TPluginContext & TContext & GatewayContext>;
+};
+interface OnFetchHookPayload<TContext> {
+    url: string;
+    setURL(url: URL | string): void;
+    options: MeshFetchRequestInit;
+    setOptions(options: MeshFetchRequestInit): void;
+    /**
+     * The context is not available in cases where "fetch" is done in
+     * order to pull a supergraph or do some internal work.
+     *
+     * The logger will be available in all cases.
+     */
+    context: (GatewayContext & TContext) | {
+        log: Logger;
+    };
+    /** @deprecated Please use `log` from the {@link context} instead. */
+    logger: Logger$1;
+    info: GraphQLResolveInfo;
+    fetchFn: MeshFetch;
+    setFetchFn: (fetchFn: MeshFetch) => void;
+    executionRequest?: ExecutionRequest;
+    endResponse: (response$: MaybePromise$1<Response>) => void;
+}
+interface OnFetchHookDonePayload {
+    response: Response;
+    setResponse: (response: Response) => void;
+}
+type OnFetchHookDone = (payload: OnFetchHookDonePayload) => MaybePromise$1<void>;
+type OnFetchHook<TContext> = (payload: OnFetchHookPayload<TContext>) => MaybePromise$1<void | OnFetchHookDone>;
+type OnCacheGetHook = (payload: OnCacheGetHookEventPayload) => MaybePromise$1<OnCacheGetHookResult | void>;
+interface OnCacheGetHookEventPayload {
+    cache: KeyValueCache;
+    key: string;
+    ttl?: number;
+}
+interface OnCacheGetHookResult {
+    onCacheHit?: OnCacheHitHook;
+    onCacheMiss?: OnCacheMissHook;
+    onCacheGetError?: OnCacheErrorHook;
+}
+type OnCacheErrorHook = (payload: OnCacheErrorHookPayload) => void;
+interface OnCacheErrorHookPayload {
+    error: Error;
+}
+type OnCacheHitHook = (payload: OnCacheHitHookEventPayload) => void;
+interface OnCacheHitHookEventPayload {
+    value: any;
+}
+type OnCacheMissHook = () => void;
+type OnCacheSetHook = (payload: OnCacheSetHookEventPayload) => MaybePromise$1<OnCacheSetHookResult | void>;
+interface OnCacheSetHookResult {
+    onCacheSetDone?: () => void;
+    onCacheSetError?: OnCacheErrorHook;
+}
+interface OnCacheSetHookEventPayload {
+    cache: KeyValueCache;
+    key: string;
+    value: any;
+    ttl?: number;
+}
+type OnCacheDeleteHook = (payload: OnCacheDeleteHookEventPayload) => MaybePromise$1<OnCacheDeleteHookResult | void>;
+interface OnCacheDeleteHookResult {
+    onCacheDeleteDone?: () => void;
+    onCacheDeleteError?: OnCacheErrorHook;
+}
+interface OnCacheDeleteHookEventPayload {
+    cache: KeyValueCache;
+    key: string;
+}
+type Instrumentation<TContext extends Record<string, any>> = Instrumentation$1<TContext> & Instrumentation$2 & FetchInstrumentation;
+
+interface MCPToolConfig {
+    name: string;
+    description?: string;
+    query: string;
+}
+interface MCPConfig {
+    name: string;
+    version?: string;
+    path?: string;
+    graphqlPath?: string;
+    tools: MCPToolConfig[];
+}
+declare function useMCP(config: MCPConfig): GatewayPlugin;
+
+export { type MCPConfig, type MCPToolConfig, useMCP };

package/dist/index.js

@@ -0,0 +1,309 @@
+import { parse, Kind, typeFromAST, isNonNullType, isListType, isEnumType, isInputObjectType, isScalarType } from 'graphql';
+
+const SCALAR_MAP = {
+  String: "string",
+  Int: "integer",
+  Float: "number",
+  Boolean: "boolean",
+  ID: "string"
+};
+function graphqlTypeToJsonSchema(type, schema) {
+  if (isNonNullType(type)) {
+    return graphqlTypeToJsonSchema(type.ofType);
+  }
+  if (isListType(type)) {
+    return {
+      type: "array",
+      items: graphqlTypeToJsonSchema(type.ofType)
+    };
+  }
+  if (isEnumType(type)) {
+    return {
+      enum: type.getValues().map((v) => v.name)
+    };
+  }
+  if (isInputObjectType(type)) {
+    const fields = type.getFields();
+    const properties = {};
+    const required = [];
+    for (const [fieldName, field] of Object.entries(fields)) {
+      if (isNonNullType(field.type)) {
+        required.push(fieldName);
+      }
+      properties[fieldName] = graphqlTypeToJsonSchema(field.type);
+      if (field.description) {
+        properties[fieldName].description = field.description;
+      }
+    }
+    const result = {
+      type: "object",
+      properties
+    };
+    if (required.length > 0) {
+      result.required = required;
+    }
+    return result;
+  }
+  if (isScalarType(type)) {
+    const jsonType = SCALAR_MAP[type.name];
+    if (jsonType) {
+      return { type: jsonType };
+    }
+    return { type: "string" };
+  }
+  return { type: "object" };
+}
+function operationToInputSchema(operationSource, schema) {
+  const document = parse(operationSource);
+  const operationDef = document.definitions.find(
+    (def) => def.kind === Kind.OPERATION_DEFINITION
+  );
+  if (!operationDef || operationDef.kind !== Kind.OPERATION_DEFINITION) {
+    throw new Error("No operation definition found in document");
+  }
+  const variables = operationDef.variableDefinitions || [];
+  const properties = {};
+  const required = [];
+  for (const variable of variables) {
+    const varName = variable.variable.name.value;
+    const varType = typeFromAST(schema, variable.type);
+    if (!varType) {
+      throw new Error(`Unknown type for variable $${varName}`);
+    }
+    if (variable.type.kind === Kind.NON_NULL_TYPE) {
+      required.push(varName);
+    }
+    properties[varName] = graphqlTypeToJsonSchema(varType);
+  }
+  const result = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    result.required = required;
+  }
+  return result;
+}
+
+class ToolRegistry {
+  tools = /* @__PURE__ */ new Map();
+  constructor(configs, schema) {
+    for (const config of configs) {
+      const inputSchema = operationToInputSchema(config.query, schema);
+      const description = config.description || `Execute ${config.name}`;
+      this.tools.set(config.name, {
+        name: config.name,
+        description,
+        query: config.query,
+        inputSchema
+      });
+    }
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  getMCPTools() {
+    return Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+  }
+}
+
+function createMCPHandler(options) {
+  const { serverName, serverVersion, registry } = options;
+  return async function handleMCPRequest(request) {
+    const body = await request.json();
+    const { id, method, params } = body;
+    let response;
+    switch (method) {
+      case "initialize":
+        response = {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2025-11-25",
+            serverInfo: {
+              name: serverName,
+              version: serverVersion
+            },
+            capabilities: {
+              tools: {}
+            }
+          }
+        };
+        break;
+      case "tools/list":
+        response = {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: registry.getMCPTools()
+          }
+        };
+        break;
+      case "notifications/initialized":
+        return new Response(null, { status: 204 });
+      case "tools/call": {
+        const callParams = params;
+        const tool = registry.getTool(callParams.name);
+        if (!tool) {
+          response = {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{
+                type: "text",
+                text: JSON.stringify({ error: `Unknown tool: ${callParams.name}` })
+              }],
+              isError: true
+            }
+          };
+          break;
+        }
+        try {
+          const result = await options.execute(callParams.name, callParams.arguments || {});
+          response = {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }]
+            }
+          };
+        } catch (error) {
+          response = {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: error instanceof Error ? error.message : "Unknown error"
+                })
+              }],
+              isError: true
+            }
+          };
+        }
+        break;
+      }
+      default:
+        response = {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`
+          }
+        };
+    }
+    return new Response(JSON.stringify(response), {
+      headers: { "Content-Type": "application/json" }
+    });
+  };
+}
+
+function createGraphQLExecutor(registry, graphqlEndpoint) {
+  return async function executeToolCall(toolName, args, context) {
+    const tool = registry.getTool(toolName);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+    const response = await fetch(graphqlEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...context?.headers
+      },
+      body: JSON.stringify({
+        query: tool.query,
+        variables: args
+      })
+    });
+    const result = await response.json();
+    return result;
+  };
+}
+
+function useMCP(config) {
+  const mcpPath = config.path || "/mcp";
+  const graphqlPath = config.graphqlPath || "/graphql";
+  let registry = null;
+  let schema = null;
+  let schemaLoadingPromise = null;
+  return {
+    onSchemaChange({ schema: newSchema }) {
+      schema = newSchema;
+      registry = new ToolRegistry(config.tools, newSchema);
+    },
+    onRequest({ request, url, endResponse }) {
+      if (url.pathname !== mcpPath) {
+        return;
+      }
+      const graphqlEndpoint = `${url.protocol}//${url.host}${graphqlPath}`;
+      const ensureSchema = async () => {
+        if (registry && schema) {
+          return true;
+        }
+        if (!schemaLoadingPromise) {
+          schemaLoadingPromise = (async () => {
+            try {
+              await fetch(graphqlEndpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ query: "{ __typename }" })
+              });
+              await new Promise((resolve) => setTimeout(resolve, 100));
+            } finally {
+              schemaLoadingPromise = null;
+            }
+          })();
+        }
+        await schemaLoadingPromise;
+        return !!(registry && schema);
+      };
+      return ensureSchema().then((ready) => {
+        if (!ready || !registry || !schema) {
+          endResponse(new Response(JSON.stringify({
+            jsonrpc: "2.0",
+            id: null,
+            error: {
+              code: -32e3,
+              message: "MCP server not ready. Schema introspection failed."
+            }
+          }), {
+            status: 503,
+            headers: { "Content-Type": "application/json" }
+          }));
+          return;
+        }
+        const execute = createGraphQLExecutor(registry, graphqlEndpoint);
+        const handler = createMCPHandler({
+          serverName: config.name,
+          serverVersion: config.version || "1.0.0",
+          registry,
+          execute: async (toolName, args) => {
+            const headers = {};
+            const auth = request.headers.get("authorization");
+            if (auth) {
+              headers["authorization"] = auth;
+            }
+            return execute(toolName, args, { headers });
+          }
+        });
+        return handler(request).then((response) => {
+          endResponse(response);
+        });
+      });
+    }
+  };
+}
+
+export { useMCP };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@graphql-hive/plugin-mcp",
+  "version": "0.0.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/graphql-hive/gateway.git",
+    "directory": "packages/plugins/mcp"
+  },
+  "author": {
+    "email": "contact@the-guild.dev",
+    "name": "The Guild",
+    "url": "https://the-guild.dev"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "prepack": "yarn build"
+  },
+  "peerDependencies": {
+    "graphql": "^15.9.0 || ^16.9.0"
+  },
+  "dependencies": {
+    "@graphql-hive/logger": "^1.0.10",
+    "@graphql-mesh/fusion-runtime": "^1.6.7",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@graphql-hive/gateway-runtime": "2.5.5",
+    "graphql": "^16.12.0",
+    "graphql-yoga": "^5.16.2",
+    "pkgroll": "2.23.0"
+  },
+  "sideEffects": false
+}