nuxt-graphql-middleware 5.2.3 → 5.3.1

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  listSchemaTypesOutputSchema
+} from "./types.js";
+export const listSchemaTypesTool = defineMcpTool({
+  name: "schema-list-types",
+  title: "List Schema Types",
+  description: "List all types in the GraphQL schema. Can be filtered by kind (OBJECT, INPUT_OBJECT, ENUM, UNION, INTERFACE, SCALAR). Returns type names, kinds, and descriptions.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    kind: z.enum(["OBJECT", "INPUT_OBJECT", "ENUM", "UNION", "INTERFACE", "SCALAR"]).optional().describe(
+      "Optional filter by type kind. If not provided, returns all types."
+    )
+  },
+  outputSchema: listSchemaTypesOutputSchema,
+  handler: async ({ kind }) => {
+    const params = {};
+    if (kind) {
+      params.kind = kind;
+    }
+    const response = await fetchFromMcpHandler(
+      "schema-list-types",
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return structuredResult({
+      count: response.types.length,
+      types: response.types
+    });
+  }
+});

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const SchemaTypeKindFilterSchema: z.ZodEnum<{
+    OBJECT: "OBJECT";
+    INPUT_OBJECT: "INPUT_OBJECT";
+    ENUM: "ENUM";
+    UNION: "UNION";
+    INTERFACE: "INTERFACE";
+    SCALAR: "SCALAR";
+}>;
+export declare const SchemaTypeSummarySchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        OBJECT: "OBJECT";
+        INPUT_OBJECT: "INPUT_OBJECT";
+        ENUM: "ENUM";
+        UNION: "UNION";
+        INTERFACE: "INTERFACE";
+        SCALAR: "SCALAR";
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ListSchemaTypesResponseSchema: z.ZodObject<{
+    types: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            OBJECT: "OBJECT";
+            INPUT_OBJECT: "INPUT_OBJECT";
+            ENUM: "ENUM";
+            UNION: "UNION";
+            INTERFACE: "INTERFACE";
+            SCALAR: "SCALAR";
+        }>;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const listSchemaTypesOutputSchema: {
+    count: z.ZodNumber;
+    types: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            OBJECT: "OBJECT";
+            INPUT_OBJECT: "INPUT_OBJECT";
+            ENUM: "ENUM";
+            UNION: "UNION";
+            INTERFACE: "INTERFACE";
+            SCALAR: "SCALAR";
+        }>;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+};
+export type SchemaTypeKindFilter = z.infer<typeof SchemaTypeKindFilterSchema>;
+export type SchemaTypeSummary = z.infer<typeof SchemaTypeSummarySchema>;
+export type ListSchemaTypesResponse = z.infer<typeof ListSchemaTypesResponseSchema>;

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const SchemaTypeKindFilterSchema = z.enum([
+  "OBJECT",
+  "INPUT_OBJECT",
+  "ENUM",
+  "UNION",
+  "INTERFACE",
+  "SCALAR"
+]);
+export const SchemaTypeSummarySchema = z.object({
+  name: z.string().describe("Type name"),
+  kind: SchemaTypeKindFilterSchema.describe("The kind of GraphQL type"),
+  description: z.string().nullable().describe("Type description")
+});
+export const ListSchemaTypesResponseSchema = z.object({
+  types: z.array(SchemaTypeSummarySchema)
+});
+export const listSchemaTypesOutputSchema = {
+  count: z.number().describe("Total number of types"),
+  types: z.array(SchemaTypeSummarySchema).describe("List of schema types")
+};

package/dist/runtime/server/mcp/tools/schema-validate-document/index.d.ts

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

