452 lines
14 KiB
Plaintext
452 lines
14 KiB
Plaintext
// mcp_tool_convert.ts
|
|
import _ from "lodash";
|
|
|
|
/**
|
|
* This file:
|
|
* - preserves exported function names: convertOpenApiToMcpTools and getMcpTools
|
|
* - improves resilience when parsing OpenAPI objects
|
|
* - emits x-props.parameters array so executeTool can act correctly
|
|
* - ensures requestBody is represented as a synthetic `body` parameter when necessary
|
|
*/
|
|
|
|
// == Types
|
|
interface McpTool {
|
|
name: string;
|
|
description: string;
|
|
inputSchema: any;
|
|
"x-props": {
|
|
method: string;
|
|
path: string;
|
|
operationId?: string;
|
|
tag?: string;
|
|
deprecated?: boolean;
|
|
summary?: string;
|
|
parameters?: any[]; // added to communicate param locations to executor
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Convert OpenAPI 3.x JSON spec into MCP-compatible tool definitions.
|
|
* - filterTag is matched case-insensitively against operation tags (substring)
|
|
*/
|
|
export function convertOpenApiToMcpTools(openApiJson: any, filterTag: string): McpTool[] {
|
|
const tools: McpTool[] = [];
|
|
|
|
if (!openApiJson || typeof openApiJson !== "object") {
|
|
console.warn("Invalid OpenAPI JSON");
|
|
return tools;
|
|
}
|
|
|
|
const paths = openApiJson.paths || {};
|
|
|
|
if (Object.keys(paths).length === 0) {
|
|
console.warn("No paths found in OpenAPI spec");
|
|
return tools;
|
|
}
|
|
|
|
for (const [path, methods] of Object.entries(paths)) {
|
|
if (!path || typeof path !== "string") continue;
|
|
if (!methods || typeof methods !== "object") continue;
|
|
|
|
for (const [method, operation] of Object.entries<any>(methods)) {
|
|
const validMethods = ["get", "post", "put", "delete", "patch", "head", "options"];
|
|
if (!validMethods.includes(method.toLowerCase())) continue;
|
|
if (!operation || typeof operation !== "object") continue;
|
|
|
|
const tags: string[] = Array.isArray(operation.tags) ? operation.tags : [];
|
|
|
|
// If filterTag provided, require at least one tag to include it (case-insensitive)
|
|
if (filterTag && (!tags.length || !tags.some(t => typeof t === "string" && t.toLowerCase().includes(filterTag.toLowerCase())))) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
const tool = createToolFromOperation(path, method, operation, tags);
|
|
if (tool) {
|
|
tools.push(tool);
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error creating tool for ${method.toUpperCase()} ${path}:`, error);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
return tools;
|
|
}
|
|
|
|
/**
|
|
* Create MCP tool from an OpenAPI operation.
|
|
* - Ensures x-props.parameters exists and describes path/query/header/cookie/requestBody
|
|
*/
|
|
function createToolFromOperation(
|
|
path: string,
|
|
method: string,
|
|
operation: any,
|
|
tags: string[]
|
|
): McpTool | null {
|
|
try {
|
|
const rawName = _.snakeCase(`${operation.operationId}` || `${method}_${path}`) || "unnamed_tool";
|
|
const name = cleanToolName(rawName);
|
|
|
|
if (!name || name === "unnamed_tool") {
|
|
console.warn(`Invalid tool name for ${method} ${path}`);
|
|
return null;
|
|
}
|
|
|
|
const description =
|
|
operation.description ||
|
|
operation.summary ||
|
|
`Execute ${method.toUpperCase()} ${path}`;
|
|
|
|
// Build parameters array for executor
|
|
const parameters: any[] = [];
|
|
|
|
if (Array.isArray(operation.parameters)) {
|
|
for (const p of operation.parameters) {
|
|
try {
|
|
// copy essential fields
|
|
const paramEntry: any = {
|
|
name: p.name,
|
|
in: p.in,
|
|
required: !!p.required,
|
|
description: p.description,
|
|
schema: p.schema || { type: "string" },
|
|
};
|
|
parameters.push(paramEntry);
|
|
} catch (err) {
|
|
console.warn("Skipping invalid parameter:", p, err);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If requestBody exists, synthesize a single `body` parameter so the executor can pick it up.
|
|
// We do not try to expand complex requestBody schemas into multiple parameters here — inputSchema covers that.
|
|
if (operation.requestBody && typeof operation.requestBody === "object") {
|
|
// prefer application/json schema, fallback to first available
|
|
const content = operation.requestBody.content || {};
|
|
let schemaCandidate: any = null;
|
|
const preferred = ["application/json", "multipart/form-data", "application/x-www-form-urlencoded"];
|
|
for (const c of preferred) {
|
|
if (content[c]?.schema) {
|
|
schemaCandidate = content[c].schema;
|
|
break;
|
|
}
|
|
}
|
|
if (!schemaCandidate) {
|
|
const entries = Object.entries(content);
|
|
if (entries.length > 0 && (entries[0] as any)[1]?.schema) {
|
|
schemaCandidate = (entries[0] as any)[1].schema;
|
|
}
|
|
}
|
|
|
|
// Add synthetic body param (name "body")
|
|
parameters.push({
|
|
name: "body",
|
|
in: "requestBody",
|
|
required: !!operation.requestBody.required,
|
|
schema: schemaCandidate || { type: "object" },
|
|
description: operation.requestBody.description || "Request body",
|
|
});
|
|
}
|
|
|
|
// Extract input schema for UI (query/path/header -> properties OR requestBody schema)
|
|
let schema;
|
|
if (method.toLowerCase() === "get" || method.toLowerCase() === "delete" || method.toLowerCase() === "head") {
|
|
schema = extractParametersSchema(operation.parameters || []);
|
|
} else {
|
|
schema = extractRequestBodySchema(operation);
|
|
// if no requestBody but parameters exist, fall back to parameters schema
|
|
if (!schema) {
|
|
schema = extractParametersSchema(operation.parameters || []);
|
|
}
|
|
}
|
|
|
|
const inputSchema = createInputSchema(schema);
|
|
|
|
return {
|
|
name,
|
|
description,
|
|
"x-props": {
|
|
method: method.toUpperCase(),
|
|
path,
|
|
operationId: operation.operationId,
|
|
tag: tags[0],
|
|
deprecated: operation.deprecated || false,
|
|
summary: operation.summary,
|
|
parameters, // executor will rely on this
|
|
},
|
|
inputSchema,
|
|
};
|
|
} catch (error) {
|
|
console.error(`Failed to create tool from operation:`, error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract schema dari parameters (untuk GET/DELETE requests)
|
|
* - returns null if no parameters
|
|
*/
|
|
function extractParametersSchema(parameters: any[]): any | null {
|
|
if (!Array.isArray(parameters) || parameters.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
const properties: any = {};
|
|
const required: string[] = [];
|
|
|
|
for (const param of parameters) {
|
|
if (!param || typeof param !== "object") continue;
|
|
|
|
// Support path, query, dan header parameters
|
|
if (["path", "query", "header"].includes(param.in)) {
|
|
const paramName = param.name;
|
|
if (!paramName || typeof paramName !== "string") continue;
|
|
|
|
properties[paramName] = {
|
|
type: param.schema?.type || "string",
|
|
description: param.description || `${param.in} parameter: ${paramName}`,
|
|
};
|
|
|
|
// copy allowed fields
|
|
if (param.schema) {
|
|
const allowedFields = ["examples", "example", "default", "enum", "pattern", "minLength", "maxLength", "minimum", "maximum", "format"];
|
|
for (const field of allowedFields) {
|
|
if (param.schema[field] !== undefined) {
|
|
properties[paramName][field] = param.schema[field];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (param.required === true) {
|
|
required.push(paramName);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Object.keys(properties).length === 0) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
type: "object",
|
|
properties,
|
|
required,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Extract schema dari requestBody (untuk POST/PUT/etc requests)
|
|
* - prefers application/json, handles form-data, urlencoded fallbacks
|
|
*/
|
|
function extractRequestBodySchema(operation: any): any | null {
|
|
if (!operation.requestBody?.content) {
|
|
return null;
|
|
}
|
|
|
|
const content = operation.requestBody.content;
|
|
|
|
const contentTypes = [
|
|
"application/json",
|
|
"multipart/form-data",
|
|
"application/x-www-form-urlencoded",
|
|
"text/plain",
|
|
];
|
|
|
|
for (const contentType of contentTypes) {
|
|
if (content[contentType]?.schema) {
|
|
return content[contentType].schema;
|
|
}
|
|
}
|
|
|
|
for (const [_, value] of Object.entries<any>(content)) {
|
|
if (value?.schema) {
|
|
return value.schema;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Buat input schema yang valid untuk MCP
|
|
* - preserves optional flags, required semantics, and nested properties
|
|
*/
|
|
function createInputSchema(schema: any): any {
|
|
const defaultSchema = {
|
|
type: "object",
|
|
properties: {},
|
|
additionalProperties: false,
|
|
};
|
|
|
|
if (!schema || typeof schema !== "object") {
|
|
return defaultSchema;
|
|
}
|
|
|
|
try {
|
|
const properties: any = {};
|
|
const required: string[] = [];
|
|
const originalRequired = Array.isArray(schema.required) ? schema.required : [];
|
|
|
|
if (schema.properties && typeof schema.properties === "object") {
|
|
for (const [key, prop] of Object.entries<any>(schema.properties)) {
|
|
if (!key || typeof key !== "string") continue;
|
|
|
|
try {
|
|
const cleanProp = cleanProperty(prop);
|
|
if (cleanProp) {
|
|
properties[key] = cleanProp;
|
|
|
|
// Check optional flag properly
|
|
const isOptional = prop?.optional === true || prop?.optional === "true";
|
|
const isInRequired = originalRequired.includes(key);
|
|
|
|
if (isInRequired && !isOptional) {
|
|
required.push(key);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error cleaning property ${key}:`, error);
|
|
continue;
|
|
}
|
|
}
|
|
} else if (schema.type === "array" && schema.items) {
|
|
// represent top-level array as object with items property to keep inputSchema shape predictable
|
|
properties["items"] = cleanProperty(schema.items) || { type: "string" };
|
|
}
|
|
|
|
return {
|
|
type: "object",
|
|
properties,
|
|
required,
|
|
additionalProperties: false,
|
|
};
|
|
} catch (error) {
|
|
console.error("Error creating input schema:", error);
|
|
return defaultSchema;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Bersihkan property dari field custom
|
|
* - preserves nested structures, arrays, and combiners (oneOf/anyOf/allOf)
|
|
*/
|
|
function cleanProperty(prop: any): any | null {
|
|
if (!prop || typeof prop !== "object") {
|
|
return { type: "string" };
|
|
}
|
|
|
|
try {
|
|
const cleaned: any = {
|
|
type: prop.type || "string",
|
|
};
|
|
|
|
const allowedFields = [
|
|
"description",
|
|
"examples",
|
|
"example",
|
|
"default",
|
|
"enum",
|
|
"pattern",
|
|
"minLength",
|
|
"maxLength",
|
|
"minimum",
|
|
"maximum",
|
|
"format",
|
|
"multipleOf",
|
|
"exclusiveMinimum",
|
|
"exclusiveMaximum",
|
|
];
|
|
|
|
for (const field of allowedFields) {
|
|
if (prop[field] !== undefined && prop[field] !== null) {
|
|
cleaned[field] = prop[field];
|
|
}
|
|
}
|
|
|
|
if (prop.properties && typeof prop.properties === "object") {
|
|
cleaned.properties = {};
|
|
for (const [key, value] of Object.entries(prop.properties)) {
|
|
const cleanedNested = cleanProperty(value);
|
|
if (cleanedNested) {
|
|
cleaned.properties[key] = cleanedNested;
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(prop.required)) {
|
|
cleaned.required = prop.required.filter((r: any) => typeof r === "string");
|
|
}
|
|
}
|
|
|
|
if (prop.items) {
|
|
cleaned.items = cleanProperty(prop.items);
|
|
}
|
|
|
|
if (Array.isArray(prop.oneOf)) {
|
|
cleaned.oneOf = prop.oneOf.map(cleanProperty).filter(Boolean);
|
|
}
|
|
if (Array.isArray(prop.anyOf)) {
|
|
cleaned.anyOf = prop.anyOf.map(cleanProperty).filter(Boolean);
|
|
}
|
|
if (Array.isArray(prop.allOf)) {
|
|
cleaned.allOf = prop.allOf.map(cleanProperty).filter(Boolean);
|
|
}
|
|
|
|
return cleaned;
|
|
} catch (error) {
|
|
console.error("Error cleaning property:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Bersihkan nama tool
|
|
*/
|
|
function cleanToolName(name: string): string {
|
|
if (!name || typeof name !== "string") {
|
|
return "unnamed_tool";
|
|
}
|
|
|
|
try {
|
|
return name
|
|
.replace(/[{}]/g, "")
|
|
.replace(/[^a-zA-Z0-9_]/g, "_")
|
|
.replace(/_+/g, "_")
|
|
.replace(/^_|_$/g, "")
|
|
// keep lowercase and stable
|
|
.toLowerCase()
|
|
|| "unnamed_tool";
|
|
} catch (error) {
|
|
console.error("Error cleaning tool name:", error);
|
|
return "unnamed_tool";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ambil OpenAPI JSON dari endpoint dan konversi ke tools MCP
|
|
* - preserves exported name getMcpTools
|
|
* - robust error handling and console diagnostics
|
|
*/
|
|
export async function getMcpTools(url: string, filterTag: string): Promise<McpTool[]> {
|
|
try {
|
|
console.log(`Fetching OpenAPI spec from: ${url}`);
|
|
|
|
const response = await fetch(url);
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP error! status: ${response.status}`);
|
|
}
|
|
|
|
const openApiJson = await response.json();
|
|
const tools = convertOpenApiToMcpTools(openApiJson, filterTag);
|
|
|
|
console.log(`✅ Successfully generated ${tools.length} MCP tools`);
|
|
|
|
return tools;
|
|
} catch (error) {
|
|
console.error("Error fetching MCP tools:", error);
|
|
throw error;
|
|
}
|
|
}
|