nuxt-graphql-middleware 5.2.3 → 5.3.0

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  listOperationsOutputSchema,
+  OperationTypeFilterSchema
+} from "./types.js";
+export const listOperationsTool = defineMcpTool({
+  name: "operations-list",
+  title: "List Operations",
+  description: "List all GraphQL operations (queries and mutations) available in the project. Returns operation names, types, file paths, and variable requirements.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    nameFilter: z.string().optional().describe(
+      'Optional filter to match operation names. Can be a plain string for substring matching or a regex pattern (e.g., "^get" to match names starting with "get")'
+    ),
+    type: OperationTypeFilterSchema.optional().describe(
+      'Optional filter by operation type: "query" or "mutation"'
+    )
+  },
+  outputSchema: listOperationsOutputSchema,
+  handler: async ({ nameFilter, type }) => {
+    const response = await fetchFromMcpHandler(
+      "operations-list",
+      { nameFilter, type }
+    );
+    const summary = response.operations.map((op) => ({
+      name: op.name,
+      type: op.type,
+      filePath: op.relativeFilePath,
+      hasVariables: op.hasVariables,
+      needsVariables: op.needsVariables,
+      variablesTypeName: op.variablesTypeName,
+      responseTypeName: op.responseTypeName
+    }));
+    return structuredResult({
+      count: response.operations.length,
+      operations: summary
+    });
+  }
+});

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const OperationTypeFilterSchema: z.ZodEnum<{
+    query: "query";
+    mutation: "mutation";
+}>;
+export type OperationTypeFilter = z.infer<typeof OperationTypeFilterSchema>;
+export declare const CollectorOperationSchema: 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>;
+export declare const ListOperationsResponseSchema: z.ZodObject<{
+    operations: z.ZodArray<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>>;
+}, z.core.$strip>;
+export declare const listOperationsOutputSchema: {
+    count: z.ZodNumber;
+    operations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+        }>;
+        filePath: z.ZodString;
+        hasVariables: z.ZodBoolean;
+        needsVariables: z.ZodBoolean;
+        variablesTypeName: z.ZodString;
+        responseTypeName: z.ZodString;
+    }, z.core.$strip>>;
+};
+export type CollectorOperation = z.infer<typeof CollectorOperationSchema>;
+export type ListOperationsResponse = z.infer<typeof ListOperationsResponseSchema>;

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export const OperationTypeFilterSchema = z.enum(["query", "mutation"]);
+export const CollectorOperationSchema = z.object({
+  name: z.string().describe("The GraphQL operation name"),
+  type: z.enum(["query", "mutation"]).describe("The type of operation (query or mutation)"),
+  filePath: z.string().describe("Absolute path to the file containing the operation"),
+  relativeFilePath: z.string().describe("Path to the file relative to the project root"),
+  hasVariables: z.boolean().describe("Whether the operation has any variables"),
+  needsVariables: z.boolean().describe(
+    "Whether the operation requires variables (has non-null variables)"
+  ),
+  variablesTypeName: z.string().describe("TypeScript type name for the operation variables"),
+  responseTypeName: z.string().describe("TypeScript type name for the operation response"),
+  source: z.string().describe("The GraphQL source code of the operation")
+});
+export const ListOperationsResponseSchema = z.object({
+  operations: z.array(CollectorOperationSchema)
+});
+const OperationMcpSchema = z.object({
+  name: z.string().describe("The GraphQL operation name"),
+  type: z.enum(["query", "mutation"]).describe("The type of operation (query or mutation)"),
+  filePath: z.string().describe("Path to the file relative to the project root"),
+  hasVariables: z.boolean().describe("Whether the operation has any variables"),
+  needsVariables: z.boolean().describe(
+    "Whether the operation requires variables (has non-null variables)"
+  ),
+  variablesTypeName: z.string().describe("TypeScript type name for the operation variables"),
+  responseTypeName: z.string().describe("TypeScript type name for the operation response")
+});
+export const listOperationsOutputSchema = {
+  count: z.number().describe("Total number of operations"),
+  operations: z.array(OperationMcpSchema).describe("List of all operations")
+};