package/dist/runtime/server/mcp/tools/schema-validate-document/index.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  validateDocumentOutputSchema
+} from "./types.js";
+export const validateDocumentTool = defineMcpTool({
+  name: "schema-validate-document",
+  title: "Validate Document",
+  description: "Validate a raw GraphQL document against the schema. Checks for syntax errors, unknown fields, type mismatches, and other validation issues. Use this to verify a GraphQL query, mutation, or fragment before saving it to a file.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    document: z.string().describe("The raw GraphQL document source to validate")
+  },
+  outputSchema: validateDocumentOutputSchema,
+  handler: async (args) => {
+    const response = await fetchFromMcpHandler(
+      "schema-validate-document",
+      { document: args.document }
+    );
+    return structuredResult({
+      valid: response.valid,
+      errors: response.errors
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-validate-document/types.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const ValidateDocumentRequestSchema: z.ZodObject<{
+    document: z.ZodString;
+}, z.core.$strip>;
+export declare const ValidateDocumentResponseSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const validateDocumentOutputSchema: {
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+};
+export type ValidateDocumentRequest = z.infer<typeof ValidateDocumentRequestSchema>;
+export type ValidateDocumentResponse = z.infer<typeof ValidateDocumentResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-validate-document/types.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const ValidateDocumentRequestSchema = z.object({
+  document: z.string().describe("The raw GraphQL document source to validate")
+});
+const ValidationErrorSchema = z.object({
+  message: z.string().describe("The error message"),
+  locations: z.array(
+    z.object({
+      line: z.number().describe("Line number (1-indexed)"),
+      column: z.number().describe("Column number (1-indexed)")
+    })
+  ).optional().describe("Source locations where the error occurred")
+});
+export const ValidateDocumentResponseSchema = z.object({
+  valid: z.boolean().describe("Whether the document is valid"),
+  errors: z.array(ValidationErrorSchema).describe("List of validation errors, empty if valid")
+});
+export const validateDocumentOutputSchema = {
+  valid: z.boolean().describe("Whether the document is valid"),
+  errors: z.array(ValidationErrorSchema).describe("List of validation errors, empty if valid")
+};

package/dist/runtime/server/mcp/tools/vue-graphql-composable-example/index.d.ts

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

package/dist/runtime/server/mcp/tools/vue-graphql-composable-example/index.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  composableExamplesOutputSchema
+} from "./types.js";
+export const vueGraphqlComposableExampleTool = defineMcpTool({
+  name: "vue-graphql-composable-example",
+  title: "Vue GraphQL Composable Examples",
+  description: "Generate usage examples for Vue composables (useGraphqlQuery, useAsyncGraphqlQuery, useGraphqlMutation, etc.) for a specific GraphQL operation. Returns code examples with mock variable data.",
+  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: composableExamplesOutputSchema,
+  handler: async ({ operationName }) => {
+    const response = await fetchFromMcpHandler(
+      "vue-graphql-composable-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/vue-graphql-composable-example/types.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+/**
+ * Schema for a single usage example.
+ */
+export declare const ComposableExampleSchema: 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 GetComposableExamplesResponseSchema: 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 composableExamplesOutputSchema: {
+    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 ComposableExample = z.infer<typeof ComposableExampleSchema>;
+export type ImportEntry = z.infer<typeof ImportEntrySchema>;
+export type GetComposableExamplesResponse = z.infer<typeof GetComposableExamplesResponseSchema>;

package/dist/runtime/server/mcp/tools/vue-graphql-composable-example/types.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const ComposableExampleSchema = z.object({
+  code: z.string().describe("The code example showing how to use the composable"),
+  description: z.string().describe("A description of what this example demonstrates"),
+  documentationUrl: z.string().describe("URL to the documentation for this composable")
+});
+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 GetComposableExamplesResponseSchema = z.object({
+  examples: z.array(ComposableExampleSchema).optional(),
+  imports: z.array(ImportEntrySchema).optional(),
+  error: z.string().optional()
+});
+export const composableExamplesOutputSchema = {
+  examples: z.array(ComposableExampleSchema).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/utils/index.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { GraphqlServerResponse } from '../../../types.js';
+/**
+ * Shared Zod schema for GraphQL errors.
+ */
+export declare const GraphqlErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, z.core.$strip>>>;
+    path: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Shared output schema for GraphQL execution results.
+ */
+export declare const graphqlExecutionOutputSchema: {
+    data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>>;
+        path: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+};
+/**
+ * Extracts GraphQL error response from a fetch error.
+ */
+export declare function extractErrorResponse(e: unknown): GraphqlServerResponse<any> | null;
+/**
+ * Fetches data from the MCP dev handler using POST.
+ */
+export declare function fetchFromMcpHandler<T>(tool: string, params?: Record<string, unknown>): Promise<T>;
+/**
+ * Creates an MCP tool result with both content (for backwards compatibility)
+ * and structuredContent (required when outputSchema is defined).
+ */
+export declare function structuredResult<T extends Record<string, unknown>>(data: T): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: T;
+};

package/dist/runtime/server/mcp/utils/index.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { devServerUrl } from "#nuxt-graphql-middleware/mcp";
+export const GraphqlErrorSchema = z.object({
+  message: z.string().describe("The error message"),
+  locations: z.array(
+    z.object({
+      line: z.number().describe("Line number"),
+      column: z.number().describe("Column number")
+    })
+  ).optional().describe("Source locations where the error occurred"),
+  path: z.array(z.union([z.string(), z.number()])).optional().describe("Path to the field that caused the error"),
+  extensions: z.record(z.string(), z.unknown()).optional().describe("Additional error metadata")
+});
+export const graphqlExecutionOutputSchema = {
+  data: z.record(z.string(), z.unknown()).nullable().describe("The GraphQL response data, or null if the request failed"),
+  errors: z.array(GraphqlErrorSchema).optional().describe("GraphQL errors if any occurred")
+};
+export function extractErrorResponse(e) {
+  if (typeof e === "object" && e && "response" in e && e.response && typeof e.response === "object" && "_data" in e.response && typeof e.response._data === "object") {
+    return e.response._data;
+  }
+  return null;
+}
+export async function fetchFromMcpHandler(tool, params) {
+  return await $fetch(`${devServerUrl}/__nuxt_graphql_middleware/mcp`, {
+    method: "POST",
+    body: { tool, ...params }
+  });
+}
+export function structuredResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
+}

package/dist/runtime/server/utils/useGraphqlMutation.d.ts

@@ -1,5 +1,5 @@
 import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
-import { type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../../helpers/composables.js';
+import { type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../../helpers/shared-types.js';
 import type { Mutation } from '#nuxt-graphql-middleware/operation-types';
 /**
  * Performs a GraphQL mutation.

package/dist/runtime/server/utils/useGraphqlMutation.js

@@ -1,6 +1,6 @@
 import {
   encodeContext
-} from "./../../helpers/composables.js";
+} from "./../../helpers/shared-types.js";
 import { performRequest } from "./index.js";
 export function useGraphqlMutation(...args) {
   const [name, body, fetchOptions = {}, clientContext = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions, args[2]?.clientContext] : [

package/dist/runtime/server/utils/useGraphqlQuery.d.ts

@@ -1,5 +1,5 @@
 import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
-import { type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../../helpers/composables.js';
+import { type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../../helpers/shared-types.js';
 import type { Query } from '#nuxt-graphql-middleware/operation-types';
 /**
  * Performs a GraphQL query.

package/dist/runtime/server/utils/useGraphqlQuery.js

@@ -1,6 +1,6 @@
 import {
   encodeContext
-} from "./../../helpers/composables.js";
+} from "./../../helpers/shared-types.js";
 import { encodeVariables } from "./../../helpers/queryEncoding.js";
 import { performRequest } from "./index.js";
 export function useGraphqlQuery(...args) {

package/dist/shared/{nuxt-graphql-middleware.ct2xvPoD.d.mts → nuxt-graphql-middleware.COufMnWs.d.mts}

@@ -230,6 +230,21 @@ interface ModuleOptions {
          */
         improvedQueryParamEncoding?: boolean;
     };
+    /**
+     * Configuration for the @nuxtjs/mcp-toolkit integration.
+     */
+    mcp?: {
+        /**
+         * Whether the MCP integration should be enabled.
+         */
+        enabled: boolean;
+        /**
+         * The route of the MCP server.
+         *
+         * @default /mcp/nuxt-graphql-middleware
+         */
+        route?: string;
+    };
 }
 
 declare const defaultOptions: ModuleOptions;
@@ -242,6 +257,7 @@ declare class ConsolePrompt {
 
 type TemplateOptions = {
     path: string;
+    context: 'nuxt' | 'nitro' | 'both';
     virtual?: boolean;
     isFullPath?: boolean;
 };
@@ -262,6 +278,27 @@ type StaticTemplate = {
     virtual?: boolean;
 };
 
+type BuildImport = {
+    name: string;
+    description: string;
+    docsUrl: string;
+    context: 'nuxt' | 'nitro';
+};
+declare const COMPOSABLES: {
+    useGraphqlQuery: BuildImport;
+    useGraphqlMutation: BuildImport;
+    useAsyncGraphqlQuery: BuildImport;
+    useGraphqlUploadMutation: BuildImport;
+    useGraphqlState: BuildImport;
+};
+type ComposableName = keyof typeof COMPOSABLES;
+declare const SERVER_UTILS: {
+    useGraphqlQuery: BuildImport;
+    useGraphqlMutation: BuildImport;
+    doGraphqlRequest: BuildImport;
+};
+type ServerUtilName = keyof typeof SERVER_UTILS;
+
 type WithRequired<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };
@@ -306,6 +343,7 @@ declare class ModuleHelper {
     readonly resolvers: ModuleHelperResolvers;
     readonly paths: ModuleHelperPaths;
     readonly isDev: boolean;
+    readonly isPrepare: boolean;
     readonly options: RequiredModuleOptions;
     readonly prompt: ConsolePrompt;
     private nitroExternals;
@@ -343,12 +381,67 @@ declare class ModuleHelper {
     applyBuildConfig(): void;
     processTemplate(path: string, content: string): string;
     addTemplate(template: StaticTemplate): void;
+    /**
+     * Register a type template without adding to globalTypeFiles.
+     *
+     * Uses addTemplate instead of addTypeTemplate to avoid Vue compiler-sfc
+     * issue where exported types from globalTypeFiles cannot be resolved.
+     * @see https://github.com/nuxt/nuxt/issues/33694
+     */
+    registerTypeTemplate(filename: `${string}.d.ts`, getContents: () => string, context: 'nuxt' | 'nitro' | 'both'): void;
     addPlugin(name: string): void;
     addServerHandler(name: string, path: string, method: RouterMethod): void;
-    addComposable(name: string): void;
-    addServerUtil(name: string): void;
+    addComposable(name: ComposableName): void;
+    addServerUtil(name: ServerUtilName): void;
 }
 
+/**
+ * Represents a collected GraphQL operation with metadata.
+ * Used internally by the Collector - decoupled from MCP tool schemas.
+ */
+type CollectorOperation = {
+    /** The GraphQL operation name */
+    name: string;
+    /** The type of operation */
+    type: 'query' | 'mutation';
+    /** Absolute path to the file containing the operation */
+    filePath: string;
+    /** Path to the file relative to the project root */
+    relativeFilePath: string;
+    /** Whether the operation has any variables */
+    hasVariables: boolean;
+    /** Whether the operation requires variables (has non-null variables) */
+    needsVariables: boolean;
+    /** TypeScript type name for the operation variables */
+    variablesTypeName: string;
+    /** TypeScript type name for the operation response */
+    responseTypeName: string;
+    /** The GraphQL source code of just this operation (no fragments) */
+    source: string;
+    /** The full GraphQL source including all fragment dependencies */
+    sourceFull: string;
+};
+/**
+ * Represents a collected GraphQL fragment with metadata.
+ * Used internally by the Collector - decoupled from MCP tool schemas.
+ */
+type CollectorFragment = {
+    /** The fragment name */
+    name: string;
+    /** The GraphQL type this fragment is defined on */
+    typeName: string;
+    /** Absolute path to the file containing the fragment */
+    filePath: string;
+    /** Path to the file relative to the project root */
+    relativeFilePath: string;
+    /** The GraphQL source code of just this fragment (no dependencies) */
+    source: string;
+    /** The full GraphQL source including all fragment dependencies */
+    sourceFull: string;
+    /** Names of other fragments this fragment depends on */
+    dependencies: string[];
+};
+
 type CollectorWatchEventResult = {
     hasChanged: boolean;
     affectedOperations: string[];
@@ -391,6 +484,14 @@ declare class Collector {
      * The generated template contents.
      */
     private templateResult;
+    /**
+     * Operations with full metadata for MCP tools.
+     */
+    private operations;
+    /**
+     * Fragments with full metadata for MCP tools.
+     */
+    private fragments;
     private isInitialised;
     constructor(schema: GraphQLSchema, helper: ModuleHelper);
     reset(): Promise<void>;
@@ -457,6 +558,22 @@ declare class Collector {
      * Get the hook documents.
      */
     getHookFiles(): string[];
+    /**
+     * Get all operations with metadata (for MCP tools).
+     */
+    getOperations(): CollectorOperation[];
+    /**
+     * Get all fragments for a specific GraphQL type (for MCP tools).
+     */
+    getFragmentsForType(typeName: string): CollectorFragment[];
+    /**
+     * Get all fragments (for MCP tools).
+     */
+    getFragments(): CollectorFragment[];
+    /**
+     * Get a fragment by name (for MCP tools).
+     */
+    getFragment(name: string): CollectorFragment | undefined;
 }
 
 /**

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { M as ModuleContext } from './shared/nuxt-graphql-middleware.ct2xvPoD.mjs';
+import { M as ModuleContext } from './shared/nuxt-graphql-middleware.COufMnWs.mjs';
 import 'graphql';
 import 'nuxt/schema';
 import '@nuxt/kit';