anyapi-mcp-server 1.8.1 → 2.0.1

package/README.md

@@ -117,7 +117,8 @@ mutation { post_endpoint(input: { name: "example" }) { id } }
 ```
 
 Key parameters:
-- **`maxTokens`** — token budget for the response (default 4000). Arrays are truncated to fit.
+- **`maxTokens`** — token budget for the response. Arrays are truncated to fit. Without this or `unlimited`, responses over ~10k tokens are rejected.
+- **`unlimited`** — set to `true` to return the full response with no token budget enforcement.
 - **`dataKey`** — reuse cached data from a previous `call_api` or `query_api` response.
 - **`jsonFilter`** — dot-path to extract nested values after the GraphQL query (e.g. `"data[].attributes.name"`).
 - **`bodyFile`** — absolute path to a JSON file to use as request body (mutually exclusive with `body`). Use for large payloads that can't be sent inline.
@@ -182,7 +183,7 @@ OpenAPI/Postman spec
 - **Mutation support** — write operations get typed GraphQL mutations from OpenAPI body schemas
 - **Smart suggestions** — `call_api` returns ready-to-use queries based on the inferred schema
 - **Response caching** — filesystem-based cache with 5-min TTL; `dataKey` tokens let `query_api` reuse data with zero HTTP calls
-- **Token budget** — `query_api` accepts `maxTokens` (default 4000) and truncates array results to fit via binary search
+- **Token budget** — `query_api` enforces a ~10k token safety limit by default; use `maxTokens` to truncate the deepest largest array to fit, or `unlimited: true` for full responses
 - **Per-field token costs** — `call_api` returns a `fieldTokenCosts` tree so the LLM can make informed field selections
 - **Rate limit tracking** — parses `X-RateLimit-*` headers and warns when limits are nearly exhausted
 - **Pagination detection** — auto-detects cursor, next-page-token, and link-based pagination patterns in responses

package/build/data-cache.js

@@ -54,12 +54,14 @@ export function cleanupExpired() {
 }
 export function storeResponse(method, path, data, responseHeaders) {
     const dataKey = randomBytes(4).toString("hex");
+    const now = Date.now();
     const entry = {
         method,
         path,
         data,
         responseHeaders,
-        expiresAt: Date.now() + TTL_MS,
+        storedAt: now,
+        expiresAt: now + TTL_MS,
     };
     try {
         ensureDir();
@@ -68,6 +70,7 @@ export function storeResponse(method, path, data, responseHeaders) {
     }
     catch (err) {
         process.stderr.write(`data-cache: failed to store ${dataKey}: ${err}\n`);
+        return undefined;
     }
     return dataKey;
 }
@@ -88,6 +91,7 @@ export function loadResponse(dataKey) {
             path: entry.path,
             data: entry.data,
             responseHeaders: entry.responseHeaders,
+            storedAt: entry.storedAt ?? (entry.expiresAt - TTL_MS),
         };
     }
     catch {

package/build/error-context.js

@@ -134,7 +134,7 @@ function getSuggestion(status, endpoint) {
             if (status >= 500) {
                 return "Server error. This is likely a temporary issue with the API. Try again later.";
             }
-            return "Check the API documentation for this endpoint using explain_api.";
+            return "Check the API documentation for this endpoint using inspect_api.";
     }
 }
 const MAX_RAW_BODY = 500;

package/build/graphql-schema.js

@@ -140,8 +140,8 @@ function dynamicArrayLimit(arr) {
         }
         costPerItem = totalCost / sampleCount;
     }
-    const TOKEN_BUDGET = 200;
-    const MIN_ITEMS = 3;
+    const TOKEN_BUDGET = 500;
+    const MIN_ITEMS = 10;
     return Math.max(MIN_ITEMS, Math.min(MAX_ARRAY_LIMIT, Math.floor(TOKEN_BUDGET / costPerItem)));
 }
 const MAX_INFER_DEPTH = 8;
@@ -428,6 +428,8 @@ function inferType(value, typeName, typeRegistry, conflicts, depth = 0) {
         });
         typeRegistry.set(typeName, placeholder);
         const usedNames = new Set();
+        // Pre-compute all sanitized names to detect collisions with synthetic _count fields
+        const allSanitizedNames = new Set(entries.map(([k]) => sanitizeFieldName(k)));
         const fieldConfigs = {};
         for (const [originalKey, fieldValue] of entries) {
             let sanitized = sanitizeFieldName(originalKey);
@@ -463,13 +465,28 @@ function inferType(value, typeName, typeRegistry, conflicts, depth = 0) {
                         limit: { type: GraphQLInt, defaultValue: arrDefault },
                         offset: { type: GraphQLInt, defaultValue: 0 },
                     },
-                    resolve: (source, args) => {
+                    resolve: (source, args, ctx) => {
                         const val = source[key];
                         if (!Array.isArray(val))
                             return val;
+                        if (ctx?.unlimited)
+                            return val;
                         return val.slice(args.offset, args.offset + args.limit);
                     },
                 };
+                // Add _count sibling so truncation is visible (skip if source data already has this field name)
+                const countFieldName = `${sanitized}_count`;
+                if (!allSanitizedNames.has(countFieldName)) {
+                    usedNames.add(countFieldName);
+                    fieldConfigs[countFieldName] = {
+                        type: GraphQLInt,
+                        description: `Total count of ${sanitized} (before any limit/offset truncation)`,
+                        resolve: (source) => {
+                            const val = source[key];
+                            return Array.isArray(val) ? val.length : null;
+                        },
+                    };
+                }
             }
             else {
                 fieldConfigs[sanitized] = {
@@ -602,10 +619,12 @@ export function buildSchemaFromData(data, method, pathTemplate, requestBodySchem
                         limit: { type: GraphQLInt, defaultValue: topLimit },
                         offset: { type: GraphQLInt, defaultValue: 0 },
                     },
-                    resolve: (source, args) => {
+                    resolve: (source, args, ctx) => {
                         const arr = source;
                         if (!Array.isArray(arr))
                             return arr;
+                        if (ctx?.unlimited)
+                            return arr;
                         return arr.slice(args.offset, args.offset + args.limit);
                     },
                 },
@@ -753,12 +772,48 @@ export function collectJsonFields(schema) {
     walk(queryType, "");
     return jsonFields;
 }
+/**
+ * Walk response data and collect actual array lengths for each array field.
+ * Returns a map of sanitized dotted paths to their lengths.
+ * Used by inspect_api to give the AI visibility into true array sizes.
+ */
+export function collectArrayLengths(data, depth = 0, prefix = "") {
+    if (depth >= MAX_INFER_DEPTH || data === null || data === undefined)
+        return {};
+    const result = {};
+    if (Array.isArray(data)) {
+        if (prefix)
+            result[prefix] = data.length;
+        // Recurse into first element to discover nested arrays
+        if (data.length > 0 && typeof data[0] === "object" && data[0] !== null && !Array.isArray(data[0])) {
+            Object.assign(result, collectArrayLengths(data[0], depth + 1, prefix));
+        }
+        return result;
+    }
+    if (typeof data === "object") {
+        for (const [key, value] of Object.entries(data)) {
+            const sanitized = sanitizeFieldName(key);
+            const path = prefix ? `${prefix}.${sanitized}` : sanitized;
+            if (Array.isArray(value)) {
+                result[path] = value.length;
+                // Recurse into first element for nested arrays
+                if (value.length > 0 && typeof value[0] === "object" && value[0] !== null && !Array.isArray(value[0])) {
+                    Object.assign(result, collectArrayLengths(value[0], depth + 1, path));
+                }
+            }
+            else if (typeof value === "object" && value !== null) {
+                Object.assign(result, collectArrayLengths(value, depth + 1, path));
+            }
+        }
+    }
+    return result;
+}
 /**
  * Execute a GraphQL selection query against JSON data using a schema.
  * The query should be a selection set like `{ id name collection { id } }`.
  * Also supports mutation syntax: `mutation { ... }`.
  */
-export async function executeQuery(schema, data, query) {
+export async function executeQuery(schema, data, query, context) {
     const trimmed = query.trim();
     const fullQuery = trimmed.startsWith("query") || trimmed.startsWith("mutation") || trimmed.startsWith("{")
         ? trimmed
@@ -769,7 +824,7 @@ export async function executeQuery(schema, data, query) {
         const messages = validationErrors.map((e) => e.message).join("; ");
         throw new Error(`GraphQL query error: ${messages}`);
     }
-    const result = await execute({ schema, document, rootValue: data });
+    const result = await execute({ schema, document, rootValue: data, contextValue: context });
     if (result.errors && result.errors.length > 0) {
         const messages = result.errors.map((e) => e.message).join("; ");
         throw new Error(`GraphQL query error: ${messages}`);