package/dist/runtime/server/mcp/tools/schema-get-interface-implementors/index.d.ts

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

package/dist/runtime/server/mcp/tools/schema-get-interface-implementors/index.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  getTypesImplementingInterfaceOutputSchema
+} from "./types.js";
+export const getTypesImplementingInterfaceTool = defineMcpTool({
+  name: "schema-get-interface-implementors",
+  title: "Get Interface Implementors",
+  description: "Get all object types that implement a given GraphQL interface. Returns the implementing type names and descriptions.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    interfaceName: z.string().describe(
+      'The name of the GraphQL interface (e.g., "Node", "Connection")'
+    )
+  },
+  outputSchema: getTypesImplementingInterfaceOutputSchema,
+  handler: async ({ interfaceName }) => {
+    const response = await fetchFromMcpHandler(
+      "schema-get-interface-implementors",
+      { name: interfaceName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({
+      interfaceName: response.interfaceName,
+      count: response.types.length,
+      types: response.types
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-get-interface-implementors/types.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const ImplementingTypeSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const GetTypesImplementingInterfaceResponseSchema: z.ZodObject<{
+    interfaceName: z.ZodString;
+    types: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getTypesImplementingInterfaceOutputSchema: {
+    interfaceName: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    types: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type ImplementingType = z.infer<typeof ImplementingTypeSchema>;
+export type GetTypesImplementingInterfaceResponse = z.infer<typeof GetTypesImplementingInterfaceResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-get-interface-implementors/types.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const ImplementingTypeSchema = z.object({
+  name: z.string().describe("Type name"),
+  description: z.string().nullable().describe("Type description")
+});
+export const GetTypesImplementingInterfaceResponseSchema = z.object({
+  interfaceName: z.string().describe("The interface name"),
+  types: z.array(ImplementingTypeSchema),
+  error: z.string().optional().describe("Error message if interface not found")
+});
+export const getTypesImplementingInterfaceOutputSchema = {
+  interfaceName: z.string().optional().describe("The interface name"),
+  count: z.number().optional().describe("Number of implementing types"),
+  types: z.array(ImplementingTypeSchema).optional().describe("Types that implement the interface"),
+  error: z.string().optional().describe("Error message if interface not found")
+};

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

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

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

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import { getSchemaTypeOutputSchema } from "./types.js";
+export const getSchemaTypeTool = defineMcpTool({
+  name: "schema-get-type",
+  title: "Get Schema Type",
+  description: "Get detailed information about a GraphQL type from the schema. Returns the type kind (OBJECT, INPUT_OBJECT, ENUM, UNION, INTERFACE, SCALAR), description, fields with their types, enum values, possible types for unions, and implemented interfaces.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    typeName: z.string().describe(
+      'The name of the GraphQL type to inspect (e.g., "User", "CreateUserInput", "UserRole")'
+    )
+  },
+  outputSchema: getSchemaTypeOutputSchema,
+  handler: async ({ typeName }) => {
+    const response = await fetchFromMcpHandler(
+      "schema-get-type",
+      { name: typeName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult(response.type);
+  }
+});

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

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+export declare const SchemaTypeFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    type: z.ZodString;
+    isNonNull: z.ZodBoolean;
+    isList: z.ZodBoolean;
+    deprecationReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const SchemaTypeEnumValueSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const SchemaTypeKindSchema: z.ZodEnum<{
+    OBJECT: "OBJECT";
+    INPUT_OBJECT: "INPUT_OBJECT";
+    ENUM: "ENUM";
+    UNION: "UNION";
+    INTERFACE: "INTERFACE";
+    SCALAR: "SCALAR";
+    UNKNOWN: "UNKNOWN";
+}>;
+export declare const SchemaTypeInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        OBJECT: "OBJECT";
+        INPUT_OBJECT: "INPUT_OBJECT";
+        ENUM: "ENUM";
+        UNION: "UNION";
+        INTERFACE: "INTERFACE";
+        SCALAR: "SCALAR";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+    fields: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        type: z.ZodString;
+        isNonNull: z.ZodBoolean;
+        isList: z.ZodBoolean;
+        deprecationReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    enumValues: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    possibleTypes: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    interfaces: z.ZodNullable<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const GetSchemaTypeResponseSchema: z.ZodObject<{
+    type: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            OBJECT: "OBJECT";
+            INPUT_OBJECT: "INPUT_OBJECT";
+            ENUM: "ENUM";
+            UNION: "UNION";
+            INTERFACE: "INTERFACE";
+            SCALAR: "SCALAR";
+            UNKNOWN: "UNKNOWN";
+        }>;
+        description: z.ZodNullable<z.ZodString>;
+        fields: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            type: z.ZodString;
+            isNonNull: z.ZodBoolean;
+            isList: z.ZodBoolean;
+            deprecationReason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        enumValues: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        possibleTypes: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        interfaces: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getSchemaTypeOutputSchema: {
+    name: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        OBJECT: "OBJECT";
+        INPUT_OBJECT: "INPUT_OBJECT";
+        ENUM: "ENUM";
+        UNION: "UNION";
+        INTERFACE: "INTERFACE";
+        SCALAR: "SCALAR";
+        UNKNOWN: "UNKNOWN";
+    }>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        type: z.ZodString;
+        isNonNull: z.ZodBoolean;
+        isList: z.ZodBoolean;
+        deprecationReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>>;
+    enumValues: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>>;
+    possibleTypes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    interfaces: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type SchemaTypeField = z.infer<typeof SchemaTypeFieldSchema>;
+export type SchemaTypeEnumValue = z.infer<typeof SchemaTypeEnumValueSchema>;
+export type SchemaTypeKind = z.infer<typeof SchemaTypeKindSchema>;
+export type SchemaTypeInfo = z.infer<typeof SchemaTypeInfoSchema>;
+export type GetSchemaTypeResponse = z.infer<typeof GetSchemaTypeResponseSchema>;

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

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export const SchemaTypeFieldSchema = z.object({
+  name: z.string().describe("Field name"),
+  description: z.string().nullable().describe("Field description"),
+  type: z.string().describe('GraphQL type (e.g., "String!", "[User!]!")'),
+  isNonNull: z.boolean().describe("Whether the field is non-nullable"),
+  isList: z.boolean().describe("Whether the field is a list type"),
+  deprecationReason: z.string().nullable().describe("Deprecation reason if the field is deprecated")
+});
+export const SchemaTypeEnumValueSchema = z.object({
+  name: z.string().describe("Enum value name"),
+  description: z.string().nullable().describe("Enum value description")
+});
+export const SchemaTypeKindSchema = z.enum([
+  "OBJECT",
+  "INPUT_OBJECT",
+  "ENUM",
+  "UNION",
+  "INTERFACE",
+  "SCALAR",
+  "UNKNOWN"
+]);
+export const SchemaTypeInfoSchema = z.object({
+  name: z.string().describe("Type name"),
+  kind: SchemaTypeKindSchema.describe("The kind of GraphQL type"),
+  description: z.string().nullable().describe("Type description"),
+  fields: z.array(SchemaTypeFieldSchema).nullable().describe("Fields for OBJECT, INPUT_OBJECT, and INTERFACE types"),
+  enumValues: z.array(SchemaTypeEnumValueSchema).nullable().describe("Values for ENUM types"),
+  possibleTypes: z.array(z.string()).nullable().describe("Possible types for UNION types"),
+  interfaces: z.array(z.string()).nullable().describe("Implemented interfaces for OBJECT types")
+});
+export const GetSchemaTypeResponseSchema = z.object({
+  type: SchemaTypeInfoSchema.nullable(),
+  error: z.string().optional().describe("Error message if type not found")
+});
+export const getSchemaTypeOutputSchema = {
+  name: z.string().optional().describe("Type name"),
+  kind: SchemaTypeKindSchema.optional().describe("The kind of GraphQL type"),
+  description: z.string().nullable().optional().describe("Type description"),
+  fields: z.array(SchemaTypeFieldSchema).nullable().optional().describe("Fields for OBJECT, INPUT_OBJECT, and INTERFACE types"),
+  enumValues: z.array(SchemaTypeEnumValueSchema).nullable().optional().describe("Values for ENUM types"),
+  possibleTypes: z.array(z.string()).nullable().optional().describe("Possible types for UNION types"),
+  interfaces: z.array(z.string()).nullable().optional().describe("Implemented interfaces for OBJECT types"),
+  error: z.string().optional().describe("Error message if type not found")
+};

package/dist/runtime/server/mcp/tools/schema-get-type-definition/index.d.ts

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

package/dist/runtime/server/mcp/tools/schema-get-type-definition/index.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  getSchemaTypeDefinitionOutputSchema
+} from "./types.js";
+export const getSchemaTypeDefinitionTool = defineMcpTool({
+  name: "schema-get-type-definition",
+  title: "Get Type Definition",
+  description: "Get the full SDL (Schema Definition Language) definition of a GraphQL type. Returns the complete type definition as it appears in the schema, including all fields, arguments, directives, and descriptions.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    typeName: z.string().describe(
+      'The name of the GraphQL type to get the definition for (e.g., "User", "CreateUserInput", "UserRole")'
+    )
+  },
+  outputSchema: getSchemaTypeDefinitionOutputSchema,
+  handler: async ({ typeName }) => {
+    const response = await fetchFromMcpHandler(
+      "schema-get-type-definition",
+      { name: typeName }
+    );
+    return structuredResult({
+      definition: response.definition,
+      error: response.error
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-get-type-definition/types.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const GetSchemaTypeDefinitionResponseSchema: z.ZodObject<{
+    definition: z.ZodNullable<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getSchemaTypeDefinitionOutputSchema: {
+    definition: z.ZodNullable<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type GetSchemaTypeDefinitionResponse = z.infer<typeof GetSchemaTypeDefinitionResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-get-type-definition/types.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const GetSchemaTypeDefinitionResponseSchema = z.object({
+  definition: z.string().nullable().describe("The full SDL definition of the type"),
+  error: z.string().optional().describe("Error message if the type was not found")
+});
+export const getSchemaTypeDefinitionOutputSchema = {
+  definition: z.string().nullable().describe("The full SDL definition of the type"),
+  error: z.string().optional().describe("Error message if the type was not found")
+};

package/dist/runtime/server/mcp/tools/schema-get-type-usage/index.d.ts

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

package/dist/runtime/server/mcp/tools/schema-get-type-usage/index.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import { getTypeUsageOutputSchema } from "./types.js";
+export const getTypeUsageTool = defineMcpTool({
+  name: "schema-get-type-usage",
+  title: "Get Type Usage",
+  description: "Find all places where a GraphQL type is used in the schema. Shows where a type appears as a field return type, argument type, or input field type.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    typeName: z.string().describe(
+      'The name of the GraphQL type to find usages for (e.g., "User", "ID", "DateTime")'
+    )
+  },
+  outputSchema: getTypeUsageOutputSchema,
+  handler: async ({ typeName }) => {
+    const response = await fetchFromMcpHandler(
+      "schema-get-type-usage",
+      { name: typeName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({
+      typeName: response.typeName,
+      count: response.usages.length,
+      usages: response.usages
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-get-type-usage/types.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const TypeUsageLocationSchema: z.ZodObject<{
+    typeName: z.ZodString;
+    fieldName: z.ZodString;
+    usageType: z.ZodEnum<{
+        return_type: "return_type";
+        argument: "argument";
+        input_field: "input_field";
+    }>;
+}, z.core.$strip>;
+export declare const GetTypeUsageResponseSchema: z.ZodObject<{
+    typeName: z.ZodString;
+    usages: z.ZodArray<z.ZodObject<{
+        typeName: z.ZodString;
+        fieldName: z.ZodString;
+        usageType: z.ZodEnum<{
+            return_type: "return_type";
+            argument: "argument";
+            input_field: "input_field";
+        }>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getTypeUsageOutputSchema: {
+    typeName: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    usages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        typeName: z.ZodString;
+        fieldName: z.ZodString;
+        usageType: z.ZodEnum<{
+            return_type: "return_type";
+            argument: "argument";
+            input_field: "input_field";
+        }>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type TypeUsageLocation = z.infer<typeof TypeUsageLocationSchema>;
+export type GetTypeUsageResponse = z.infer<typeof GetTypeUsageResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-get-type-usage/types.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const TypeUsageLocationSchema = z.object({
+  typeName: z.string().describe("The type where this type is used"),
+  fieldName: z.string().describe("The field name"),
+  usageType: z.enum(["return_type", "argument", "input_field"]).describe("How the type is used")
+});
+export const GetTypeUsageResponseSchema = z.object({
+  typeName: z.string().describe("The type being searched for"),
+  usages: z.array(TypeUsageLocationSchema),
+  error: z.string().optional().describe("Error message if type not found")
+});
+export const getTypeUsageOutputSchema = {
+  typeName: z.string().optional().describe("The type being searched for"),
+  count: z.number().optional().describe("Number of usages found"),
+  usages: z.array(TypeUsageLocationSchema).optional().describe("Locations where the type is used"),
+  error: z.string().optional().describe("Error message if type not found")
+};

package/dist/runtime/server/mcp/tools/schema-get-union-members/index.d.ts

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

package/dist/runtime/server/mcp/tools/schema-get-union-members/index.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  getUnionMembersOutputSchema
+} from "./types.js";
+export const getUnionMembersTool = defineMcpTool({
+  name: "schema-get-union-members",
+  title: "Get Union Members",
+  description: "Get all types that are members of a GraphQL union. Returns the member type names and descriptions.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    unionName: z.string().describe('The name of the GraphQL union (e.g., "SearchResult")')
+  },
+  outputSchema: getUnionMembersOutputSchema,
+  handler: async ({ unionName }) => {
+    const response = await fetchFromMcpHandler(
+      "schema-get-union-members",
+      { name: unionName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({
+      unionName: response.unionName,
+      count: response.members.length,
+      members: response.members
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-get-union-members/types.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const UnionMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const GetUnionMembersResponseSchema: z.ZodObject<{
+    unionName: z.ZodString;
+    members: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getUnionMembersOutputSchema: {
+    unionName: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    members: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type UnionMember = z.infer<typeof UnionMemberSchema>;
+export type GetUnionMembersResponse = z.infer<typeof GetUnionMembersResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-get-union-members/types.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const UnionMemberSchema = z.object({
+  name: z.string().describe("Type name"),
+  description: z.string().nullable().describe("Type description")
+});
+export const GetUnionMembersResponseSchema = z.object({
+  unionName: z.string().describe("The union name"),
+  members: z.array(UnionMemberSchema),
+  error: z.string().optional().describe("Error message if union not found")
+});
+export const getUnionMembersOutputSchema = {
+  unionName: z.string().optional().describe("The union name"),
+  count: z.number().optional().describe("Number of union members"),
+  members: z.array(UnionMemberSchema).optional().describe("Types that are part of the union"),
+  error: z.string().optional().describe("Error message if union not found")
+};

package/dist/runtime/server/mcp/tools/schema-list-types/index.d.ts

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