magicpod-mcp-server 0.1.5 → 0.1.6

package/build/openapi-mcp-server/mcp/proxy.js

@@ -12,7 +12,7 @@ export class MCPProxy {
     openApiLookup;
     constructor(name, openApiSpec, apiToken, otherTools) {
         this.otherTools = otherTools;
-        this.server = new Server({ name, version: "0.1.5" }, { capabilities: { tools: {} } });
+        this.server = new Server({ name, version: "0.1.6" }, { capabilities: { tools: {} } });
         const baseUrl = openApiSpec.servers?.[0].url;
         if (!baseUrl) {
             throw new Error("No base URL found in OpenAPI spec");
@@ -48,30 +48,6 @@ export class MCPProxy {
             }
         }
     }
-    collectRefs(obj) {
-        const refs = [];
-        if (Array.isArray(obj)) {
-            for (const childRefs of obj.map(this.collectRefs)) {
-                for (const childRef of childRefs) {
-                    refs.push(childRef);
-                }
-            }
-        }
-        else if (obj && typeof obj === "object") {
-            for (const key in obj) {
-                if (key === "$ref") {
-                    // @ts-ignore
-                    const ref = obj[key];
-                    refs.push(ref.replaceAll("#/$defs/", ""));
-                }
-                else {
-                    // @ts-ignore
-                    this.collectRefs(obj[key]).forEach(refs.push);
-                }
-            }
-        }
-        return refs;
-    }
     setupHandlers() {
         // Handle tool listing
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -85,24 +61,6 @@ export class MCPProxy {
                     // TODO description is actually required
                     const inputSchema = JSON.parse(JSON.stringify(method.inputSchema));
                     this.removeDescriptions(inputSchema);
-                    // 95% of the response size is consumed by $defs
-                    const body = method.inputSchema.properties?.body;
-                    if (body == null || typeof body === "boolean") {
-                        delete inputSchema["$defs"];
-                    }
-                    else {
-                        const refs = this.collectRefs(body);
-                        if (refs.length === 0) {
-                            delete inputSchema["$defs"];
-                        }
-                        else if (inputSchema["$defs"]) {
-                            for (const def of Object.keys(inputSchema["$defs"])) {
-                                if (!refs.includes(def)) {
-                                    delete inputSchema["$defs"][def];
-                                }
-                            }
-                        }
-                    }
                     tools.push({
                         name: truncatedToolName,
                         description: method.description,

package/build/openapi-mcp-server/openapi/parser.js

@@ -26,6 +26,100 @@ export class OpenAPIToMCPConverter {
         resolvedRefs.add(ref);
         return current;
     }
+    /**
+     * Inline all $ref references in a schema by replacing them with their actual definitions.
+     * Handles circular references by detecting cycles and breaking them with simplified schemas.
+     */
+    inlineAllRefs(schema, resolutionStack = new Set(), inlinedCache = new Map()) {
+        if (!schema || typeof schema !== "object") {
+            return schema;
+        }
+        // Handle $ref references
+        if ("$ref" in schema && typeof schema.$ref === "string") {
+            const ref = schema.$ref;
+            // Check for circular reference
+            if (resolutionStack.has(ref)) {
+                console.warn(`Circular reference detected for ${ref}, using simplified schema`);
+                return {
+                    type: "object",
+                    description: `Circular reference to ${ref}`,
+                    additionalProperties: true
+                };
+            }
+            // Check cache first
+            if (inlinedCache.has(ref)) {
+                return inlinedCache.get(ref);
+            }
+            // Convert #/$defs/ references back to #/components/schemas/ for resolution
+            let resolveRef = ref;
+            if (ref.startsWith("#/$defs/")) {
+                resolveRef = ref.replace(/^#\/\$defs\//, "#/components/schemas/");
+            }
+            // Resolve the reference
+            const resolved = this.internalResolveRef(resolveRef, new Set());
+            if (!resolved) {
+                console.error(`Failed to resolve reference ${ref} (tried as ${resolveRef})`);
+                return {
+                    type: "object",
+                    description: `Unresolved reference: ${ref}`,
+                    additionalProperties: true
+                };
+            }
+            // Convert and inline recursively
+            resolutionStack.add(ref);
+            const convertedResolved = this.convertOpenApiSchemaToJsonSchema(resolved, new Set(), true);
+            const inlinedResolved = this.inlineAllRefs(convertedResolved, resolutionStack, inlinedCache);
+            resolutionStack.delete(ref);
+            // Preserve description from the original $ref if it exists
+            if (schema.description && !inlinedResolved.description) {
+                inlinedResolved.description = schema.description;
+            }
+            // Cache the result
+            inlinedCache.set(ref, inlinedResolved);
+            return inlinedResolved;
+        }
+        // Handle arrays
+        if (schema.type === "array" && schema.items) {
+            return {
+                ...schema,
+                items: this.inlineAllRefs(schema.items, resolutionStack, inlinedCache)
+            };
+        }
+        // Handle objects with properties
+        if (schema.type === "object" && schema.properties) {
+            const inlinedProperties = {};
+            for (const [key, value] of Object.entries(schema.properties)) {
+                inlinedProperties[key] = this.inlineAllRefs(value, resolutionStack, inlinedCache);
+            }
+            const result = { ...schema, properties: inlinedProperties };
+            // Handle additionalProperties
+            if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+                result.additionalProperties = this.inlineAllRefs(schema.additionalProperties, resolutionStack, inlinedCache);
+            }
+            return result;
+        }
+        // Handle oneOf, anyOf, allOf
+        if (schema.oneOf) {
+            return {
+                ...schema,
+                oneOf: schema.oneOf.map(s => this.inlineAllRefs(s, resolutionStack, inlinedCache))
+            };
+        }
+        if (schema.anyOf) {
+            return {
+                ...schema,
+                anyOf: schema.anyOf.map(s => this.inlineAllRefs(s, resolutionStack, inlinedCache))
+            };
+        }
+        if (schema.allOf) {
+            return {
+                ...schema,
+                allOf: schema.allOf.map(s => this.inlineAllRefs(s, resolutionStack, inlinedCache))
+            };
+        }
+        // Return schema as-is if no special handling needed
+        return schema;
+    }
     /**
      * Convert an OpenAPI schema (or reference) into a JSON Schema object.
      * Uses caching and handles cycles by returning $ref nodes.
@@ -226,6 +320,78 @@ export class OpenAPIToMCPConverter {
         }
         return schema;
     }
+    /**
+     * Create a fully inlined schema without any $ref or $defs for Gemini CLI compatibility
+     */
+    createInlinedSchema(operation, method, path) {
+        // First create the schema with $defs
+        const schemaWithRefs = {
+            $defs: this.convertComponentsToJsonSchema(),
+            type: "object",
+            properties: {},
+            required: [],
+        };
+        // Handle parameters (path, query, header, cookie)
+        if (operation.parameters) {
+            for (const param of operation.parameters) {
+                const paramObj = this.resolveParameter(param);
+                if (paramObj && paramObj.schema) {
+                    const schema = this.convertOpenApiSchemaToJsonSchema(paramObj.schema, new Set(), false);
+                    // Merge parameter-level description if available
+                    if (paramObj.description) {
+                        schema.description = paramObj.description;
+                    }
+                    schemaWithRefs.properties[paramObj.name] = schema;
+                    if (paramObj.required) {
+                        schemaWithRefs.required.push(paramObj.name);
+                    }
+                }
+            }
+        }
+        // Handle requestBody
+        if (operation.requestBody) {
+            const bodyObj = this.resolveRequestBody(operation.requestBody);
+            if (bodyObj?.content) {
+                // Handle multipart/form-data for file uploads
+                if (bodyObj.content["multipart/form-data"]?.schema) {
+                    const formSchema = this.convertOpenApiSchemaToJsonSchema(bodyObj.content["multipart/form-data"].schema, new Set(), false);
+                    if (formSchema.type === "object" && formSchema.properties) {
+                        for (const [name, propSchema] of Object.entries(formSchema.properties)) {
+                            schemaWithRefs.properties[name] = propSchema;
+                        }
+                        if (formSchema.required) {
+                            schemaWithRefs.required.push(...formSchema.required);
+                        }
+                    }
+                }
+                // Handle application/json
+                else if (bodyObj.content["application/json"]?.schema) {
+                    const bodySchema = this.convertOpenApiSchemaToJsonSchema(bodyObj.content["application/json"].schema, new Set(), false);
+                    // Merge body schema into the inputSchema's properties
+                    if (bodySchema.type === "object" && bodySchema.properties) {
+                        for (const [name, propSchema] of Object.entries(bodySchema.properties)) {
+                            schemaWithRefs.properties[name] = propSchema;
+                        }
+                        if (bodySchema.required) {
+                            schemaWithRefs.required.push(...bodySchema.required);
+                        }
+                    }
+                    else {
+                        // If the request body is not an object, just put it under "body"
+                        schemaWithRefs.properties["body"] = bodySchema;
+                        schemaWithRefs.required.push("body");
+                    }
+                }
+            }
+        }
+        // Now inline all references and remove $defs
+        const inlinedSchema = this.inlineAllRefs(schemaWithRefs);
+        // Ensure we remove $defs completely for Gemini CLI compatibility
+        if ("$defs" in inlinedSchema) {
+            delete inlinedSchema["$defs"];
+        }
+        return inlinedSchema;
+    }
     /**
      * Helper method to convert an operation to a JSON Schema for parameters
      */
@@ -323,67 +489,8 @@ export class OpenAPIToMCPConverter {
             return null;
         }
         const methodName = operation.operationId.replaceAll("\.", "_");
-        const inputSchema = {
-            $defs: this.convertComponentsToJsonSchema(),
-            type: "object",
-            properties: {},
-            required: [],
-        };
-        // Handle parameters (path, query, header, cookie)
-        if (operation.parameters) {
-            for (const param of operation.parameters) {
-                const paramObj = this.resolveParameter(param);
-                if (paramObj && paramObj.schema) {
-                    const schema = this.convertOpenApiSchemaToJsonSchema(paramObj.schema, new Set(), false);
-                    // Merge parameter-level description if available
-                    if (paramObj.description) {
-                        schema.description = paramObj.description;
-                    }
-                    inputSchema.properties[paramObj.name] = schema;
-                    if (paramObj.required) {
-                        inputSchema.required.push(paramObj.name);
-                    }
-                }
-            }
-        }
-        // Handle requestBody
-        if (operation.requestBody) {
-            const bodyObj = this.resolveRequestBody(operation.requestBody);
-            if (bodyObj?.content) {
-                // Handle multipart/form-data for file uploads
-                // We convert the multipart/form-data schema to a JSON schema and we require
-                // that the user passes in a string for each file that points to the local file
-                if (bodyObj.content["multipart/form-data"]?.schema) {
-                    const formSchema = this.convertOpenApiSchemaToJsonSchema(bodyObj.content["multipart/form-data"].schema, new Set(), false);
-                    if (formSchema.type === "object" && formSchema.properties) {
-                        for (const [name, propSchema] of Object.entries(formSchema.properties)) {
-                            inputSchema.properties[name] = propSchema;
-                        }
-                        if (formSchema.required) {
-                            inputSchema.required.push(...formSchema.required);
-                        }
-                    }
-                }
-                // Handle application/json
-                else if (bodyObj.content["application/json"]?.schema) {
-                    const bodySchema = this.convertOpenApiSchemaToJsonSchema(bodyObj.content["application/json"].schema, new Set(), false);
-                    // Merge body schema into the inputSchema's properties
-                    if (bodySchema.type === "object" && bodySchema.properties) {
-                        for (const [name, propSchema] of Object.entries(bodySchema.properties)) {
-                            inputSchema.properties[name] = propSchema;
-                        }
-                        if (bodySchema.required) {
-                            inputSchema.required.push(...bodySchema.required);
-                        }
-                    }
-                    else {
-                        // If the request body is not an object, just put it under "body"
-                        inputSchema.properties["body"] = bodySchema;
-                        inputSchema.required.push("body");
-                    }
-                }
-            }
-        }
+        // Use the inlined schema method for Gemini CLI compatibility
+        const inputSchema = this.createInlinedSchema(operation, method, path);
         // Build description including error responses
         let description = operation.summary || operation.description || "";
         if (operation.responses) {

package/build/tools/search-magicpod-articles.js

@@ -30,6 +30,7 @@ export const searchMagicpodArticles = () => {
                 .describe("Query's and search target's locale"),
         }),
         handleRequest: async ({ query, locale }) => {
+            query += ' -label:release';
             const response = await makeRequest(query, locale);
             // The response has "body" field, but it is too large for LLM
             // So, such large or insignificant fields are filtered here

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magicpod-mcp-server",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Model Context Protocol server for MagicPod integration",
   "type": "module",
   "bin": {