graphql-agent-toolkit 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1726 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GraphQLExecutor: () => GraphQLExecutor,
+  SchemaNavigator: () => SchemaNavigator,
+  buildOperation: () => buildOperation,
+  createAgentToolkitServer: () => createAgentToolkitServer,
+  createCrewAITools: () => createCrewAITools,
+  createLangChainTools: () => createLangChainTools,
+  createMockExecutor: () => createMockExecutor,
+  createStructuredTools: () => createStructuredTools,
+  createToolsFromSchema: () => createToolsFromSchema,
+  createVercelAITools: () => createVercelAITools,
+  detectPaginationStyle: () => detectPaginationStyle,
+  executePaginated: () => executePaginated,
+  fetchSchema: () => fetchSchema,
+  formatForLLM: () => formatForLLM,
+  generateMockData: () => generateMockData,
+  parseSchema: () => parseSchema,
+  summarizeResponse: () => summarizeResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/introspection/fetcher.ts
+var import_graphql = require("graphql");
+var import_graphql_request = require("graphql-request");
+async function fetchSchema(options) {
+  const client = new import_graphql_request.GraphQLClient(options.endpoint, {
+    headers: options.headers
+  });
+  const query = (0, import_graphql.getIntrospectionQuery)();
+  try {
+    const result = await client.request(query);
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to fetch schema from ${options.endpoint}: ${error.message}`);
+    }
+    throw new Error(`Failed to fetch schema from ${options.endpoint}: Unknown error`);
+  }
+}
+
+// src/introspection/parser.ts
+function convertTypeRef(introspectionType) {
+  return {
+    kind: introspectionType.kind,
+    name: introspectionType.name ?? null,
+    ofType: introspectionType.ofType ? convertTypeRef(
+      introspectionType.ofType
+    ) : null
+  };
+}
+function convertArgument(arg) {
+  return {
+    name: arg.name,
+    description: arg.description ?? null,
+    type: convertTypeRef(arg.type),
+    defaultValue: arg.defaultValue ?? null
+  };
+}
+function convertField(field) {
+  return {
+    name: field.name,
+    description: field.description ?? null,
+    type: convertTypeRef(field.type),
+    args: (field.args ?? []).map(convertArgument),
+    isDeprecated: field.isDeprecated ?? false
+  };
+}
+function parseSchema(introspectionResult) {
+  const schema = introspectionResult.__schema;
+  const types = /* @__PURE__ */ new Map();
+  for (const type of schema.types) {
+    if (type.name.startsWith("__")) {
+      continue;
+    }
+    const schemaType = {
+      name: type.name,
+      kind: type.kind,
+      description: type.description ?? null,
+      fields: "fields" in type && type.fields ? type.fields.map(convertField) : [],
+      inputFields: "inputFields" in type && type.inputFields ? type.inputFields.map(convertArgument) : [],
+      enumValues: "enumValues" in type && type.enumValues ? type.enumValues.map((v) => ({
+        name: v.name,
+        description: v.description ?? null
+      })) : [],
+      interfaces: "interfaces" in type && type.interfaces ? type.interfaces.map((i) => i.name) : [],
+      possibleTypes: "possibleTypes" in type && type.possibleTypes ? type.possibleTypes.map((t) => t.name) : []
+    };
+    types.set(type.name, schemaType);
+  }
+  return {
+    queryType: schema.queryType.name,
+    mutationType: schema.mutationType?.name ?? null,
+    subscriptionType: schema.subscriptionType?.name ?? null,
+    types
+  };
+}
+
+// src/operations/variables.ts
+function typeRefToString(typeRef) {
+  if (typeRef.kind === "NON_NULL") {
+    if (!typeRef.ofType) {
+      return "Unknown!";
+    }
+    return `${typeRefToString(typeRef.ofType)}!`;
+  }
+  if (typeRef.kind === "LIST") {
+    if (!typeRef.ofType) {
+      return "[Unknown]";
+    }
+    return `[${typeRefToString(typeRef.ofType)}]`;
+  }
+  return typeRef.name ?? "Unknown";
+}
+function isRequired(typeRef) {
+  return typeRef.kind === "NON_NULL";
+}
+function unwrapType(typeRef) {
+  if (typeRef.kind === "NON_NULL" || typeRef.kind === "LIST") {
+    if (typeRef.ofType) {
+      return unwrapType(typeRef.ofType);
+    }
+  }
+  return typeRef;
+}
+
+// src/operations/builder.ts
+var SCALAR_KINDS = /* @__PURE__ */ new Set(["SCALAR", "ENUM"]);
+function isScalarLike(schema, field) {
+  const unwrapped = unwrapType(field.type);
+  if (SCALAR_KINDS.has(unwrapped.kind)) {
+    return true;
+  }
+  if (unwrapped.name) {
+    const namedType = schema.types.get(unwrapped.name);
+    if (namedType && SCALAR_KINDS.has(namedType.kind)) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildSelectionSet(schema, typeName, currentDepth, maxDepth, visited, includeDeprecated, indentLevel = 2) {
+  if (currentDepth >= maxDepth) {
+    return "";
+  }
+  const type = schema.types.get(typeName);
+  if (!type || type.fields.length === 0) {
+    return "";
+  }
+  const fieldIndent = "  ".repeat(indentLevel + 1);
+  const closingIndent = "  ".repeat(indentLevel);
+  if (visited.has(typeName)) {
+    const scalarFields = type.fields.filter((f) => !f.isDeprecated || includeDeprecated).filter((f) => isScalarLike(schema, f));
+    if (scalarFields.length === 0) {
+      return "";
+    }
+    return `{
+${scalarFields.map((f) => `${fieldIndent}${f.name}`).join("\n")}
+${closingIndent}}`;
+  }
+  visited.add(typeName);
+  const fields = type.fields.filter((f) => !f.isDeprecated || includeDeprecated);
+  const lines = [];
+  for (const field of fields) {
+    const unwrapped = unwrapType(field.type);
+    if (isScalarLike(schema, field)) {
+      lines.push(`${fieldIndent}${field.name}`);
+    } else if (unwrapped.name) {
+      const nestedSelection = buildSelectionSet(
+        schema,
+        unwrapped.name,
+        currentDepth + 1,
+        maxDepth,
+        new Set(visited),
+        includeDeprecated,
+        indentLevel + 1
+      );
+      if (nestedSelection) {
+        lines.push(`${fieldIndent}${field.name} ${nestedSelection}`);
+      }
+    }
+  }
+  visited.delete(typeName);
+  if (lines.length === 0) {
+    return "";
+  }
+  return `{
+${lines.join("\n")}
+${closingIndent}}`;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function buildOperation(schema, rootFieldName, options) {
+  const maxDepth = options?.maxDepth ?? 2;
+  const includeDeprecated = options?.includeDeprecated ?? false;
+  let operationType = "query";
+  let rootField;
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    rootField = queryType.fields.find((f) => f.name === rootFieldName);
+  }
+  if (!rootField && schema.mutationType) {
+    const mutationType = schema.types.get(schema.mutationType);
+    if (mutationType) {
+      rootField = mutationType.fields.find((f) => f.name === rootFieldName);
+      if (rootField) {
+        operationType = "mutation";
+      }
+    }
+  }
+  if (!rootField) {
+    throw new Error(`Field "${rootFieldName}" not found in schema query or mutation types`);
+  }
+  const operationName = `${capitalize(rootFieldName)}${capitalize(operationType)}`;
+  const variables = rootField.args.map((arg) => ({
+    name: arg.name,
+    type: typeRefToString(arg.type),
+    required: isRequired(arg.type),
+    description: arg.description
+  }));
+  const varDefs = variables.length > 0 ? `(${variables.map((v) => `$${v.name}: ${v.type}`).join(", ")})` : "";
+  const argsPassing = rootField.args.length > 0 ? `(${rootField.args.map((a) => `${a.name}: $${a.name}`).join(", ")})` : "";
+  const unwrapped = unwrapType(rootField.type);
+  let selectionSet = "";
+  if (!isScalarLike(schema, rootField) && unwrapped.name) {
+    selectionSet = ` ${buildSelectionSet(
+      schema,
+      unwrapped.name,
+      0,
+      maxDepth,
+      /* @__PURE__ */ new Set(),
+      includeDeprecated,
+      1
+    )}`;
+  }
+  const operation = `${operationType} ${operationName}${varDefs} {
+  ${rootFieldName}${argsPassing}${selectionSet}
+}`;
+  return {
+    operation,
+    operationName,
+    variables,
+    operationType
+  };
+}
+
+// src/mcp/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_zod2 = require("zod");
+
+// src/mcp/executor.ts
+var import_graphql_request2 = require("graphql-request");
+var GraphQLExecutor = class {
+  client;
+  constructor(endpoint, headers) {
+    this.client = new import_graphql_request2.GraphQLClient(endpoint, { headers });
+  }
+  async execute(operation, variables, additionalHeaders) {
+    try {
+      const result = await this.client.request(operation, variables, additionalHeaders);
+      return JSON.stringify(result, null, 2);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`GraphQL execution failed: ${error.message}`);
+      }
+      throw new Error("GraphQL execution failed: Unknown error");
+    }
+  }
+};
+
+// src/mcp/tool-factory.ts
+var import_zod = require("zod");
+function typeRefToZod(typeRef, schema) {
+  if (typeRef.kind === "NON_NULL") {
+    if (!typeRef.ofType) return import_zod.z.unknown();
+    return typeRefToZod(typeRef.ofType, schema);
+  }
+  if (typeRef.kind === "LIST") {
+    if (!typeRef.ofType) return import_zod.z.array(import_zod.z.unknown());
+    return import_zod.z.array(typeRefToZod(typeRef.ofType, schema)).optional();
+  }
+  const unwrapped = unwrapType(typeRef);
+  const typeName = unwrapped.name;
+  if (typeName) {
+    const namedType = schema.types.get(typeName);
+    if (namedType && namedType.kind === "ENUM" && namedType.enumValues.length > 0) {
+      const values = namedType.enumValues.map((v) => v.name);
+      return import_zod.z.enum(values).optional();
+    }
+    if (namedType && namedType.kind === "INPUT_OBJECT") {
+      const shape = {};
+      for (const field of namedType.inputFields) {
+        const fieldSchema = typeRefToZod(field.type, schema);
+        if (field.type.kind === "NON_NULL") {
+          shape[field.name] = fieldSchema;
+        } else {
+          shape[field.name] = fieldSchema.optional();
+        }
+      }
+      return import_zod.z.object(shape);
+    }
+  }
+  switch (typeName) {
+    case "String":
+      return import_zod.z.string().optional();
+    case "Int":
+      return import_zod.z.number().int().optional();
+    case "Float":
+      return import_zod.z.number().optional();
+    case "Boolean":
+      return import_zod.z.boolean().optional();
+    case "ID":
+      return import_zod.z.string().optional();
+    default:
+      return import_zod.z.unknown().optional();
+  }
+}
+function buildInputSchema(field, schema) {
+  const shape = {};
+  for (const arg of field.args) {
+    const zodType = typeRefToZod(arg.type, schema);
+    if (arg.type.kind === "NON_NULL") {
+      shape[arg.name] = zodType;
+    } else {
+      shape[arg.name] = zodType.optional();
+    }
+  }
+  return shape;
+}
+function createToolsFromSchema(schema, executor, options) {
+  const maxDepth = options?.maxDepth ?? 2;
+  const includeDeprecated = options?.includeDeprecated ?? false;
+  const tools = [];
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    for (const field of queryType.fields) {
+      if (field.isDeprecated && !includeDeprecated) continue;
+      const toolName = `query_${field.name}`;
+      const description = field.description || `Query ${field.name}`;
+      const inputSchema = buildInputSchema(field, schema);
+      tools.push({
+        name: toolName,
+        description,
+        inputSchema,
+        execute: async (args) => {
+          const op = buildOperation(schema, field.name, { maxDepth, includeDeprecated });
+          return executor.execute(op.operation, args);
+        }
+      });
+    }
+  }
+  if (schema.mutationType) {
+    const mutationType = schema.types.get(schema.mutationType);
+    if (mutationType) {
+      for (const field of mutationType.fields) {
+        if (field.isDeprecated && !includeDeprecated) continue;
+        const toolName = `mutate_${field.name}`;
+        const description = field.description || `Mutation ${field.name}`;
+        const inputSchema = buildInputSchema(field, schema);
+        tools.push({
+          name: toolName,
+          description,
+          inputSchema,
+          execute: async (args) => {
+            const op = buildOperation(schema, field.name, { maxDepth, includeDeprecated });
+            return executor.execute(op.operation, args);
+          }
+        });
+      }
+    }
+  }
+  return tools;
+}
+
+// src/mcp/server.ts
+var packageVersion = "1.0.0";
+async function createAgentToolkitServer(config, options) {
+  const serverName = options?.serverName ?? "graphql-agent-toolkit";
+  const serverVersion = options?.serverVersion ?? packageVersion;
+  const introspectionResult = await fetchSchema({
+    endpoint: config.endpoint,
+    headers: config.headers
+  });
+  const schema = parseSchema(introspectionResult);
+  const executor = new GraphQLExecutor(config.endpoint, config.headers);
+  const tools = createToolsFromSchema(schema, executor, {
+    maxDepth: config.operationDepth ?? 2,
+    includeDeprecated: config.includeDeprecated ?? false
+  });
+  const server = new import_mcp.McpServer({
+    name: serverName,
+    version: serverVersion
+  });
+  for (const tool of tools) {
+    const inputSchema = Object.keys(tool.inputSchema).length > 0 ? tool.inputSchema : void 0;
+    if (inputSchema) {
+      server.tool(
+        tool.name,
+        tool.description,
+        inputSchema,
+        async (args) => {
+          try {
+            const result = await tool.execute(args);
+            return {
+              content: [{ type: "text", text: result }]
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            return {
+              content: [{ type: "text", text: `Error: ${message}` }],
+              isError: true
+            };
+          }
+        }
+      );
+    } else {
+      server.tool(
+        tool.name,
+        tool.description,
+        async () => {
+          try {
+            const result = await tool.execute({});
+            return {
+              content: [{ type: "text", text: result }]
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            return {
+              content: [{ type: "text", text: `Error: ${message}` }],
+              isError: true
+            };
+          }
+        }
+      );
+    }
+  }
+  server.tool(
+    "explore_schema",
+    "Explore the GraphQL schema \u2014 list types, fields, and arguments",
+    {
+      typeName: import_zod2.z.string().optional().describe("Type name to explore. If omitted, lists all types.")
+    },
+    async (args) => {
+      if (args.typeName) {
+        const type = schema.types.get(args.typeName);
+        if (!type) {
+          return {
+            content: [{ type: "text", text: `Type "${args.typeName}" not found.` }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(type, null, 2) }]
+        };
+      }
+      const typeList = Array.from(schema.types.values()).filter((t) => !["SCALAR"].includes(t.kind)).map((t) => `${t.kind} ${t.name}${t.description ? ` \u2014 ${t.description}` : ""}`);
+      return {
+        content: [{ type: "text", text: typeList.join("\n") }]
+      };
+    }
+  );
+  return server;
+}
+
+// src/semantic/tokenizer.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "dare",
+  "ought",
+  "used",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "not",
+  "so",
+  "yet",
+  "both",
+  "either",
+  "neither",
+  "each",
+  "every",
+  "all",
+  "any",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "only",
+  "own",
+  "same",
+  "than",
+  "too",
+  "very",
+  "just",
+  "because",
+  "if",
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "they",
+  "them",
+  "their",
+  "what",
+  "which",
+  "who",
+  "whom"
+]);
+function tokenize(text) {
+  if (!text) return [];
+  const split = text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").toLowerCase().trim().split(/\s+/).filter((word) => word.length > 0);
+  return split.filter((word) => !STOP_WORDS.has(word));
+}
+
+// src/semantic/navigator.ts
+var SchemaNavigator = class {
+  schema = null;
+  documents = [];
+  idf = /* @__PURE__ */ new Map();
+  /**
+   * Index a parsed schema for semantic search.
+   */
+  index(schema) {
+    this.schema = schema;
+    this.documents = [];
+    for (const [typeName, type] of schema.types) {
+      if (type.kind === "SCALAR") continue;
+      const textParts = [typeName];
+      if (type.description) {
+        textParts.push(type.description);
+      }
+      for (const field of type.fields) {
+        textParts.push(field.name);
+        if (field.description) {
+          textParts.push(field.description);
+        }
+      }
+      for (const field of type.inputFields) {
+        textParts.push(field.name);
+        if (field.description) {
+          textParts.push(field.description);
+        }
+      }
+      for (const ev of type.enumValues) {
+        textParts.push(ev.name);
+        if (ev.description) {
+          textParts.push(ev.description);
+        }
+      }
+      const tokens = tokenize(textParts.join(" "));
+      this.documents.push({ typeName, tokens, tfidf: /* @__PURE__ */ new Map() });
+    }
+    this.computeIdf();
+    for (const doc of this.documents) {
+      doc.tfidf = this.computeTfidf(doc.tokens);
+    }
+  }
+  /**
+   * Search the schema for types matching the query.
+   */
+  search(query, limit = 5) {
+    if (!this.schema || this.documents.length === 0) {
+      return [];
+    }
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0) {
+      return [];
+    }
+    const queryTfidf = this.computeTfidf(queryTokens);
+    const scored = [];
+    for (const doc of this.documents) {
+      const score = this.cosineSimilarity(queryTfidf, doc.tfidf);
+      if (score > 0) {
+        const type = this.schema.types.get(doc.typeName);
+        scored.push({
+          typeName: doc.typeName,
+          score,
+          kind: type.kind,
+          description: type.description
+        });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit);
+  }
+  /**
+   * Get formatted context for a specific type.
+   */
+  getTypeContext(typeName) {
+    if (!this.schema) return null;
+    const type = this.schema.types.get(typeName);
+    if (!type) return null;
+    const lines = [];
+    lines.push(`${type.kind} ${type.name}`);
+    if (type.description) {
+      lines.push(`  Description: ${type.description}`);
+    }
+    if (type.fields.length > 0) {
+      lines.push("  Fields:");
+      for (const field of type.fields) {
+        const desc = field.description ? ` \u2014 ${field.description}` : "";
+        const args = field.args.length > 0 ? `(${field.args.map((a) => a.name).join(", ")})` : "";
+        lines.push(`    ${field.name}${args}${desc}`);
+      }
+    }
+    if (type.inputFields.length > 0) {
+      lines.push("  Input Fields:");
+      for (const field of type.inputFields) {
+        const desc = field.description ? ` \u2014 ${field.description}` : "";
+        lines.push(`    ${field.name}${desc}`);
+      }
+    }
+    if (type.enumValues.length > 0) {
+      lines.push("  Enum Values:");
+      for (const ev of type.enumValues) {
+        const desc = ev.description ? ` \u2014 ${ev.description}` : "";
+        lines.push(`    ${ev.name}${desc}`);
+      }
+    }
+    if (type.interfaces.length > 0) {
+      lines.push(`  Implements: ${type.interfaces.join(", ")}`);
+    }
+    if (type.possibleTypes.length > 0) {
+      lines.push(`  Possible Types: ${type.possibleTypes.join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+  computeIdf() {
+    const docCount = this.documents.length;
+    const termDocFreq = /* @__PURE__ */ new Map();
+    for (const doc of this.documents) {
+      const uniqueTokens = new Set(doc.tokens);
+      for (const token of uniqueTokens) {
+        termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);
+      }
+    }
+    this.idf = /* @__PURE__ */ new Map();
+    for (const [term, freq] of termDocFreq) {
+      this.idf.set(term, Math.log(1 + docCount / (1 + freq)));
+    }
+  }
+  computeTfidf(tokens) {
+    const tf = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      tf.set(token, (tf.get(token) ?? 0) + 1);
+    }
+    const tfidf = /* @__PURE__ */ new Map();
+    for (const [term, count] of tf) {
+      const idfVal = this.idf.get(term) ?? Math.log(1 + this.documents.length);
+      tfidf.set(term, count / tokens.length * idfVal);
+    }
+    return tfidf;
+  }
+  cosineSimilarity(a, b) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (const [term, val] of a) {
+      normA += val * val;
+      const bVal = b.get(term);
+      if (bVal !== void 0) {
+        dotProduct += val * bVal;
+      }
+    }
+    for (const val of b.values()) {
+      normB += val * val;
+    }
+    if (normA === 0 || normB === 0) return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+};
+
+// src/pagination/handler.ts
+var DEFAULT_PAGE_SIZE = 20;
+var DEFAULT_MAX_PAGES = 10;
+function detectPaginationStyle(schema, typeName) {
+  const type = schema.types.get(typeName);
+  if (!type) return "none";
+  const edgesField = type.fields.find((f) => f.name === "edges");
+  const pageInfoField = type.fields.find((f) => f.name === "pageInfo");
+  if (edgesField && pageInfoField) {
+    const edgesTypeName = unwrapTypeName(edgesField.type);
+    if (edgesTypeName) {
+      const edgesType = schema.types.get(edgesTypeName);
+      if (edgesType) {
+        const hasNode = edgesType.fields.some((f) => f.name === "node");
+        if (hasNode) {
+          const pageInfoTypeName = unwrapTypeName(pageInfoField.type);
+          if (pageInfoTypeName) {
+            const pageInfoType = schema.types.get(pageInfoTypeName);
+            if (pageInfoType) {
+              const hasNextPage = pageInfoType.fields.some((f) => f.name === "hasNextPage");
+              const hasEndCursor = pageInfoType.fields.some((f) => f.name === "endCursor");
+              if (hasNextPage && hasEndCursor) {
+                return "relay";
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    for (const field of queryType.fields) {
+      const returnTypeName = unwrapTypeName(field.type);
+      if (returnTypeName === typeName) {
+        const argNames = field.args.map((a) => a.name);
+        const hasLimitOffset = argNames.includes("limit") && argNames.includes("offset");
+        const hasSkipTake = argNames.includes("skip") && argNames.includes("take");
+        if (hasLimitOffset || hasSkipTake) {
+          return "offset";
+        }
+      }
+    }
+  }
+  return "none";
+}
+async function executePaginated(executor, operation, variables, config) {
+  const style = config?.style ?? "auto";
+  const pageSize = config?.pageSize ?? DEFAULT_PAGE_SIZE;
+  const maxPages = config?.maxPages ?? DEFAULT_MAX_PAGES;
+  if (style === "relay" || style === "auto" && isRelayOperation(operation)) {
+    return executeRelayPaginated(executor, operation, variables, pageSize, maxPages);
+  }
+  if (style === "offset" || style === "auto" && isOffsetOperation(operation)) {
+    return executeOffsetPaginated(executor, operation, variables, pageSize, maxPages);
+  }
+  const resultStr = await executor.execute(operation, variables);
+  const data = JSON.parse(resultStr);
+  const items = extractItems(data);
+  return {
+    items,
+    totalFetched: items.length,
+    hasMore: false
+  };
+}
+function isRelayOperation(operation) {
+  return operation.includes("$after") && operation.includes("$first") && operation.includes("pageInfo");
+}
+function isOffsetOperation(operation) {
+  return operation.includes("$limit") && operation.includes("$offset") || operation.includes("$skip") && operation.includes("$take");
+}
+async function executeRelayPaginated(executor, operation, variables, pageSize, maxPages) {
+  const allItems = [];
+  let cursor = null;
+  let startCursor = null;
+  let hasMore = true;
+  let pageCount = 0;
+  while (hasMore && pageCount < maxPages) {
+    const vars = {
+      ...variables,
+      first: pageSize
+    };
+    if (cursor) {
+      vars.after = cursor;
+    }
+    const resultStr = await executor.execute(operation, vars);
+    const data = JSON.parse(resultStr);
+    const connectionData = findConnectionData(data);
+    if (!connectionData) {
+      break;
+    }
+    const { edges, pageInfo } = connectionData;
+    if (pageCount === 0 && pageInfo.startCursor) {
+      startCursor = pageInfo.startCursor;
+    }
+    for (const edge of edges) {
+      if (edge && typeof edge === "object" && "node" in edge) {
+        allItems.push(edge.node);
+      } else {
+        allItems.push(edge);
+      }
+    }
+    hasMore = pageInfo.hasNextPage ?? false;
+    cursor = pageInfo.endCursor ?? null;
+    pageCount++;
+    if (!hasMore || !cursor) break;
+  }
+  const result = {
+    items: allItems,
+    totalFetched: allItems.length,
+    hasMore
+  };
+  if (startCursor || cursor) {
+    result.cursors = {
+      start: startCursor ?? "",
+      end: cursor ?? ""
+    };
+  }
+  return result;
+}
+async function executeOffsetPaginated(executor, operation, variables, pageSize, maxPages) {
+  const allItems = [];
+  let currentOffset = 0;
+  let hasMore = true;
+  let pageCount = 0;
+  const useSkipTake = operation.includes("$skip") && operation.includes("$take");
+  while (hasMore && pageCount < maxPages) {
+    const vars = { ...variables };
+    if (useSkipTake) {
+      vars.skip = currentOffset;
+      vars.take = pageSize;
+    } else {
+      vars.offset = currentOffset;
+      vars.limit = pageSize;
+    }
+    const resultStr = await executor.execute(operation, vars);
+    const data = JSON.parse(resultStr);
+    const items = extractItems(data);
+    allItems.push(...items);
+    pageCount++;
+    if (items.length < pageSize) {
+      hasMore = false;
+    } else {
+      currentOffset += pageSize;
+    }
+  }
+  return {
+    items: allItems,
+    totalFetched: allItems.length,
+    hasMore
+  };
+}
+function findConnectionData(data) {
+  if (!data || typeof data !== "object") return null;
+  const obj = data;
+  if (Array.isArray(obj.edges) && obj.pageInfo && typeof obj.pageInfo === "object") {
+    return {
+      edges: obj.edges,
+      pageInfo: obj.pageInfo
+    };
+  }
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const found = findConnectionData(value);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function extractItems(data) {
+  if (Array.isArray(data)) return data;
+  if (!data || typeof data !== "object") return [];
+  const obj = data;
+  for (const value of Object.values(obj)) {
+    if (Array.isArray(value)) return value;
+    if (value && typeof value === "object") {
+      const items = extractItems(value);
+      if (items.length > 0) return items;
+    }
+  }
+  return [];
+}
+function unwrapTypeName(typeRef) {
+  if (typeRef.kind === "NON_NULL" || typeRef.kind === "LIST") {
+    if (typeRef.ofType) {
+      return unwrapTypeName(typeRef.ofType);
+    }
+    return null;
+  }
+  return typeRef.name;
+}
+
+// src/summarizer/summarizer.ts
+var DEFAULT_CONFIG = {
+  maxItems: 5,
+  maxDepth: 3,
+  maxStringLength: 200,
+  includeMetadata: true
+};
+function summarizeResponse(data, config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const originalSize = JSON.stringify(data).length;
+  let truncated = false;
+  let totalItems = 0;
+  function countItems(value) {
+    if (Array.isArray(value)) return value.length;
+    if (value && typeof value === "object") {
+      let count = 0;
+      for (const v of Object.values(value)) {
+        if (Array.isArray(v)) count += v.length;
+        else count += countItems(v);
+      }
+      return count;
+    }
+    return 0;
+  }
+  totalItems = countItems(data);
+  function summarize(value, depth) {
+    if (value === null || value === void 0) return value;
+    if (typeof value === "string") {
+      if (value.length > cfg.maxStringLength) {
+        truncated = true;
+        return value.slice(0, cfg.maxStringLength) + "...";
+      }
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      if (depth >= cfg.maxDepth) {
+        truncated = true;
+        return `[...${value.length} items]`;
+      }
+      const items = value.slice(0, cfg.maxItems).map((item) => summarize(item, depth + 1));
+      if (value.length > cfg.maxItems) {
+        truncated = true;
+        if (cfg.includeMetadata) {
+          return Object.assign(items, {
+            _meta: { totalCount: value.length, showing: cfg.maxItems }
+          });
+        }
+      }
+      return items;
+    }
+    if (typeof value === "object") {
+      if (depth >= cfg.maxDepth) {
+        const keys = Object.keys(value);
+        truncated = true;
+        return `{...${keys.length} keys}`;
+      }
+      const result = {};
+      for (const [key, val] of Object.entries(value)) {
+        result[key] = summarize(val, depth + 1);
+      }
+      return result;
+    }
+    return value;
+  }
+  const summary = summarize(data, 0);
+  return {
+    summary,
+    metadata: {
+      totalItems,
+      truncated,
+      originalSize
+    }
+  };
+}
+function formatForLLM(data, config) {
+  const { summary } = summarizeResponse(data, config);
+  return renderMarkdown(summary, 0);
+}
+function renderMarkdown(value, indent) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "(empty list)";
+    const lines = [];
+    const meta = value._meta;
+    for (const item of value) {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const objLines = renderObjectAsBullets(item, indent + 1);
+        lines.push(`${"  ".repeat(indent)}- ${objLines}`);
+      } else {
+        lines.push(`${"  ".repeat(indent)}- ${renderMarkdown(item, indent + 1)}`);
+      }
+    }
+    if (meta) {
+      lines.push(`${"  ".repeat(indent)}- _(${meta.totalCount - meta.showing} more items...)_`);
+    }
+    return lines.join("\n");
+  }
+  if (typeof value === "object") {
+    return renderObjectAsSection(value, indent);
+  }
+  return String(value);
+}
+function renderObjectAsBullets(obj, indent) {
+  const entries = Object.entries(obj).filter(([k]) => k !== "_meta");
+  if (entries.length === 0) return "(empty)";
+  const parts = [];
+  let first = true;
+  for (const [key, value] of entries) {
+    if (typeof value === "object" && value !== null) {
+      if (first) {
+        parts.push(`**${key}**: ${renderMarkdown(value, indent + 1)}`);
+        first = false;
+      } else {
+        parts.push(`${"  ".repeat(indent)}**${key}**: ${renderMarkdown(value, indent + 1)}`);
+      }
+    } else {
+      const rendered = renderMarkdown(value, indent);
+      if (first) {
+        parts.push(`**${key}**: ${rendered}`);
+        first = false;
+      } else {
+        parts.push(`${"  ".repeat(indent)}**${key}**: ${rendered}`);
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function renderObjectAsSection(obj, indent) {
+  const entries = Object.entries(obj).filter(([k]) => k !== "_meta");
+  if (entries.length === 0) return "(empty)";
+  const lines = [];
+  const headerLevel = Math.min(indent + 2, 6);
+  const header = "#".repeat(headerLevel);
+  for (const [key, value] of entries) {
+    if (typeof value === "object" && value !== null) {
+      lines.push(`${header} ${key}`);
+      lines.push(renderMarkdown(value, indent + 1));
+    } else {
+      lines.push(`- **${key}**: ${renderMarkdown(value, indent)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/adapters/langchain.ts
+var import_zod3 = require("zod");
+function typeRefToJsonSchema(typeRef, schema) {
+  if (typeRef.kind === "NON_NULL") {
+    if (!typeRef.ofType) return { type: "string" };
+    return typeRefToJsonSchema(typeRef.ofType, schema);
+  }
+  if (typeRef.kind === "LIST") {
+    if (!typeRef.ofType) return { type: "array", items: {} };
+    return { type: "array", items: typeRefToJsonSchema(typeRef.ofType, schema) };
+  }
+  const unwrapped = unwrapType(typeRef);
+  const typeName = unwrapped.name;
+  if (typeName) {
+    const namedType = schema.types.get(typeName);
+    if (namedType && namedType.kind === "ENUM" && namedType.enumValues.length > 0) {
+      return { type: "string", enum: namedType.enumValues.map((v) => v.name) };
+    }
+    if (namedType && namedType.kind === "INPUT_OBJECT") {
+      const properties = {};
+      const required = [];
+      for (const field of namedType.inputFields) {
+        properties[field.name] = typeRefToJsonSchema(field.type, schema);
+        if (field.type.kind === "NON_NULL") {
+          required.push(field.name);
+        }
+      }
+      const result = { type: "object", properties };
+      if (required.length > 0) result.required = required;
+      return result;
+    }
+  }
+  switch (typeName) {
+    case "String":
+    case "ID":
+      return { type: "string" };
+    case "Int":
+      return { type: "integer" };
+    case "Float":
+      return { type: "number" };
+    case "Boolean":
+      return { type: "boolean" };
+    default:
+      return {};
+  }
+}
+function typeRefToZod2(typeRef, schema) {
+  if (typeRef.kind === "NON_NULL") {
+    if (!typeRef.ofType) return import_zod3.z.unknown();
+    return typeRefToZod2(typeRef.ofType, schema);
+  }
+  if (typeRef.kind === "LIST") {
+    if (!typeRef.ofType) return import_zod3.z.array(import_zod3.z.unknown()).optional();
+    return import_zod3.z.array(typeRefToZod2(typeRef.ofType, schema)).optional();
+  }
+  const unwrapped = unwrapType(typeRef);
+  const typeName = unwrapped.name;
+  if (typeName) {
+    const namedType = schema.types.get(typeName);
+    if (namedType && namedType.kind === "ENUM" && namedType.enumValues.length > 0) {
+      const values = namedType.enumValues.map((v) => v.name);
+      return import_zod3.z.enum(values).optional();
+    }
+    if (namedType && namedType.kind === "INPUT_OBJECT") {
+      const shape = {};
+      for (const field of namedType.inputFields) {
+        const fieldSchema = typeRefToZod2(field.type, schema);
+        if (field.type.kind === "NON_NULL") {
+          shape[field.name] = fieldSchema;
+        } else {
+          shape[field.name] = fieldSchema.optional();
+        }
+      }
+      return import_zod3.z.object(shape);
+    }
+  }
+  switch (typeName) {
+    case "String":
+    case "ID":
+      return import_zod3.z.string().optional();
+    case "Int":
+      return import_zod3.z.number().int().optional();
+    case "Float":
+      return import_zod3.z.number().optional();
+    case "Boolean":
+      return import_zod3.z.boolean().optional();
+    default:
+      return import_zod3.z.unknown().optional();
+  }
+}
+function buildJsonSchema(field, schema) {
+  const properties = {};
+  const required = [];
+  for (const arg of field.args) {
+    properties[arg.name] = typeRefToJsonSchema(arg.type, schema);
+    if (arg.type.kind === "NON_NULL") {
+      required.push(arg.name);
+    }
+  }
+  const result = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) result.required = required;
+  return result;
+}
+function buildZodSchema(field, schema) {
+  const shape = {};
+  for (const arg of field.args) {
+    const zodType = typeRefToZod2(arg.type, schema);
+    if (arg.type.kind === "NON_NULL") {
+      shape[arg.name] = zodType;
+    } else {
+      shape[arg.name] = zodType.optional();
+    }
+  }
+  return import_zod3.z.object(shape);
+}
+function collectRootFields(schema) {
+  const result = [];
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    for (const field of queryType.fields) {
+      result.push({ field, operationType: "query" });
+    }
+  }
+  if (schema.mutationType) {
+    const mutationType = schema.types.get(schema.mutationType);
+    if (mutationType) {
+      for (const field of mutationType.fields) {
+        result.push({ field, operationType: "mutation" });
+      }
+    }
+  }
+  return result;
+}
+function createLangChainTools(schema, executor, options) {
+  const maxDepth = options?.maxDepth ?? 2;
+  const rootFields = collectRootFields(schema);
+  return rootFields.map(({ field, operationType }) => {
+    const toolName = operationType === "query" ? `query_${field.name}` : `mutate_${field.name}`;
+    const description = field.description || `${operationType === "query" ? "Query" : "Mutation"} ${field.name}`;
+    const jsonSchema = buildJsonSchema(field, schema);
+    return {
+      name: toolName,
+      description,
+      schema: jsonSchema,
+      func: async (input) => {
+        const variables = input ? JSON.parse(input) : {};
+        const op = buildOperation(schema, field.name, { maxDepth });
+        return executor.execute(op.operation, variables);
+      }
+    };
+  });
+}
+function createStructuredTools(schema, executor, options) {
+  const maxDepth = options?.maxDepth ?? 2;
+  const rootFields = collectRootFields(schema);
+  return rootFields.map(({ field, operationType }) => {
+    const toolName = operationType === "query" ? `query_${field.name}` : `mutate_${field.name}`;
+    const description = field.description || `${operationType === "query" ? "Query" : "Mutation"} ${field.name}`;
+    const zodSchema = buildZodSchema(field, schema);
+    return {
+      name: toolName,
+      description,
+      schema: zodSchema,
+      func: async (input) => {
+        const op = buildOperation(schema, field.name, { maxDepth });
+        return executor.execute(op.operation, input);
+      }
+    };
+  });
+}
+
+// src/adapters/crewai.ts
+function typeRefToJsonSchema2(typeRef, schema) {
+  if (typeRef.kind === "NON_NULL") {
+    if (!typeRef.ofType) return { type: "string" };
+    return typeRefToJsonSchema2(typeRef.ofType, schema);
+  }
+  if (typeRef.kind === "LIST") {
+    if (!typeRef.ofType) return { type: "array", items: {} };
+    return { type: "array", items: typeRefToJsonSchema2(typeRef.ofType, schema) };
+  }
+  const unwrapped = unwrapType(typeRef);
+  const typeName = unwrapped.name;
+  if (typeName) {
+    const namedType = schema.types.get(typeName);
+    if (namedType && namedType.kind === "ENUM" && namedType.enumValues.length > 0) {
+      return { type: "string", enum: namedType.enumValues.map((v) => v.name) };
+    }
+    if (namedType && namedType.kind === "INPUT_OBJECT") {
+      const properties = {};
+      const required = [];
+      for (const field of namedType.inputFields) {
+        properties[field.name] = typeRefToJsonSchema2(field.type, schema);
+        if (field.type.kind === "NON_NULL") {
+          required.push(field.name);
+        }
+      }
+      const result = { type: "object", properties };
+      if (required.length > 0) result.required = required;
+      return result;
+    }
+  }
+  switch (typeName) {
+    case "String":
+    case "ID":
+      return { type: "string" };
+    case "Int":
+      return { type: "integer" };
+    case "Float":
+      return { type: "number" };
+    case "Boolean":
+      return { type: "boolean" };
+    default:
+      return {};
+  }
+}
+function buildArgsSchema(field, schema) {
+  const properties = {};
+  const required = [];
+  for (const arg of field.args) {
+    properties[arg.name] = typeRefToJsonSchema2(arg.type, schema);
+    if (arg.type.kind === "NON_NULL") {
+      required.push(arg.name);
+    }
+  }
+  const result = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) result.required = required;
+  return result;
+}
+function createCrewAITools(schema, executor, options) {
+  const maxDepth = options?.maxDepth ?? 2;
+  const tools = [];
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    for (const field of queryType.fields) {
+      const toolName = `query_${field.name}`;
+      const description = field.description || `Query ${field.name}`;
+      const argsSchema = buildArgsSchema(field, schema);
+      tools.push({
+        name: toolName,
+        description,
+        args_schema: argsSchema,
+        func: async (args) => {
+          const op = buildOperation(schema, field.name, { maxDepth });
+          return executor.execute(op.operation, args);
+        }
+      });
+    }
+  }
+  if (schema.mutationType) {
+    const mutationType = schema.types.get(schema.mutationType);
+    if (mutationType) {
+      for (const field of mutationType.fields) {
+        const toolName = `mutate_${field.name}`;
+        const description = field.description || `Mutation ${field.name}`;
+        const argsSchema = buildArgsSchema(field, schema);
+        tools.push({
+          name: toolName,
+          description,
+          args_schema: argsSchema,
+          func: async (args) => {
+            const op = buildOperation(schema, field.name, { maxDepth });
+            return executor.execute(op.operation, args);
+          }
+        });
+      }
+    }
+  }
+  return tools;
+}
+
+// src/adapters/vercel-ai.ts
+var import_zod4 = require("zod");
+function typeRefToZod3(typeRef, schema) {
+  if (typeRef.kind === "NON_NULL") {
+    if (!typeRef.ofType) return import_zod4.z.unknown();
+    return typeRefToZod3(typeRef.ofType, schema);
+  }
+  if (typeRef.kind === "LIST") {
+    if (!typeRef.ofType) return import_zod4.z.array(import_zod4.z.unknown()).optional();
+    return import_zod4.z.array(typeRefToZod3(typeRef.ofType, schema)).optional();
+  }
+  const unwrapped = unwrapType(typeRef);
+  const typeName = unwrapped.name;
+  if (typeName) {
+    const namedType = schema.types.get(typeName);
+    if (namedType && namedType.kind === "ENUM" && namedType.enumValues.length > 0) {
+      const values = namedType.enumValues.map((v) => v.name);
+      return import_zod4.z.enum(values).optional();
+    }
+    if (namedType && namedType.kind === "INPUT_OBJECT") {
+      const shape = {};
+      for (const field of namedType.inputFields) {
+        const fieldSchema = typeRefToZod3(field.type, schema);
+        if (field.type.kind === "NON_NULL") {
+          shape[field.name] = fieldSchema;
+        } else {
+          shape[field.name] = fieldSchema.optional();
+        }
+      }
+      return import_zod4.z.object(shape);
+    }
+  }
+  switch (typeName) {
+    case "String":
+    case "ID":
+      return import_zod4.z.string().optional();
+    case "Int":
+      return import_zod4.z.number().int().optional();
+    case "Float":
+      return import_zod4.z.number().optional();
+    case "Boolean":
+      return import_zod4.z.boolean().optional();
+    default:
+      return import_zod4.z.unknown().optional();
+  }
+}
+function buildParametersSchema(field, schema) {
+  const shape = {};
+  for (const arg of field.args) {
+    const zodType = typeRefToZod3(arg.type, schema);
+    if (arg.type.kind === "NON_NULL") {
+      shape[arg.name] = zodType;
+    } else {
+      shape[arg.name] = zodType.optional();
+    }
+  }
+  return import_zod4.z.object(shape);
+}
+function createVercelAITools(schema, executor, options) {
+  const maxDepth = options?.maxDepth ?? 2;
+  const tools = {};
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    for (const field of queryType.fields) {
+      const toolName = `query_${field.name}`;
+      const description = field.description || `Query ${field.name}`;
+      const parameters = buildParametersSchema(field, schema);
+      tools[toolName] = {
+        description,
+        parameters,
+        execute: async (args) => {
+          const op = buildOperation(schema, field.name, { maxDepth });
+          return executor.execute(op.operation, args);
+        }
+      };
+    }
+  }
+  if (schema.mutationType) {
+    const mutationType = schema.types.get(schema.mutationType);
+    if (mutationType) {
+      for (const field of mutationType.fields) {
+        const toolName = `mutate_${field.name}`;
+        const description = field.description || `Mutation ${field.name}`;
+        const parameters = buildParametersSchema(field, schema);
+        tools[toolName] = {
+          description,
+          parameters,
+          execute: async (args) => {
+            const op = buildOperation(schema, field.name, { maxDepth });
+            return executor.execute(op.operation, args);
+          }
+        };
+      }
+    }
+  }
+  return tools;
+}
+
+// src/mock/generator.ts
+var DEFAULT_ARRAY_LENGTH = 3;
+var DEFAULT_MAX_DEPTH = 3;
+function hashString(str, seed = 0) {
+  let hash = seed;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char | 0;
+  }
+  return Math.abs(hash);
+}
+function parseMockDirective(description) {
+  if (!description) return void 0;
+  const match = description.match(/@mock\(([^)]+)\)/);
+  if (!match) return void 0;
+  const raw = match[1].trim();
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!isNaN(num)) return num;
+  return raw;
+}
+function generateScalar(typeName, fieldName, index, seed) {
+  const hash = hashString(fieldName, seed);
+  switch (typeName) {
+    case "String":
+      return `mock_${fieldName}`;
+    case "Int":
+      return hash % 1e3 + index;
+    case "Float":
+      return parseFloat((hash % 1e4 / 100 + index * 0.1).toFixed(2));
+    case "Boolean":
+      return index % 2 === 0;
+    case "ID":
+      return `id_${fieldName}_${index}`;
+    default:
+      return `mock_${typeName}_${fieldName}`;
+  }
+}
+function generateMockData(schema, typeName, config) {
+  const seed = config?.seed ?? 0;
+  const arrayLength = config?.arrayLength ?? DEFAULT_ARRAY_LENGTH;
+  const maxDepth = config?.maxDepth ?? DEFAULT_MAX_DEPTH;
+  return generateForType(schema, typeName, 0, maxDepth, arrayLength, seed, 0, /* @__PURE__ */ new Set());
+}
+function generateForType(schema, typeName, depth, maxDepth, arrayLength, seed, index, visited) {
+  const type = schema.types.get(typeName);
+  if (!type || type.fields.length === 0) {
+    return {};
+  }
+  const result = {};
+  for (const field of type.fields) {
+    const mockValue = parseMockDirective(field.description);
+    if (mockValue !== void 0) {
+      result[field.name] = mockValue;
+      continue;
+    }
+    result[field.name] = generateForField(
+      schema,
+      field,
+      depth,
+      maxDepth,
+      arrayLength,
+      seed,
+      index,
+      visited
+    );
+  }
+  return result;
+}
+function generateForField(schema, field, depth, maxDepth, arrayLength, seed, index, visited) {
+  return generateForTypeRef(
+    schema,
+    field.type,
+    field.name,
+    depth,
+    maxDepth,
+    arrayLength,
+    seed,
+    index,
+    visited
+  );
+}
+function generateForTypeRef(schema, typeRef, fieldName, depth, maxDepth, arrayLength, seed, index, visited) {
+  if (typeRef.kind === "NON_NULL") {
+    if (!typeRef.ofType) return null;
+    return generateForTypeRef(
+      schema,
+      typeRef.ofType,
+      fieldName,
+      depth,
+      maxDepth,
+      arrayLength,
+      seed,
+      index,
+      visited
+    );
+  }
+  if (typeRef.kind === "LIST") {
+    if (!typeRef.ofType) return [];
+    if (depth >= maxDepth) return [];
+    const items = [];
+    for (let i = 0; i < arrayLength; i++) {
+      items.push(
+        generateForTypeRef(
+          schema,
+          typeRef.ofType,
+          fieldName,
+          depth,
+          maxDepth,
+          arrayLength,
+          seed,
+          i,
+          new Set(visited)
+        )
+      );
+    }
+    return items;
+  }
+  const unwrapped = unwrapType(typeRef);
+  const resolvedTypeName = unwrapped.name;
+  if (!resolvedTypeName) return null;
+  const namedType = schema.types.get(resolvedTypeName);
+  if (namedType && namedType.kind === "ENUM" && namedType.enumValues.length > 0) {
+    return namedType.enumValues[0].name;
+  }
+  if (unwrapped.kind === "SCALAR" || namedType && namedType.kind === "SCALAR") {
+    return generateScalar(resolvedTypeName, fieldName, index, seed);
+  }
+  if (depth >= maxDepth) {
+    return null;
+  }
+  if (visited.has(resolvedTypeName)) {
+    return null;
+  }
+  visited.add(resolvedTypeName);
+  const result = generateForType(
+    schema,
+    resolvedTypeName,
+    depth + 1,
+    maxDepth,
+    arrayLength,
+    seed,
+    index,
+    new Set(visited)
+  );
+  visited.delete(resolvedTypeName);
+  return result;
+}
+function createMockExecutor(schema, config) {
+  const mockExecutor = Object.create(GraphQLExecutor.prototype);
+  mockExecutor.execute = async (operation, _variables, _additionalHeaders) => {
+    const rootFieldName = extractRootFieldName(operation);
+    if (!rootFieldName) {
+      return JSON.stringify({ data: null });
+    }
+    const returnTypeName = findReturnTypeName(schema, rootFieldName);
+    if (!returnTypeName) {
+      return JSON.stringify({ data: { [rootFieldName]: null } });
+    }
+    const returnType = schema.types.get(returnTypeName);
+    if (!returnType || returnType.kind === "SCALAR") {
+      const scalarValue = generateScalar(returnTypeName, rootFieldName, 0, config?.seed ?? 0);
+      return JSON.stringify({ data: { [rootFieldName]: scalarValue } }, null, 2);
+    }
+    const isList = isListField(schema, rootFieldName);
+    if (isList) {
+      const arrayLength = config?.arrayLength ?? DEFAULT_ARRAY_LENGTH;
+      const items = [];
+      for (let i = 0; i < arrayLength; i++) {
+        items.push(generateMockData(schema, returnTypeName, { ...config, seed: (config?.seed ?? 0) + i }));
+      }
+      return JSON.stringify({ data: { [rootFieldName]: items } }, null, 2);
+    }
+    const mockData = generateMockData(schema, returnTypeName, config);
+    return JSON.stringify({ data: { [rootFieldName]: mockData } }, null, 2);
+  };
+  return mockExecutor;
+}
+function extractRootFieldName(operation) {
+  const match = operation.match(/(?:query|mutation|subscription)\s+\w*[^{]*\{\s*(\w+)/);
+  if (match) return match[1];
+  const simpleMatch = operation.match(/\{\s*(\w+)/);
+  return simpleMatch ? simpleMatch[1] : null;
+}
+function findReturnTypeName(schema, fieldName) {
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    const field = queryType.fields.find((f) => f.name === fieldName);
+    if (field) {
+      const unwrapped = unwrapType(field.type);
+      return unwrapped.name;
+    }
+  }
+  if (schema.mutationType) {
+    const mutationType = schema.types.get(schema.mutationType);
+    if (mutationType) {
+      const field = mutationType.fields.find((f) => f.name === fieldName);
+      if (field) {
+        const unwrapped = unwrapType(field.type);
+        return unwrapped.name;
+      }
+    }
+  }
+  return null;
+}
+function isListField(schema, fieldName) {
+  const queryType = schema.types.get(schema.queryType);
+  if (queryType) {
+    const field = queryType.fields.find((f) => f.name === fieldName);
+    if (field) return isListTypeRef(field.type);
+  }
+  if (schema.mutationType) {
+    const mutationType = schema.types.get(schema.mutationType);
+    if (mutationType) {
+      const field = mutationType.fields.find((f) => f.name === fieldName);
+      if (field) return isListTypeRef(field.type);
+    }
+  }
+  return false;
+}
+function isListTypeRef(typeRef) {
+  if (typeRef.kind === "LIST") return true;
+  if (typeRef.kind === "NON_NULL" && typeRef.ofType) return isListTypeRef(typeRef.ofType);
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GraphQLExecutor,
+  SchemaNavigator,
+  buildOperation,
+  createAgentToolkitServer,
+  createCrewAITools,
+  createLangChainTools,
+  createMockExecutor,
+  createStructuredTools,
+  createToolsFromSchema,
+  createVercelAITools,
+  detectPaginationStyle,
+  executePaginated,
+  fetchSchema,
+  formatForLLM,
+  generateMockData,
+  parseSchema,
+  summarizeResponse
+});
+//# sourceMappingURL=index.cjs.map