langmart-gateway-type3 3.0.45 → 3.0.47

package/dist/user-tools.js

@@ -0,0 +1,685 @@
+"use strict";
+/**
+ * User Tools - MCP Tools for User Account Management
+ *
+ * Provides tools for:
+ * - API key management (list, create, delete, rotate)
+ * - Model mappings (aliases)
+ * - Account info (balance, usage)
+ * - Analytics (request logs, errors)
+ * - Alerts management
+ * - Quota status
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTools = exports.userToolDefinitions = void 0;
+const axios_1 = __importDefault(require("axios"));
+// ============= TOOL DEFINITIONS =============
+exports.userToolDefinitions = [
+    // ===== API KEYS =====
+    {
+        type: 'function',
+        function: {
+            name: 'user_api_keys_list',
+            description: 'List all API keys for the current user. Response includes key_id (use with user_api_keys_delete or user_api_keys_rotate), organization_id (use organizations_get for org details). Shows key prefix, name, creation date, and last used date.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        metadata: {
+            category: 'api_keys',
+            defaultEnabled: false, // Sensitive - user must enable
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/keys',
+            apiMethod: 'GET',
+            tags: ['api_keys', 'list', 'security']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_api_keys_create',
+            description: 'Create a new API key. The full key is only shown once at creation time - save it immediately. Optionally specify a name and expiration.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Human-readable name for this API key (e.g., "Production Server", "Dev Laptop")'
+                    },
+                    expires_in_days: {
+                        type: 'number',
+                        description: 'Number of days until the key expires. Leave empty for no expiration.',
+                        minimum: 1,
+                        maximum: 365
+                    }
+                },
+                required: []
+            }
+        },
+        metadata: {
+            category: 'api_keys',
+            defaultEnabled: false,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: true,
+            apiEndpoint: '/api/keys',
+            apiMethod: 'POST',
+            tags: ['api_keys', 'create', 'security']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_api_keys_delete',
+            description: 'Delete an API key permanently. key_id must be obtained from user_api_keys_list first. Any applications using this key will immediately lose access.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    key_id: {
+                        type: 'string',
+                        description: 'The ID of the API key to delete. Use user.api_keys_list to find key IDs.'
+                    }
+                },
+                required: ['key_id']
+            }
+        },
+        metadata: {
+            category: 'api_keys',
+            defaultEnabled: false,
+            adminOnly: false,
+            destructive: true,
+            requiresConfirmation: true,
+            apiEndpoint: '/api/keys/:id',
+            apiMethod: 'DELETE',
+            tags: ['api_keys', 'delete', 'security']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_api_keys_rotate',
+            description: 'Rotate an API key, generating a new key value while keeping the same key ID and settings. The old key becomes invalid immediately.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    key_id: {
+                        type: 'string',
+                        description: 'The ID of the API key to rotate. Use user.api_keys_list to find key IDs.'
+                    }
+                },
+                required: ['key_id']
+            }
+        },
+        metadata: {
+            category: 'api_keys',
+            defaultEnabled: false,
+            adminOnly: false,
+            destructive: true,
+            requiresConfirmation: true,
+            apiEndpoint: '/api/keys/:id/rotate',
+            apiMethod: 'POST',
+            tags: ['api_keys', 'rotate', 'security']
+        }
+    },
+    // ===== MODEL MAPPINGS =====
+    {
+        type: 'function',
+        function: {
+            name: 'user_model_mappings_list',
+            description: 'List all model mappings (aliases) for the current user. Model mappings let you create aliases for models (e.g., map "gpt-4" to "groq/llama-3.3-70b-versatile").',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        metadata: {
+            category: 'mappings',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/user/model-mappings',
+            apiMethod: 'GET',
+            tags: ['mappings', 'list']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_model_mappings_create',
+            description: 'Create a model mapping (alias). When you request the alias model, it will be routed to the target model. Useful for using familiar model names with different providers.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    alias: {
+                        type: 'string',
+                        description: 'The alias name to create (e.g., "gpt-4", "my-model", "fast-model")',
+                        examples: ['gpt-4', 'my-model', 'fast-model']
+                    },
+                    target_model_id: {
+                        type: 'string',
+                        description: 'The actual model to route to (e.g., "groq/llama-3.3-70b-versatile", "openai/gpt-4o")',
+                        examples: ['groq/llama-3.3-70b-versatile', 'openai/gpt-4o']
+                    }
+                },
+                required: ['alias', 'target_model_id']
+            }
+        },
+        metadata: {
+            category: 'mappings',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/user/model-mappings',
+            apiMethod: 'POST',
+            tags: ['mappings', 'create']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_model_mappings_delete',
+            description: 'Delete a model mapping. The alias will no longer route to the target model.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    mapping_id: {
+                        type: 'string',
+                        description: 'The ID of the mapping to delete. Use user.model_mappings_list to find IDs.'
+                    }
+                },
+                required: ['mapping_id']
+            }
+        },
+        metadata: {
+            category: 'mappings',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: true,
+            requiresConfirmation: true,
+            apiEndpoint: '/api/user/model-mappings/:id',
+            apiMethod: 'DELETE',
+            tags: ['mappings', 'delete']
+        }
+    },
+    // ===== ACCOUNT / BILLING =====
+    {
+        type: 'function',
+        function: {
+            name: 'user_account_balance',
+            description: 'Get the current account balance and credit information.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        metadata: {
+            category: 'billing',
+            defaultEnabled: false,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/billing/balance',
+            apiMethod: 'GET',
+            tags: ['billing', 'balance']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_account_usage',
+            description: 'Get usage summary including total requests, tokens, and costs over a time period.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    period: {
+                        type: 'string',
+                        description: 'Time period for usage data',
+                        enum: ['today', 'week', 'month', 'all'],
+                        default: 'month'
+                    }
+                },
+                required: []
+            }
+        },
+        metadata: {
+            category: 'analytics',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/billing/usage/breakdown',
+            apiMethod: 'GET',
+            tags: ['analytics', 'usage']
+        }
+    },
+    // ===== ANALYTICS =====
+    {
+        type: 'function',
+        function: {
+            name: 'user_analytics_errors',
+            description: 'Get error analytics showing error rates, types, and trends. Use to identify and debug API issues.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    period: {
+                        type: 'string',
+                        description: 'Time period for error data',
+                        enum: ['hour', 'day', 'week', 'month'],
+                        default: 'day'
+                    }
+                },
+                required: []
+            }
+        },
+        metadata: {
+            category: 'analytics',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/account/errors',
+            apiMethod: 'GET',
+            tags: ['analytics', 'errors']
+        }
+    },
+    // ===== ALERTS =====
+    {
+        type: 'function',
+        function: {
+            name: 'user_alerts_list',
+            description: 'List all configured alerts for quota limits, error thresholds, cost limits, etc.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        metadata: {
+            category: 'alerts',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/account/alerts',
+            apiMethod: 'GET',
+            tags: ['alerts', 'list']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_alerts_create',
+            description: 'Create a new alert to be notified when certain thresholds are reached (quota warning, error rate, latency, cost).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        description: 'Type of alert',
+                        enum: ['quota_warning', 'error_rate', 'latency', 'cost']
+                    },
+                    threshold: {
+                        type: 'number',
+                        description: 'Threshold value to trigger the alert (e.g., 80 for 80% quota, 5 for 5% error rate)'
+                    },
+                    notification_method: {
+                        type: 'string',
+                        description: 'How to be notified when alert triggers',
+                        enum: ['email', 'webhook'],
+                        default: 'email'
+                    },
+                    webhook_url: {
+                        type: 'string',
+                        description: 'Webhook URL (required if notification_method is webhook)'
+                    }
+                },
+                required: ['type', 'threshold']
+            }
+        },
+        metadata: {
+            category: 'alerts',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/account/alerts',
+            apiMethod: 'POST',
+            tags: ['alerts', 'create']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'user_alerts_delete',
+            description: 'Delete an alert. You will no longer receive notifications for this alert.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    alert_id: {
+                        type: 'string',
+                        description: 'The ID of the alert to delete. Use user.alerts_list to find IDs.'
+                    }
+                },
+                required: ['alert_id']
+            }
+        },
+        metadata: {
+            category: 'alerts',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: true,
+            requiresConfirmation: true,
+            apiEndpoint: '/api/account/alerts/:id',
+            apiMethod: 'DELETE',
+            tags: ['alerts', 'delete']
+        }
+    },
+    // ===== QUOTA =====
+    {
+        type: 'function',
+        function: {
+            name: 'user_quota_status',
+            description: 'Get current quota usage status including limits and remaining allowance for requests, tokens, and cost.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        metadata: {
+            category: 'billing',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/user/quota/status',
+            apiMethod: 'GET',
+            tags: ['quota', 'status']
+        }
+    },
+    // ===== ORGANIZATION SWITCH =====
+    {
+        type: 'function',
+        function: {
+            name: 'user_switch_organization',
+            description: 'Switch the primary organization context. This affects which connections and models are visible by default.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    organization_id: {
+                        type: 'string',
+                        description: 'Organization ID to switch to. Use organizations.list to see available organizations.'
+                    }
+                },
+                required: ['organization_id']
+            }
+        },
+        metadata: {
+            category: 'organizations',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/user/primary-organization',
+            apiMethod: 'PUT',
+            tags: ['organizations', 'switch']
+        }
+    }
+];
+// ============= TOOL EXECUTOR =============
+class UserTools {
+    constructor(registryUrl, apiKey) {
+        this.registryUrl = registryUrl;
+        this.apiKey = apiKey;
+        this.client = axios_1.default.create({
+            baseURL: registryUrl,
+            timeout: 30000,
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+    static getInstance(registryUrl, apiKey) {
+        if (!UserTools.instance && registryUrl && apiKey) {
+            UserTools.instance = new UserTools(registryUrl, apiKey);
+        }
+        if (!UserTools.instance) {
+            throw new Error('UserTools not initialized. Provide registryUrl and apiKey.');
+        }
+        return UserTools.instance;
+    }
+    getTools() {
+        return exports.userToolDefinitions;
+    }
+    async executeTool(toolName, args) {
+        try {
+            switch (toolName) {
+                // API Keys
+                case 'user_api_keys_list':
+                    return await this.listApiKeys();
+                case 'user_api_keys_create':
+                    return await this.createApiKey(args);
+                case 'user_api_keys_delete':
+                    return await this.deleteApiKey(args.key_id);
+                case 'user_api_keys_rotate':
+                    return await this.rotateApiKey(args.key_id);
+                // Model Mappings
+                case 'user_model_mappings_list':
+                    return await this.listMappings();
+                case 'user_model_mappings_create':
+                    return await this.createMapping(args);
+                case 'user_model_mappings_delete':
+                    return await this.deleteMapping(args.mapping_id);
+                // Account
+                case 'user_account_balance':
+                    return await this.getBalance();
+                case 'user_account_usage':
+                    return await this.getUsage(args);
+                // Analytics
+                case 'user_analytics_errors':
+                    return await this.getErrors(args);
+                // Alerts
+                case 'user_alerts_list':
+                    return await this.listAlerts();
+                case 'user_alerts_create':
+                    return await this.createAlert(args);
+                case 'user_alerts_delete':
+                    return await this.deleteAlert(args.alert_id);
+                // Quota
+                case 'user_quota_status':
+                    return await this.getQuotaStatus();
+                // Organization
+                case 'user_switch_organization':
+                    return await this.switchOrganization(args.organization_id);
+                default:
+                    return { success: false, error: `Unknown user tool: ${toolName}` };
+            }
+        }
+        catch (error) {
+            const message = error.response?.data?.error?.message || error.message;
+            return { success: false, error: message };
+        }
+    }
+    // ===== API KEYS =====
+    async listApiKeys() {
+        const response = await this.client.get('/api/keys');
+        const keys = response.data.keys || response.data;
+        if (!keys || keys.length === 0) {
+            return { success: true, output: 'No API keys found.' };
+        }
+        const lines = ['**API Keys:**', ''];
+        keys.forEach((key, i) => {
+            lines.push(`[${i + 1}] ${key.name || 'Unnamed Key'}`);
+            lines.push(`    ID: ${key.id}`);
+            lines.push(`    Prefix: ${key.prefix || key.key_prefix}...`);
+            lines.push(`    Created: ${new Date(key.created_at).toLocaleDateString()}`);
+            if (key.last_used_at) {
+                lines.push(`    Last Used: ${new Date(key.last_used_at).toLocaleDateString()}`);
+            }
+            lines.push('');
+        });
+        return { success: true, output: lines.join('\n') };
+    }
+    async createApiKey(args) {
+        const response = await this.client.post('/api/keys', {
+            name: args.name,
+            expires_in_days: args.expires_in_days
+        });
+        const key = response.data;
+        return {
+            success: true,
+            output: `✅ API Key Created!\n\n**Key:** ${key.key}\n**ID:** ${key.id}\n**Name:** ${key.name || 'Unnamed'}\n\n⚠️ **Save this key now** - you won't be able to see it again!`
+        };
+    }
+    async deleteApiKey(keyId) {
+        await this.client.delete(`/api/keys/${keyId}`);
+        return { success: true, output: `✅ API Key ${keyId} deleted successfully.` };
+    }
+    async rotateApiKey(keyId) {
+        const response = await this.client.post(`/api/keys/${keyId}/rotate`);
+        const key = response.data;
+        return {
+            success: true,
+            output: `✅ API Key Rotated!\n\n**New Key:** ${key.key}\n**ID:** ${key.id}\n\n⚠️ **Save this key now** - the old key is now invalid!`
+        };
+    }
+    // ===== MODEL MAPPINGS =====
+    async listMappings() {
+        const response = await this.client.get('/api/user/model-mappings');
+        const mappings = response.data.mappings || response.data;
+        if (!mappings || mappings.length === 0) {
+            return { success: true, output: 'No model mappings configured.' };
+        }
+        const lines = ['**Model Mappings:**', ''];
+        mappings.forEach((m, i) => {
+            lines.push(`[${i + 1}] "${m.alias}" → ${m.target_model_id}`);
+            lines.push(`    ID: ${m.id}`);
+            lines.push('');
+        });
+        return { success: true, output: lines.join('\n') };
+    }
+    async createMapping(args) {
+        const response = await this.client.post('/api/user/model-mappings', {
+            alias: args.alias,
+            target_model_id: args.target_model_id
+        });
+        return {
+            success: true,
+            output: `✅ Model mapping created!\n\n"${args.alias}" → ${args.target_model_id}`
+        };
+    }
+    async deleteMapping(mappingId) {
+        await this.client.delete(`/api/user/model-mappings/${mappingId}`);
+        return { success: true, output: `✅ Model mapping ${mappingId} deleted.` };
+    }
+    // ===== ACCOUNT =====
+    async getBalance() {
+        const response = await this.client.get('/api/account/balance');
+        const data = response.data;
+        return {
+            success: true,
+            output: `**Account Balance**\n\nBalance: $${data.balance?.toFixed(2) || '0.00'}\nAvailable: $${data.available?.toFixed(2) || '0.00'}\nCurrency: ${data.currency || 'USD'}`
+        };
+    }
+    async getUsage(args) {
+        const response = await this.client.get('/api/billing/usage/breakdown', {
+            params: { period: args.period || 'month' }
+        });
+        const data = response.data;
+        const lines = [`**Usage (${args.period || 'month'})**`, ''];
+        lines.push(`Total Requests: ${data.total_requests || 0}`);
+        lines.push(`Total Tokens: ${data.total_tokens || 0}`);
+        lines.push(`Total Cost: $${data.total_cost?.toFixed(4) || '0.00'}`);
+        return { success: true, output: lines.join('\n') };
+    }
+    // ===== ANALYTICS =====
+    async getErrors(args) {
+        const response = await this.client.get('/api/account/errors', {
+            params: { period: args.period || 'day' }
+        });
+        const data = response.data;
+        const lines = [`**Error Analytics (${args.period || 'day'})**`, ''];
+        lines.push(`Total Errors: ${data.total_errors || 0}`);
+        lines.push(`Error Rate: ${data.error_rate?.toFixed(2) || 0}%`);
+        if (data.by_type && Object.keys(data.by_type).length > 0) {
+            lines.push('', '**By Type:**');
+            Object.entries(data.by_type).forEach(([type, count]) => {
+                lines.push(`  ${type}: ${count}`);
+            });
+        }
+        return { success: true, output: lines.join('\n') };
+    }
+    // ===== ALERTS =====
+    async listAlerts() {
+        const response = await this.client.get('/api/account/alerts');
+        const alerts = response.data.alerts || response.data;
+        if (!alerts || alerts.length === 0) {
+            return { success: true, output: 'No alerts configured.' };
+        }
+        const lines = ['**Alerts:**', ''];
+        alerts.forEach((a, i) => {
+            lines.push(`[${i + 1}] ${a.type} (threshold: ${a.threshold})`);
+            lines.push(`    ID: ${a.id}`);
+            lines.push(`    Notification: ${a.notification_method}`);
+            lines.push(`    Status: ${a.enabled ? 'Enabled' : 'Disabled'}`);
+            lines.push('');
+        });
+        return { success: true, output: lines.join('\n') };
+    }
+    async createAlert(args) {
+        const response = await this.client.post('/api/account/alerts', args);
+        return {
+            success: true,
+            output: `✅ Alert created!\n\nType: ${args.type}\nThreshold: ${args.threshold}\nNotification: ${args.notification_method || 'email'}`
+        };
+    }
+    async deleteAlert(alertId) {
+        await this.client.delete(`/api/account/alerts/${alertId}`);
+        return { success: true, output: `✅ Alert ${alertId} deleted.` };
+    }
+    // ===== QUOTA =====
+    async getQuotaStatus() {
+        const response = await this.client.get('/api/user/quota/status');
+        const data = response.data;
+        const lines = ['**Quota Status**', ''];
+        if (data.daily) {
+            lines.push('**Daily:**');
+            lines.push(`  Requests: ${data.daily.requests_used}/${data.daily.requests_limit || '∞'}`);
+            lines.push(`  Tokens: ${data.daily.tokens_used}/${data.daily.tokens_limit || '∞'}`);
+            lines.push(`  Cost: $${data.daily.cost_used?.toFixed(4) || 0}/$${data.daily.cost_limit || '∞'}`);
+        }
+        if (data.monthly) {
+            lines.push('', '**Monthly:**');
+            lines.push(`  Requests: ${data.monthly.requests_used}/${data.monthly.requests_limit || '∞'}`);
+            lines.push(`  Tokens: ${data.monthly.tokens_used}/${data.monthly.tokens_limit || '∞'}`);
+            lines.push(`  Cost: $${data.monthly.cost_used?.toFixed(4) || 0}/$${data.monthly.cost_limit || '∞'}`);
+        }
+        return { success: true, output: lines.join('\n') };
+    }
+    // ===== ORGANIZATION =====
+    async switchOrganization(orgId) {
+        await this.client.put('/api/user/primary-organization', {
+            organization_id: orgId
+        });
+        return {
+            success: true,
+            output: `✅ Switched to organization ${orgId}`
+        };
+    }
+}
+exports.UserTools = UserTools;
+UserTools.instance = null;
+exports.default = UserTools;
+//# sourceMappingURL=user-tools.js.map