nuxt-graphql-middleware 5.2.2 → 5.3.0

package/dist/runtime/server/mcp/tools/fragments-list-for-type/index.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  getFragmentsForTypeOutputSchema
+} from "./types.js";
+export const getFragmentsForTypeTool = defineMcpTool({
+  name: "fragments-list-for-type",
+  title: "List Fragments for Type",
+  description: "Get all GraphQL fragments defined for a specific type. Returns fragment names, file paths, and dependencies on other fragments. Use fragments-get-source to get the GraphQL source code.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    typeName: z.string().describe(
+      'The name of the GraphQL type to get fragments for (e.g., "User", "Post")'
+    )
+  },
+  outputSchema: getFragmentsForTypeOutputSchema,
+  handler: async ({ typeName }) => {
+    const response = await fetchFromMcpHandler(
+      "fragments-list-for-type",
+      { name: typeName }
+    );
+    if (response.error) {
+      return structuredResult({ fragments: [], error: response.error });
+    }
+    const fragments = response.fragments.map((frag) => ({
+      name: frag.name,
+      typeName: frag.typeName,
+      filePath: frag.relativeFilePath,
+      dependencies: frag.dependencies
+    }));
+    return structuredResult({ fragments });
+  }
+});

package/dist/runtime/server/mcp/tools/fragments-list-for-type/types.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const FragmentInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    typeName: z.ZodString;
+    filePath: z.ZodString;
+    relativeFilePath: z.ZodString;
+    source: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const GetFragmentsForTypeResponseSchema: z.ZodObject<{
+    fragments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        typeName: z.ZodString;
+        filePath: z.ZodString;
+        relativeFilePath: z.ZodString;
+        source: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getFragmentsForTypeOutputSchema: {
+    fragments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        typeName: z.ZodString;
+        filePath: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type FragmentInfo = z.infer<typeof FragmentInfoSchema>;
+export type GetFragmentsForTypeResponse = z.infer<typeof GetFragmentsForTypeResponseSchema>;

package/dist/runtime/server/mcp/tools/fragments-list-for-type/types.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export const FragmentInfoSchema = z.object({
+  name: z.string().describe("Fragment name"),
+  typeName: z.string().describe("The GraphQL type this fragment is defined on"),
+  filePath: z.string().describe("Absolute path to the file containing the fragment"),
+  relativeFilePath: z.string().describe("Path to the file relative to the project root"),
+  source: z.string().describe("The GraphQL source code of the fragment"),
+  dependencies: z.array(z.string()).describe("Names of other fragments this fragment depends on")
+});
+export const GetFragmentsForTypeResponseSchema = z.object({
+  fragments: z.array(FragmentInfoSchema),
+  error: z.string().optional().describe("Error message if type not found")
+});
+const FragmentMcpSchema = z.object({
+  name: z.string().describe("Fragment name"),
+  typeName: z.string().describe("The GraphQL type this fragment is defined on"),
+  filePath: z.string().describe("Path to the file relative to the project root"),
+  dependencies: z.array(z.string()).describe("Names of other fragments this fragment depends on")
+});
+export const getFragmentsForTypeOutputSchema = {
+  fragments: z.array(FragmentMcpSchema).describe("List of fragments for the specified type"),
+  error: z.string().optional().describe("Error message if type not found")
+};

package/dist/runtime/server/mcp/tools/graphql-execute/index.d.ts

@@ -0,0 +1 @@
+export declare const executeGraphqlTool: any;

package/dist/runtime/server/mcp/tools/graphql-execute/index.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { serverApiPrefix } from "#nuxt-graphql-middleware/helpers";
+import { devServerUrl } from "#nuxt-graphql-middleware/mcp";
+import {
+  structuredResult,
+  graphqlExecutionOutputSchema,
+  extractErrorResponse
+} from "./../../utils/index.js";
+export const executeGraphqlTool = defineMcpTool({
+  name: "graphql-execute",
+  title: "Execute GraphQL",
+  description: "Execute an arbitrary GraphQL operation (query or mutation) against the configured GraphQL endpoint. This sends a real request to the GraphQL server and returns the response. Use this to test queries, fetch data, or perform mutations.",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  inputSchema: {
+    document: z.string().describe(
+      "The GraphQL document (query or mutation) to execute. Must be a valid GraphQL operation."
+    ),
+    variables: z.record(z.string(), z.unknown()).optional().describe("Optional variables to pass to the GraphQL operation"),
+    operationName: z.string().optional().describe(
+      "Optional operation name if the document contains multiple operations"
+    )
+  },
+  outputSchema: graphqlExecutionOutputSchema,
+  handler: async ({ document, variables, operationName }) => {
+    try {
+      const response = await $fetch(`${devServerUrl}${serverApiPrefix}/do-request`, {
+        method: "POST",
+        body: {
+          document,
+          variables,
+          operationName
+        }
+      });
+      return structuredResult({
+        data: response?.data ?? null,
+        errors: response?.errors
+      });
+    } catch (error) {
+      const fetchError = extractErrorResponse(error);
+      if (fetchError) {
+        return structuredResult({
+          data: fetchError.data ?? null,
+          errors: fetchError.errors
+        });
+      }
+      const message = error.statusMessage || error.message || "Unknown error occurred";
+      return structuredResult({
+        data: null,
+        errors: [{ message }]
+      });
+    }
+  }
+});

package/dist/runtime/server/mcp/tools/module-get-config/index.d.ts

@@ -0,0 +1 @@
+export declare const moduleGetConfigTool: any;

package/dist/runtime/server/mcp/tools/module-get-config/index.js

@@ -0,0 +1,23 @@
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import { moduleConfigOutputSchema } from "./types.js";
+export const moduleGetConfigTool = defineMcpTool({
+  name: "module-get-config",
+  title: "Module Configuration",
+  description: "Get internal configuration and state of the nuxt-graphql-middleware module. Returns resolved paths and patterns used by the module.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {},
+  outputSchema: moduleConfigOutputSchema,
+  handler: async () => {
+    const response = await fetchFromMcpHandler("module-get-config");
+    return structuredResult({
+      autoImportPatterns: response.autoImportPatterns,
+      paths: response.paths
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/module-get-config/types.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+/**
+ * Schema for module paths.
+ */
+export declare const ModulePathsSchema: z.ZodObject<{
+    runtimeTypes: z.ZodString;
+    schema: z.ZodString;
+    serverOptions: z.ZodNullable<z.ZodString>;
+    clientOptions: z.ZodNullable<z.ZodString>;
+    documentTypes: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Response schema for the module config handler.
+ */
+export declare const GetModuleConfigResponseSchema: z.ZodObject<{
+    autoImportPatterns: z.ZodArray<z.ZodString>;
+    paths: z.ZodObject<{
+        runtimeTypes: z.ZodString;
+        schema: z.ZodString;
+        serverOptions: z.ZodNullable<z.ZodString>;
+        clientOptions: z.ZodNullable<z.ZodString>;
+        documentTypes: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * MCP output schema.
+ */
+export declare const moduleConfigOutputSchema: {
+    autoImportPatterns: z.ZodArray<z.ZodString>;
+    paths: z.ZodObject<{
+        runtimeTypes: z.ZodString;
+        schema: z.ZodString;
+        serverOptions: z.ZodNullable<z.ZodString>;
+        clientOptions: z.ZodNullable<z.ZodString>;
+        documentTypes: z.ZodString;
+    }, z.core.$strip>;
+};
+export type ModulePaths = z.infer<typeof ModulePathsSchema>;
+export type GetModuleConfigResponse = z.infer<typeof GetModuleConfigResponseSchema>;

package/dist/runtime/server/mcp/tools/module-get-config/types.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export const ModulePathsSchema = z.object({
+  runtimeTypes: z.string().describe("Path to the runtime types file provided by the module"),
+  schema: z.string().describe("Path to the GraphQL schema file"),
+  serverOptions: z.string().nullable().describe(
+    "Path to the graphqlMiddleware.serverOptions.ts file, or null if not found"
+  ),
+  clientOptions: z.string().nullable().describe(
+    "Path to the graphqlMiddleware.clientOptions.ts file, or null if not found"
+  ),
+  documentTypes: z.string().describe(
+    "Path to the generated TypeScript types file for all GraphQL operations and fragments"
+  )
+});
+export const GetModuleConfigResponseSchema = z.object({
+  autoImportPatterns: z.array(z.string()).describe(
+    "The resolved file patterns used to discover GraphQL documents (queries, mutations, fragments)"
+  ),
+  paths: ModulePathsSchema.describe("Important file paths used by the module")
+});
+export const moduleConfigOutputSchema = {
+  autoImportPatterns: z.array(z.string()).describe(
+    "The resolved file patterns used to discover GraphQL documents (queries, mutations, fragments)"
+  ),
+  paths: ModulePathsSchema.describe("Important file paths used by the module")
+};

package/dist/runtime/server/mcp/tools/nitro-graphql-server-utils-example/index.d.ts

@@ -0,0 +1 @@
+export declare const nitroGraphqlServerUtilsExampleTool: any;

package/dist/runtime/server/mcp/tools/nitro-graphql-server-utils-example/index.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  serverUtilExamplesOutputSchema
+} from "./types.js";
+export const nitroGraphqlServerUtilsExampleTool = defineMcpTool({
+  name: "nitro-graphql-server-utils-example",
+  title: "Nitro GraphQL Server Utils Examples",
+  description: "Generate usage examples for Nitro server utils (useGraphqlQuery, useGraphqlMutation, doGraphqlRequest) for a specific GraphQL operation. Returns code examples with mock variable data for use in Nitro event handlers and server-side code.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    operationName: z.string().describe(
+      'The name of the GraphQL operation to generate examples for (e.g., "getUsers", "createPost")'
+    )
+  },
+  outputSchema: serverUtilExamplesOutputSchema,
+  handler: async ({ operationName }) => {
+    const response = await fetchFromMcpHandler(
+      "nitro-graphql-server-utils-example",
+      { name: operationName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({
+      examples: response.examples,
+      imports: response.imports
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/nitro-graphql-server-utils-example/types.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+/**
+ * Schema for a single usage example.
+ */
+export declare const ServerUtilExampleSchema: z.ZodObject<{
+    code: z.ZodString;
+    description: z.ZodString;
+    documentationUrl: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for an import entry.
+ */
+export declare const ImportEntrySchema: z.ZodObject<{
+    typeName: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Response schema for the handler.
+ */
+export declare const GetServerUtilExamplesResponseSchema: z.ZodObject<{
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        description: z.ZodString;
+        documentationUrl: z.ZodString;
+    }, z.core.$strip>>>;
+    imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        typeName: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * MCP output schema.
+ */
+export declare const serverUtilExamplesOutputSchema: {
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        description: z.ZodString;
+        documentationUrl: z.ZodString;
+    }, z.core.$strip>>>;
+    imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        typeName: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type ServerUtilExample = z.infer<typeof ServerUtilExampleSchema>;
+export type ImportEntry = z.infer<typeof ImportEntrySchema>;
+export type GetServerUtilExamplesResponse = z.infer<typeof GetServerUtilExamplesResponseSchema>;

package/dist/runtime/server/mcp/tools/nitro-graphql-server-utils-example/types.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const ServerUtilExampleSchema = z.object({
+  code: z.string().describe("The code example showing how to use the server util"),
+  description: z.string().describe("A description of what this example demonstrates"),
+  documentationUrl: z.string().describe("URL to the documentation for this server util")
+});
+export const ImportEntrySchema = z.object({
+  typeName: z.string().describe("The name of the type to import"),
+  description: z.string().describe(
+    'What this type is used for (e.g., "Variables type", "Response type", "Input type", "Enum type")'
+  )
+});
+export const GetServerUtilExamplesResponseSchema = z.object({
+  examples: z.array(ServerUtilExampleSchema).optional(),
+  imports: z.array(ImportEntrySchema).optional(),
+  error: z.string().optional()
+});
+export const serverUtilExamplesOutputSchema = {
+  examples: z.array(ServerUtilExampleSchema).optional().describe("Array of usage examples for the operation"),
+  imports: z.array(ImportEntrySchema).optional().describe(
+    "Array of types that can be imported from #graphql-operations for this operation"
+  ),
+  error: z.string().optional().describe("Error message if the operation was not found")
+};

package/dist/runtime/server/mcp/tools/operations-execute/index.d.ts

@@ -0,0 +1 @@
+export declare const executeOperationTool: any;

package/dist/runtime/server/mcp/tools/operations-execute/index.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { serverApiPrefix } from "#nuxt-graphql-middleware/helpers";
+import { devServerUrl } from "#nuxt-graphql-middleware/mcp";
+import {
+  structuredResult,
+  graphqlExecutionOutputSchema,
+  extractErrorResponse
+} from "./../../utils/index.js";
+export const executeOperationTool = defineMcpTool({
+  name: "operations-execute",
+  title: "Execute Operation",
+  description: "Execute an existing GraphQL operation (query or mutation) by name via the middleware. This sends a real request through the configured middleware and returns the response. Use this to test existing operations or fetch data.",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  inputSchema: {
+    type: z.enum(["query", "mutation"]).describe("The type of operation to execute"),
+    name: z.string().describe(
+      'The name of the GraphQL operation to execute (e.g., "getUsers", "createPost")'
+    ),
+    variables: z.record(z.string(), z.unknown()).optional().describe("Optional variables to pass to the GraphQL operation")
+  },
+  outputSchema: graphqlExecutionOutputSchema,
+  handler: async ({ type, name, variables }) => {
+    const isQuery = type === "query";
+    const method = isQuery ? "GET" : "POST";
+    const endpoint = `${devServerUrl}${serverApiPrefix}/${type}/${name}`;
+    try {
+      const fetchOptions = {
+        method
+      };
+      if (isQuery && variables && Object.keys(variables).length > 0) {
+        fetchOptions.params = {
+          __variables: JSON.stringify(variables)
+        };
+      } else if (!isQuery && variables) {
+        fetchOptions.body = variables;
+      }
+      const response = await $fetch(endpoint, fetchOptions);
+      return structuredResult({
+        data: response?.data ?? null,
+        errors: response?.errors
+      });
+    } catch (error) {
+      const fetchError = extractErrorResponse(error);
+      if (fetchError) {
+        return structuredResult({
+          data: fetchError.data ?? null,
+          errors: fetchError.errors
+        });
+      }
+      const message = error.statusMessage || error.message || "Unknown error occurred";
+      return structuredResult({
+        data: null,
+        errors: [{ message }]
+      });
+    }
+  }
+});

package/dist/runtime/server/mcp/tools/operations-get/index.d.ts

@@ -0,0 +1 @@
+export declare const getOperationTool: any;

package/dist/runtime/server/mcp/tools/operations-get/index.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import { getOperationOutputSchema } from "./types.js";
+export const getOperationTool = defineMcpTool({
+  name: "operations-get",
+  title: "Get Operation",
+  description: "Get detailed information about a specific GraphQL operation (query or mutation). Returns the operation name, type, file path, variable requirements, and TypeScript type names. Use operations-get-source to get the GraphQL source code.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    operationName: z.string().describe(
+      'The name of the GraphQL operation to get details for (e.g., "getUsers", "createPost")'
+    )
+  },
+  outputSchema: getOperationOutputSchema,
+  handler: async ({ operationName }) => {
+    const response = await fetchFromMcpHandler(
+      "operations-get",
+      { name: operationName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    const op = response.operation;
+    return structuredResult({
+      name: op.name,
+      type: op.type,
+      filePath: op.relativeFilePath,
+      hasVariables: op.hasVariables,
+      needsVariables: op.needsVariables,
+      variablesTypeName: op.variablesTypeName,
+      responseTypeName: op.responseTypeName
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/operations-get/types.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const GetOperationResponseSchema: z.ZodObject<{
+    operation: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+        }>;
+        filePath: z.ZodString;
+        relativeFilePath: z.ZodString;
+        hasVariables: z.ZodBoolean;
+        needsVariables: z.ZodBoolean;
+        variablesTypeName: z.ZodString;
+        responseTypeName: z.ZodString;
+        source: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getOperationOutputSchema: {
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+    }>>;
+    filePath: z.ZodOptional<z.ZodString>;
+    hasVariables: z.ZodOptional<z.ZodBoolean>;
+    needsVariables: z.ZodOptional<z.ZodBoolean>;
+    variablesTypeName: z.ZodOptional<z.ZodString>;
+    responseTypeName: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type GetOperationResponse = z.infer<typeof GetOperationResponseSchema>;

package/dist/runtime/server/mcp/tools/operations-get/types.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { CollectorOperationSchema } from "../operations-list/types.js";
+export const GetOperationResponseSchema = z.object({
+  operation: CollectorOperationSchema.nullable(),
+  error: z.string().optional().describe("Error message if operation not found")
+});
+export const getOperationOutputSchema = {
+  name: z.string().optional().describe("The GraphQL operation name"),
+  type: z.enum(["query", "mutation"]).optional().describe("The type of operation (query or mutation)"),
+  filePath: z.string().optional().describe("Path to the file containing the operation"),
+  hasVariables: z.boolean().optional().describe("Whether the operation has any variables"),
+  needsVariables: z.boolean().optional().describe(
+    "Whether the operation requires variables (has non-null variables)"
+  ),
+  variablesTypeName: z.string().optional().describe("TypeScript type name for the operation variables"),
+  responseTypeName: z.string().optional().describe("TypeScript type name for the operation response"),
+  error: z.string().optional().describe("Error message if operation not found")
+};

package/dist/runtime/server/mcp/tools/operations-get-field-usage/index.d.ts

@@ -0,0 +1 @@
+export declare const getFieldUsageTool: any;

package/dist/runtime/server/mcp/tools/operations-get-field-usage/index.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import { getFieldUsageOutputSchema } from "./types.js";
+export const getFieldUsageTool = defineMcpTool({
+  name: "operations-get-field-usage",
+  title: "Get Field Usage",
+  description: "Find all operations and fragments where a specific field on a GraphQL type is used. Useful for impact analysis when modifying or deprecating fields.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    typeName: z.string().describe(
+      'The name of the GraphQL type (e.g., "Query", "User", "Article")'
+    ),
+    fieldName: z.string().describe(
+      'The name of the field to find usages for (e.g., "search", "id", "email")'
+    )
+  },
+  outputSchema: getFieldUsageOutputSchema,
+  handler: async ({ typeName, fieldName }) => {
+    const response = await fetchFromMcpHandler(
+      "operations-get-field-usage",
+      { typeName, fieldName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({
+      typeName: response.typeName,
+      fieldName: response.fieldName,
+      count: response.usages.length,
+      usages: response.usages
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/operations-get-field-usage/types.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const fieldUsageLocationSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        operation: "operation";
+        fragment: "fragment";
+    }>;
+    name: z.ZodString;
+    filePath: z.ZodString;
+}, z.core.$strip>;
+export type FieldUsageLocation = z.infer<typeof fieldUsageLocationSchema>;
+export declare const getFieldUsageResponseSchema: z.ZodObject<{
+    typeName: z.ZodOptional<z.ZodString>;
+    fieldName: z.ZodOptional<z.ZodString>;
+    usages: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            operation: "operation";
+            fragment: "fragment";
+        }>;
+        name: z.ZodString;
+        filePath: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getFieldUsageOutputSchema: {
+    typeName: z.ZodOptional<z.ZodString>;
+    fieldName: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    usages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            operation: "operation";
+            fragment: "fragment";
+        }>;
+        name: z.ZodString;
+        filePath: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type GetFieldUsageResponse = z.infer<typeof getFieldUsageResponseSchema>;

package/dist/runtime/server/mcp/tools/operations-get-field-usage/types.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export const fieldUsageLocationSchema = z.object({
+  kind: z.enum(["operation", "fragment"]).describe("Whether this usage is in an operation or fragment"),
+  name: z.string().describe("Name of the operation or fragment"),
+  filePath: z.string().describe("File path where the usage occurs")
+});
+export const getFieldUsageResponseSchema = z.object({
+  typeName: z.string().describe("The GraphQL type name").optional(),
+  fieldName: z.string().describe("The field name").optional(),
+  usages: z.array(fieldUsageLocationSchema).describe("All locations where this field is used"),
+  error: z.string().optional().describe("Error message if the lookup failed")
+});
+export const getFieldUsageOutputSchema = {
+  typeName: z.string().optional().describe("The GraphQL type name"),
+  fieldName: z.string().optional().describe("The field name"),
+  count: z.number().optional().describe("Number of usages found"),
+  usages: z.array(fieldUsageLocationSchema).optional().describe("All locations where this field is used"),
+  error: z.string().optional().describe("Error message if the lookup failed")
+};

package/dist/runtime/server/mcp/tools/operations-get-source/index.d.ts

@@ -0,0 +1 @@
+export declare const getOperationSourceTool: any;