@epicai/legion 1.0.0

package/dist/mcp-servers/whatsapp.js

@@ -0,0 +1,356 @@
+/**
+ * WhatsApp Business API MCP Adapter
+ * Built on the Epic AI® Intelligence Platform
+ * Copyright 2026 protectNIL Inc. Apache-2.0
+ */
+import { MCPAdapterBase } from './base.js';
+export class WhatsAppMCPServer extends MCPAdapterBase {
+    baseUrl;
+    token;
+    constructor(config) {
+        super();
+        this.baseUrl = config.baseUrl.replace(/\/+$/, '');
+        this.token = config.token;
+    }
+    static catalog() {
+        return {
+            name: 'whatsapp',
+            displayName: 'WhatsApp Business API',
+            version: '1.0.0',
+            category: 'communication',
+            keywords: [
+                'whatsapp', 'messaging', 'sms', 'chat', 'business', 'facebook', 'meta',
+                'send message', 'group', 'media', 'contact', 'notification',
+            ],
+            toolNames: [
+                'send_message',
+                'check_contact',
+                'get_groups',
+                'create_group',
+                'get_group_info',
+                'upload_media',
+                'get_application_settings',
+                'get_business_profile',
+                'get_metrics',
+                'check_health',
+            ],
+            description: 'WhatsApp Business API: send messages, manage groups, check contacts, upload media, and configure the WhatsApp Business client via the self-hosted v1 REST API.',
+            author: 'protectnil',
+        };
+    }
+    get tools() {
+        return [
+            {
+                name: 'send_message',
+                description: 'Send a text, template, image, document, audio, or video message to a WhatsApp number or group',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        to: {
+                            type: 'string',
+                            description: 'Recipient phone number in E.164 format (e.g. +14155552671) or group ID',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Message type: text, image, document, audio, video, template (default: text)',
+                        },
+                        text_body: {
+                            type: 'string',
+                            description: 'Plain text body (used when type=text)',
+                        },
+                        template_name: {
+                            type: 'string',
+                            description: 'Approved template name (used when type=template)',
+                        },
+                        template_language: {
+                            type: 'string',
+                            description: 'Template language/locale code, e.g. en_US (used when type=template)',
+                        },
+                        media_id: {
+                            type: 'string',
+                            description: 'ID of a previously uploaded media asset (used for image/document/audio/video types)',
+                        },
+                        media_link: {
+                            type: 'string',
+                            description: 'Public URL of media to send instead of a pre-uploaded media_id',
+                        },
+                        caption: {
+                            type: 'string',
+                            description: 'Optional caption for media messages',
+                        },
+                    },
+                    required: ['to', 'type'],
+                },
+            },
+            {
+                name: 'check_contact',
+                description: 'Check whether one or more phone numbers are registered WhatsApp users and get their WA IDs',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        contacts: {
+                            type: 'array',
+                            description: 'Array of phone numbers in E.164 format to check (e.g. ["+14155552671"])',
+                        },
+                        blocking: {
+                            type: 'string',
+                            description: 'Lookup mode: wait (synchronous) or no_wait (asynchronous, default: wait)',
+                        },
+                    },
+                    required: ['contacts'],
+                },
+            },
+            {
+                name: 'get_groups',
+                description: 'List all WhatsApp groups this business number is a member of',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'create_group',
+                description: 'Create a new WhatsApp group with a subject and initial participant list',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        subject: {
+                            type: 'string',
+                            description: 'Group name/subject',
+                        },
+                        participants: {
+                            type: 'array',
+                            description: 'Array of WA IDs (phone numbers) to add as initial participants',
+                        },
+                    },
+                    required: ['subject', 'participants'],
+                },
+            },
+            {
+                name: 'get_group_info',
+                description: 'Get metadata for a specific WhatsApp group including participants and admins',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        group_id: {
+                            type: 'string',
+                            description: 'WhatsApp group ID',
+                        },
+                    },
+                    required: ['group_id'],
+                },
+            },
+            {
+                name: 'upload_media',
+                description: 'Upload a media file (image, document, audio, video) to the WhatsApp server for later use in messages',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        file_url: {
+                            type: 'string',
+                            description: 'Publicly accessible URL of the file to upload',
+                        },
+                        content_type: {
+                            type: 'string',
+                            description: 'MIME type of the file, e.g. image/jpeg, application/pdf, audio/ogg',
+                        },
+                    },
+                    required: ['file_url', 'content_type'],
+                },
+            },
+            {
+                name: 'get_application_settings',
+                description: 'Retrieve current WhatsApp Business API application configuration including webhook, media, and callback settings',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'get_business_profile',
+                description: 'Get the WhatsApp Business profile including address, description, email, vertical, and website',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'get_metrics',
+                description: 'Retrieve application metrics such as message throughput and delivery stats',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        format: {
+                            type: 'string',
+                            description: 'Response format: prometheus or json (default: json)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'check_health',
+                description: 'Check the health and status of the WhatsApp Business API container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+        ];
+    }
+    async callTool(name, args) {
+        try {
+            switch (name) {
+                case 'send_message':
+                    return this.sendMessage(args);
+                case 'check_contact':
+                    return this.checkContact(args);
+                case 'get_groups':
+                    return this.getGroups();
+                case 'create_group':
+                    return this.createGroup(args);
+                case 'get_group_info':
+                    return this.getGroupInfo(args);
+                case 'upload_media':
+                    return this.uploadMedia(args);
+                case 'get_application_settings':
+                    return this.getApplicationSettings();
+                case 'get_business_profile':
+                    return this.getBusinessProfile();
+                case 'get_metrics':
+                    return this.getMetrics(args);
+                case 'check_health':
+                    return this.checkHealth();
+                default:
+                    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+            }
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Tool execution failed: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    }
+    get headers() {
+        return {
+            'Authorization': `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+        };
+    }
+    async get(path, params = {}) {
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(params)) {
+            if (v !== undefined)
+                qs.set(k, v);
+        }
+        const query = qs.toString();
+        const url = `${this.baseUrl}${path}${query ? '?' + query : ''}`;
+        const response = await this.fetchWithRetry(url, { method: 'GET', headers: this.headers });
+        if (!response.ok) {
+            return { content: [{ type: 'text', text: `API error: ${response.status} ${response.statusText}` }], isError: true };
+        }
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throw new Error(`WhatsApp API returned non-JSON (HTTP ${response.status})`);
+        }
+        return { content: [{ type: 'text', text: this.truncate(data) }], isError: false };
+    }
+    async post(path, body) {
+        const response = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => response.statusText);
+            return { content: [{ type: 'text', text: `API error: ${response.status} ${errText}` }], isError: true };
+        }
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throw new Error(`WhatsApp API returned non-JSON (HTTP ${response.status})`);
+        }
+        return { content: [{ type: 'text', text: this.truncate(data) }], isError: false };
+    }
+    async sendMessage(args) {
+        const { to, type = 'text', text_body, template_name, template_language, media_id, media_link, caption } = args;
+        const body = { to, type };
+        if (type === 'text') {
+            body['text'] = { body: text_body };
+        }
+        else if (type === 'template') {
+            body['template'] = {
+                namespace: '',
+                name: template_name,
+                language: { policy: 'deterministic', code: template_language ?? 'en_US' },
+            };
+        }
+        else {
+            // image, document, audio, video
+            const mediaObj = {};
+            if (media_id)
+                mediaObj['id'] = media_id;
+            else if (media_link)
+                mediaObj['link'] = media_link;
+            if (caption)
+                mediaObj['caption'] = caption;
+            body[type] = mediaObj;
+        }
+        return this.post('/messages', body);
+    }
+    async checkContact(args) {
+        const { contacts, blocking = 'wait' } = args;
+        return this.post('/contacts', { blocking, contacts });
+    }
+    async getGroups() {
+        return this.get('/groups');
+    }
+    async createGroup(args) {
+        const { subject, participants } = args;
+        return this.post('/groups', { subject, participants });
+    }
+    async getGroupInfo(args) {
+        const { group_id } = args;
+        return this.get(`/groups/${encodeURIComponent(group_id)}`);
+    }
+    async uploadMedia(args) {
+        const { file_url, content_type } = args;
+        // WhatsApp /media expects multipart/form-data; since we only have fetch, we post JSON with the link form
+        // The API accepts a URL-based upload via form-data. We send it as JSON body (link field).
+        const response = await this.fetchWithRetry(`${this.baseUrl}/media`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': content_type },
+            body: JSON.stringify({ url: file_url }),
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => response.statusText);
+            return { content: [{ type: 'text', text: `API error: ${response.status} ${errText}` }], isError: true };
+        }
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throw new Error(`WhatsApp API returned non-JSON (HTTP ${response.status})`);
+        }
+        return { content: [{ type: 'text', text: this.truncate(data) }], isError: false };
+    }
+    async getApplicationSettings() {
+        return this.get('/settings/application');
+    }
+    async getBusinessProfile() {
+        return this.get('/settings/business/profile');
+    }
+    async getMetrics(args) {
+        const { format } = args;
+        return this.get('/metrics', { format });
+    }
+    async checkHealth() {
+        return this.get('/health');
+    }
+}

package/dist/mcp-servers/wheretocredit.d.ts

@@ -0,0 +1,34 @@
+/**
+ * WhereToCredit MCP Adapter
+ * Built on the Epic AI® Intelligence Platform
+ * Copyright 2026 protectNIL Inc. Apache-2.0
+ */
+import { ToolDefinition, ToolResult } from './types.js';
+import { MCPAdapterBase } from './base.js';
+interface WhereToCreditConfig {
+    /** API key for authenticated endpoints */
+    apiKey: string;
+    /** Optional base URL override (default: https://api.wheretocredit.com) */
+    baseUrl?: string;
+}
+export declare class WhereToCreditMCPServer extends MCPAdapterBase {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(config: WhereToCreditConfig);
+    static catalog(): {
+        name: string;
+        displayName: string;
+        version: string;
+        category: string;
+        keywords: string[];
+        toolNames: string[];
+        description: string;
+        author: string;
+    };
+    get tools(): ToolDefinition[];
+    callTool(name: string, args: Record<string, unknown>): Promise<ToolResult>;
+    private get authHeaders();
+    private listPrograms;
+    private calculateMiles;
+}
+export {};

package/dist/mcp-servers/wheretocredit.js

@@ -0,0 +1,178 @@
+/**
+ * WhereToCredit MCP Adapter
+ * Built on the Epic AI® Intelligence Platform
+ * Copyright 2026 protectNIL Inc. Apache-2.0
+ */
+import { MCPAdapterBase } from './base.js';
+export class WhereToCreditMCPServer extends MCPAdapterBase {
+    apiKey;
+    baseUrl;
+    constructor(config) {
+        super();
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl ?? 'https://api.wheretocredit.com';
+    }
+    static catalog() {
+        return {
+            name: 'wheretocredit',
+            displayName: 'WhereToCredit',
+            version: '1.0.0',
+            category: 'travel',
+            keywords: [
+                'wheretocredit', 'frequent flyer', 'miles', 'points', 'airline', 'loyalty',
+                'travel', 'reward', 'credit', 'itinerary', 'segment', 'mileage', 'earn',
+                'booking class', 'iata', 'partner', 'revenue', 'tier', 'program',
+            ],
+            toolNames: [
+                'list_programs',
+                'calculate_miles',
+            ],
+            description: 'WhereToCredit API: list all supported frequent flyer programs and calculate miles or points earned for flight itineraries across every major loyalty program.',
+            author: 'protectnil',
+        };
+    }
+    get tools() {
+        return [
+            {
+                name: 'list_programs',
+                description: 'List all frequent flyer programs supported by WhereToCredit — returns program IDs, names, associated airlines, tier levels, and the denomination of miles/points used by each program',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'calculate_miles',
+                description: 'Calculate the number of miles or points earned for one or more flight itineraries across every supported frequent flyer program — provide flight segments with carrier, origin, destination, booking class, and optional base fare for revenue-based programs',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        itineraries: {
+                            type: 'array',
+                            description: 'Array of flight itineraries to evaluate. Each itinerary contains one or more flight segments.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: {
+                                        type: 'string',
+                                        description: 'Unique identifier for this itinerary (returned in the response for matching)',
+                                    },
+                                    ticketingCarrier: {
+                                        type: 'string',
+                                        description: 'Two-letter IATA carrier code of the ticketing/plating airline (e.g. "AA", "UA")',
+                                    },
+                                    baseFareUSD: {
+                                        type: 'number',
+                                        description: 'Base fare amount in USD — required for revenue-based mileage programs (e.g. Delta SkyMiles, JetBlue TrueBlue)',
+                                    },
+                                    segments: {
+                                        type: 'array',
+                                        description: 'Flight segments in this itinerary. Each connection or stopover is a separate segment.',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                carrier: {
+                                                    type: 'string',
+                                                    description: 'Two-letter IATA carrier code for the marketing airline (e.g. "AA")',
+                                                },
+                                                operatingCarrier: {
+                                                    type: 'string',
+                                                    description: 'Two-letter IATA carrier code for the operating airline (if different from marketing carrier)',
+                                                },
+                                                origin: {
+                                                    type: 'string',
+                                                    description: 'Three-letter IATA airport code of the departure airport (e.g. "JFK")',
+                                                },
+                                                destination: {
+                                                    type: 'string',
+                                                    description: 'Three-letter IATA airport code of the arrival airport (e.g. "LHR")',
+                                                },
+                                                bookingClass: {
+                                                    type: 'string',
+                                                    description: 'Single-letter booking/fare class (e.g. "Y" for economy, "J" for business)',
+                                                },
+                                                flightNumber: {
+                                                    type: 'number',
+                                                    description: 'Flight number (numeric portion only, e.g. 100 for AA100)',
+                                                },
+                                                departure: {
+                                                    type: 'string',
+                                                    description: 'Departure date in YYYY-MM-DD format (e.g. "2026-06-15")',
+                                                },
+                                                distance: {
+                                                    type: 'number',
+                                                    description: 'Flight distance in miles — if omitted, the API computes the great-circle distance from origin/destination',
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    required: ['itineraries'],
+                },
+            },
+        ];
+    }
+    async callTool(name, args) {
+        try {
+            switch (name) {
+                case 'list_programs': return this.listPrograms();
+                case 'calculate_miles': return this.calculateMiles(args);
+                default:
+                    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+            }
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Tool execution failed: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    }
+    // ── Private helpers ──────────────────────────────────────────────────────────
+    get authHeaders() {
+        return {
+            'api-key': this.apiKey,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+        };
+    }
+    // ── Tool implementations ─────────────────────────────────────────────────────
+    async listPrograms() {
+        const response = await this.fetchWithRetry(`${this.baseUrl}/api/1.0/programs`, {
+            headers: this.authHeaders,
+        });
+        if (!response.ok) {
+            return {
+                content: [{ type: 'text', text: `API error: ${response.status} ${response.statusText}` }],
+                isError: true,
+            };
+        }
+        const data = await response.json();
+        return { content: [{ type: 'text', text: this.truncate(data) }], isError: false };
+    }
+    async calculateMiles(args) {
+        const itineraries = args['itineraries'];
+        if (!itineraries || !Array.isArray(itineraries) || itineraries.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'itineraries is required and must be a non-empty array' }],
+                isError: true,
+            };
+        }
+        const response = await this.fetchWithRetry(`${this.baseUrl}/api/1.0/calculate`, {
+            method: 'POST',
+            headers: this.authHeaders,
+            body: JSON.stringify(itineraries),
+        });
+        if (!response.ok) {
+            return {
+                content: [{ type: 'text', text: `API error: ${response.status} ${response.statusText}` }],
+                isError: true,
+            };
+        }
+        const data = await response.json();
+        return { content: [{ type: 'text', text: this.truncate(data) }], isError: false };
+    }
+}

package/dist/mcp-servers/wikimedia.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Wikimedia MCP Adapter
+ * Built on the Epic AI® Intelligence Platform
+ * Copyright 2026 protectNIL Inc. Apache-2.0
+ */
+import { ToolDefinition, ToolResult } from './types.js';
+import { MCPAdapterBase } from './base.js';
+interface WikimediaConfig {
+    /** Optional base URL override (default: https://en.wikipedia.org/api/rest_v1) */
+    baseUrl?: string;
+    /** User-Agent string sent with every request — set to identify your application */
+    userAgent?: string;
+}
+export declare class WikimediaMCPServer extends MCPAdapterBase {
+    private readonly baseUrl;
+    private readonly userAgent;
+    constructor(config?: WikimediaConfig);
+    static catalog(): {
+        name: string;
+        displayName: string;
+        version: string;
+        category: string;
+        keywords: string[];
+        toolNames: string[];
+        description: string;
+        author: string;
+    };
+    get tools(): ToolDefinition[];
+    callTool(name: string, args: Record<string, unknown>): Promise<ToolResult>;
+    private get;
+    private getText;
+    private getPageSummary;
+    private getPageHtml;
+    private getPageMediaList;
+    private getPageMobileHtml;
+    private getRevisionMetadata;
+    private getMathFormula;
+    private getCitation;
+    private getTranslationRecommendations;
+    private getMobileCss;
+}
+export {};