@gsb-core/mcp-tools/dist/tools/tool-helper.js

Shared tools for GSB MCP implementations

import { gsbEntityTools } from "./gsb-entity-tools.js";
import { gsbEntityDefTools } from "./gsb-entity-def-tools.js";
import { z } from "zod";
import { getDocs, getSummary, getApiDocs, getServerlessFunctionDocs, getSchemaDocs } from "@gsb-core/mcp-docs";
function getToolSummary(toolName) {
    return getSummary(toolName) + "\n\n ***Important: Make sure to run getDocs(\"" + toolName + "\") to get the full documentation before using the tool";
}
export const toolHelper = {
    applyToMcp: async ({ server, getToken, getTenantCode }) => {
        // Entity tools
        server.tool("getById", getToolSummary("getById") || "Retrieves an entity by its ID", {
            definitionType: z.string().describe("The entity definition type name"),
            id: z.string().describe("The unique identifier of the entity"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ definitionType, id, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.getById({ definitionType, id, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("getCopy", getToolSummary("getCopy") || "Creates a copy of an entity by its ID, excluding the ID field", {
            request: z.any().describe("The copy request containing definitionType and id"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.getCopy({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("query", getToolSummary("query") || "Performs a query operation to fetch entities", {
            queryParams: z.any().describe("The query parameters object"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ queryParams, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.query({ queryParams, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("queryMapped", getToolSummary("queryMapped") || "Performs a mapped query operation to fetch entities with mapping", {
            queryParams: z.any().describe("The query parameters object"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ queryParams, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.queryMapped({ queryParams, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("save", getToolSummary("save") || "Saves a single entity", {
            entity: z.any().describe("The entity to save"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ entity, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.save({ request: entity, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("saveMulti", getToolSummary("saveMulti") || "Saves multiple entities in a single operation", {
            request: z.any().describe("The save request with entities array"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.saveMulti({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("delete", getToolSummary("delete") || "Deletes an entity or entities based on criteria", {
            request: z.any().describe("The delete request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.delete({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("deleteQuery", getToolSummary("deleteQuery") || "Deletes entities based on a query", {
            queryParams: z.any().describe("The query parameters object"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ queryParams, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.deleteQuery({ queryParams, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("saveMappedItems", getToolSummary("saveMappedItems") || "Saves mapped items for an entity", {
            request: z.any().describe("The mapped save request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.saveMappedItems({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("removeMappedItems", getToolSummary("removeMappedItems") || "Removes mapped items from an entity", {
            request: z.any().describe("The mapped remove request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.removeMappedItems({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("runWorkflow", getToolSummary("runWorkflow") || "Runs a workflow", {
            request: z.any().describe("The workflow request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.runWorkflow({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("startWorkflow", getToolSummary("startWorkflow") || "Starts a workflow", {
            request: z.any().describe("The workflow start request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.startWorkflow({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("runWfFunction", getToolSummary("runWfFunction") || "Runs a workflow function", {
            request: z.any().describe("The function execution request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.runWfFunction({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("testWfFunction", getToolSummary("testWfFunction") || "Tests a workflow function", {
            request: z.any().describe("The function execution request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.testWfFunction({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("iterateTask", getToolSummary("iterateTask") || "Iterates a workflow task", {
            request: z.any().describe("The task iteration request"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ request, token, tenantCode }, extra) => {
            const result = await gsbEntityTools.iterateTask({ request, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        // Entity Definition tools
        server.tool("getCommonPropertyDefs", getToolSummary("getCommonPropertyDefs") || "Gets common property definitions that can be used when creating entity properties", {
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.getCommonPropertyDefs({ token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("createEntityDef", getToolSummary("createEntityDef") || "Creates a new entity definition with the specified schema", {
            entityDef: z.any().describe("The entity definition to create"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ entityDef, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.createEntityDef({ entityDef, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("updateEntityDef", getToolSummary("updateEntityDef") || "Updates an existing entity definition", {
            entityDef: z.any().describe("The entity definition to update"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ entityDef, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.updateEntityDef({ entityDef, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("addProperty", getToolSummary("addProperty") || "Adds a new property to an entity definition", {
            property: z.any().describe("The property to add"),
            entityDef: z.any().optional().describe("The entity definition object containing id or name"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ property, entityDef, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.addProperty({ property, entityDef, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("removeProperty", getToolSummary("removeProperty") || "Removes a property from an entity definition", {
            property: z.any().describe("The property to remove"),
            entityDef: z.any().optional().describe("The entity definition object containing id or name"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ property, entityDef, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.removeProperty({ property, entityDef, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("updateProperty", getToolSummary("updateProperty") || "Updates an existing property in an entity definition", {
            property: z.any().describe("The updated property definition"),
            entityDef: z.any().describe("The entity definition object containing id or name"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ property, entityDef, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.updateProperty({ property, entityDef, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("getEntityDef", getToolSummary("getEntityDef") || "Gets an entity definition by ID or name", {
            entityDef: z.any().describe("The entity definition object containing id or name"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ entityDef, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.getEntityDef({ entityDef, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        server.tool("queryEntityDefs", getToolSummary("queryEntityDefs") || "Queries entity definitions", {
            searchTerm: z.string().describe("Search term for entity definitions"),
            page: z.number().int().describe("Page number (0-based)"),
            pageSize: z.number().int().describe("Number of items per page"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ searchTerm, page, pageSize, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.queryEntityDefs({ searchTerm, page, pageSize, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        // Add the createOrUpdateSchema tool
        server.tool("createOrUpdateSchema", getToolSummary("createOrUpdateSchema") || "Creates or updates multiple entity definitions and their properties with intelligent reference handling", {
            entityDefs: z.array(z.any()).describe("Array of entity definitions to create or update"),
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ entityDefs, token, tenantCode }, extra) => {
            const result = await gsbEntityDefTools.createOrUpdateSchema({ entityDefs, token: getToken(token), tenantCode: getTenantCode(tenantCode) });
            return {
                content: [{ type: "text", text: JSON.stringify(result) }],
            };
        });
        // Add API documentation tools
        server.tool("getDocs", getToolSummary("getDocs") || "Gets comprehensive API documentation", {
            methodName: z.string().optional().describe("Optional method name to get specific documentation")
        }, async ({ methodName }, extra) => {
            const docs = getDocs(methodName);
            return {
                content: [{ type: "text", text: docs }],
            };
        });
        server.tool("getApiDocs", getToolSummary("getApiDocs") || "Gets general API information", {
            token: z.string().optional().describe("The authentication token for your request"),
            tenantCode: z.string().optional().describe("Optional tenant code (extracted from token if not provided)")
        }, async ({ token, tenantCode }, extra) => {
            const docs = getApiDocs();
            return {
                content: [{ type: "text", text: docs }],
            };
        });
        // New tool for GSB Serverless Functions Documentation
        server.tool("getServerlessFunctionDocs", "Gets comprehensive documentation for GSB Serverless Functions", {}, async (args, extra) => {
            const docs = getServerlessFunctionDocs();
            return {
                content: [{ type: "text", text: docs }],
            };
        });
        // New tool for GSB Schema Docs
        server.tool("getSchemaDocs", "Gets comprehensive documentation for GSB Schema Management", {}, async (args, extra) => {
            const docs = getSchemaDocs();
            return {
                content: [{ type: "text", text: docs }],
            };
        });
        // Add Schema Manager Documentation
        server.tool("getSchemaManagerDocs", "Gets documentation specific to the Schema Manager service", {}, async (args, extra) => {
            const docs = getDocs("createOrUpdateSchema");
            return {
                content: [{ type: "text", text: docs }],
            };
        });
    }
}; // Added missing closing brace
//# sourceMappingURL=tool-helper.js.map