@hailer/mcp 0.2.7 → 1.0.21

package/dist/mcp/tools/metrics.js

@@ -0,0 +1,546 @@
+"use strict";
+/**
+ * Victoria Metrics Tools - Query and List Metrics
+ *
+ * Tools for querying Hailer metrics from Victoria Metrics:
+ * - Query metrics with PromQL (READ)
+ * - List available metrics (READ)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchUserForMetricsTool = exports.searchWorkspaceForMetricsTool = exports.listMetricsTool = exports.queryMetricTool = void 0;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const index_1 = require("../utils/index");
+const axios_1 = __importDefault(require("axios"));
+const hailer_clients_1 = require("../hailer-clients");
+const logger = (0, index_1.createLogger)({ component: 'metrics-tools' });
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+const METRICS_CONFIG = {
+    host: process.env.METRICS_QUERY_HOST || 'observer.hailer.com',
+    port: Number(process.env.METRICS_QUERY_PORT) || 443,
+    secure: process.env.METRICS_QUERY_SECURE !== 'false',
+    user: process.env.METRICS_QUERY_USER || 'metrics',
+    password: process.env.METRICS_QUERY_PASSWORD || 'verysecuremetricspassword42',
+};
+// Metrics Admin API credentials (for workspace/user search - requires whitelisted user)
+const METRICS_ADMIN_CONFIG = {
+    email: process.env.METRICS_ADMIN_EMAIL || '',
+    password: process.env.METRICS_ADMIN_PASSWORD || '',
+    apiBaseUrl: process.env.METRICS_ADMIN_API_URL || 'https://api.hailer.com',
+};
+logger.info('Metrics admin config loaded', {
+    email: METRICS_ADMIN_CONFIG.email || '(not set)',
+    apiBaseUrl: METRICS_ADMIN_CONFIG.apiBaseUrl,
+    hasPassword: !!METRICS_ADMIN_CONFIG.password,
+});
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+// Cached admin client for metrics operations
+let metricsAdminClient = null;
+let metricsAdminManager = null;
+/**
+ * Get or create metrics admin client for privileged operations
+ */
+async function getMetricsAdminClient() {
+    if (!METRICS_ADMIN_CONFIG.email || !METRICS_ADMIN_CONFIG.password) {
+        throw new Error('METRICS_ADMIN_EMAIL and METRICS_ADMIN_PASSWORD must be set for workspace/user search');
+    }
+    // Return cached client if connected
+    if (metricsAdminClient && metricsAdminManager?.isConnected()) {
+        return metricsAdminClient;
+    }
+    // Clean up stale connection
+    if (metricsAdminManager) {
+        metricsAdminManager.disconnect();
+    }
+    logger.info('Creating metrics admin connection', {
+        email: METRICS_ADMIN_CONFIG.email,
+        apiBaseUrl: METRICS_ADMIN_CONFIG.apiBaseUrl,
+    });
+    // Create new connection using WebSocket (same as regular clients)
+    metricsAdminManager = new hailer_clients_1.HailerClientManager(METRICS_ADMIN_CONFIG.apiBaseUrl, METRICS_ADMIN_CONFIG.email, METRICS_ADMIN_CONFIG.password);
+    metricsAdminClient = await metricsAdminManager.connect();
+    logger.info('Metrics admin connected successfully');
+    return metricsAdminClient;
+}
+/**
+ * Make admin API request with special credentials via WebSocket
+ */
+async function metricsAdminRequest(method, params) {
+    const client = await getMetricsAdminClient();
+    return client.socket.request(method, params);
+}
+/**
+ * Get Victoria Metrics base URL
+ */
+function getMetricsBaseUrl() {
+    const protocol = METRICS_CONFIG.secure ? 'https' : 'http';
+    const port = METRICS_CONFIG.port !== (METRICS_CONFIG.secure ? 443 : 80)
+        ? `:${METRICS_CONFIG.port}`
+        : '';
+    return `${protocol}://${METRICS_CONFIG.host}${port}`;
+}
+/**
+ * Get Basic Auth credentials
+ */
+function getAuthHeader() {
+    return {
+        username: METRICS_CONFIG.user,
+        password: METRICS_CONFIG.password,
+    };
+}
+/**
+ * Parse time range string to PromQL duration
+ */
+function parseTimeRange(timeRange) {
+    const validRanges = ['1h', '24h', '3d', '7d', '30d'];
+    if (!validRanges.includes(timeRange)) {
+        throw new Error(`Invalid time range "${timeRange}". Valid options: ${validRanges.join(', ')}`);
+    }
+    return timeRange;
+}
+/**
+ * Build PromQL query from parameters
+ */
+function buildPromQLQuery(metric, timeRange, aggregation, groupBy, filters) {
+    // Build label filters
+    let labelFilters = '';
+    if (filters && Object.keys(filters).length > 0) {
+        const filterPairs = Object.entries(filters).map(([key, value]) => `${key}="${value}"`);
+        labelFilters = filterPairs.join(',');
+    }
+    // Build metric selector
+    const metricSelector = labelFilters
+        ? `${metric}{${labelFilters}}`
+        : metric;
+    // Build aggregation with groupBy
+    const groupByClause = groupBy && groupBy.length > 0
+        ? ` by (${groupBy.join(', ')})`
+        : '';
+    // Build final query
+    const query = `${aggregation}${groupByClause} (increase(${metricSelector}[${timeRange}]))`;
+    return query;
+}
+/**
+ * Format query results for display
+ */
+function formatQueryResults(data) {
+    if (!data || !data.result || data.result.length === 0) {
+        return {
+            formatted: 'No data returned for this query.',
+            raw: data,
+        };
+    }
+    // Single value result
+    if (data.result.length === 1 && !data.result[0].metric) {
+        const value = data.result[0].value[1];
+        return {
+            formatted: `Result: ${value}`,
+            raw: { value: Number(value) },
+        };
+    }
+    // Multiple values or grouped results
+    const results = data.result.map((item) => {
+        const labels = item.metric || {};
+        const value = item.value[1];
+        return {
+            labels,
+            value: Number(value),
+        };
+    });
+    // Format as table
+    let formatted = `Found ${results.length} result(s):\n\n`;
+    for (const result of results) {
+        const labelStr = Object.entries(result.labels)
+            .map(([k, v]) => `${k}="${v}"`)
+            .join(', ');
+        formatted += `- ${labelStr ? `{${labelStr}}` : 'total'}: ${result.value}\n`;
+    }
+    return {
+        formatted,
+        raw: results,
+    };
+}
+// ============================================================================
+// TOOL 1: QUERY METRIC
+// ============================================================================
+/**
+ * Generate ASCII bar chart from data
+ */
+function generateAsciiChart(data, options = {}) {
+    const { maxWidth = 40, showPercent = true } = options;
+    if (data.length === 0)
+        return 'No data to display';
+    const maxValue = Math.max(...data.map(d => d.value));
+    const total = data.reduce((sum, d) => sum + d.value, 0);
+    // Find max label length for alignment
+    const maxLabelLen = Math.max(...data.map(d => d.label.length), 10);
+    const lines = data.map(item => {
+        const barLength = maxValue > 0 ? Math.round((item.value / maxValue) * maxWidth) : 0;
+        const bar = '█'.repeat(barLength);
+        const label = item.label.padEnd(maxLabelLen);
+        const valueStr = item.value.toLocaleString();
+        const percent = showPercent && total > 0
+            ? ` (${Math.round(item.value / total * 100)}%)`
+            : '';
+        return `${label} ${bar} ${valueStr}${percent}`;
+    });
+    return lines.join('\n');
+}
+/**
+ * Format grouped results as ASCII chart
+ */
+function formatAsChart(data, groupByLabel) {
+    if (!data || !data.result || data.result.length === 0) {
+        return 'No data to display';
+    }
+    const chartData = data.result
+        .map((item) => ({
+        label: item.metric?.[groupByLabel] || 'unknown',
+        value: Math.round(parseFloat(item.value?.[1] || 0)),
+    }))
+        .filter((item) => item.value > 0)
+        .sort((a, b) => b.value - a.value)
+        .slice(0, 10); // Top 10
+    const total = chartData.reduce((sum, d) => sum + d.value, 0);
+    let output = generateAsciiChart(chartData);
+    output += `\n\nTotal: ${total.toLocaleString()}`;
+    return output;
+}
+// ============================================================================
+// TOOL 1: QUERY METRIC
+// ============================================================================
+exports.queryMetricTool = {
+    name: 'query_metric',
+    group: tool_registry_1.ToolGroup.READ,
+    description: `Query metrics from Victoria Metrics using PromQL. Available metrics:
+- hailer.activity.create - Activities created (labels: workspace, process, team, userRole)
+- hailer.message.create - Messages sent (labels: workspace, discussion, userRole)
+- hailer.file.upload - Files uploaded (labels: workspace)
+- hailer.telemetry - UI events (labels: workspace, user, element)
+
+Supports ASCII chart visualization for grouped data (format: "chart")`,
+    schema: zod_1.z.object({
+        metric: zod_1.z.string().describe('Metric name (e.g., "hailer.activity.create")'),
+        timeRange: zod_1.z.enum(['1h', '24h', '3d', '7d', '30d']).optional().default('24h').describe('Time range: 1h, 24h, 3d, 7d, 30d'),
+        aggregation: zod_1.z.enum(['sum', 'avg', 'max', 'min', 'count']).optional().default('sum').describe('Aggregation function'),
+        groupBy: zod_1.z.preprocess((val) => {
+            if (typeof val === 'string') {
+                try {
+                    return JSON.parse(val);
+                }
+                catch {
+                    return val.split(',').map(s => s.trim()).filter(Boolean);
+                }
+            }
+            return val;
+        }, zod_1.z.array(zod_1.z.string()).optional()).describe('Group by labels like ["workspace", "process"] (optional)'),
+        filters: zod_1.z.preprocess((val) => typeof val === 'string' ? JSON.parse(val) : val, zod_1.z.record(zod_1.z.string()).optional()).describe('Label filters like { "workspace": "abc123", "userRole": "admin" } (optional)'),
+        format: zod_1.z.enum(["json", "chart"]).optional().default("json").describe("Output format: 'json' for raw data, 'chart' for ASCII bar chart"),
+    }),
+    async execute(args, _context) {
+        try {
+            logger.info('Querying metric', {
+                metric: args.metric,
+                timeRange: args.timeRange,
+                aggregation: args.aggregation,
+                groupBy: args.groupBy,
+                filters: args.filters,
+            });
+            // Parse and validate time range
+            const timeRange = parseTimeRange(args.timeRange || '24h');
+            // Build PromQL query
+            const promqlQuery = buildPromQLQuery(args.metric, timeRange, args.aggregation || 'sum', args.groupBy, args.filters);
+            logger.debug('Built PromQL query', { query: promqlQuery });
+            // Execute query
+            const baseUrl = getMetricsBaseUrl();
+            const url = `${baseUrl}/api/v1/query`;
+            const response = await axios_1.default.get(url, {
+                params: { query: promqlQuery },
+                auth: getAuthHeader(),
+                timeout: 10000,
+            });
+            if (response.data.status !== 'success') {
+                throw new Error(`Query failed: ${response.data.error || 'Unknown error'}`);
+            }
+            // Format results
+            const { formatted, raw } = formatQueryResults(response.data.data);
+            // Format output based on requested format
+            const format = args.format || 'json';
+            let responseText;
+            if (format === 'chart' && args.groupBy && args.groupBy.length > 0) {
+                // ASCII chart for grouped data
+                const chartTitle = `📊 ${args.metric} by ${args.groupBy[0]} (${args.timeRange})\n${'─'.repeat(50)}\n`;
+                responseText = chartTitle + formatAsChart(response.data.data, args.groupBy[0]);
+            }
+            else {
+                // JSON format (default)
+                responseText = `📊 **Metric Query Results**
+
+**Query:** \`${promqlQuery}\`
+**Time Range:** ${args.timeRange}
+**Aggregation:** ${args.aggregation}
+
+${formatted}
+
+**Raw Data:**
+\`\`\`json
+${JSON.stringify(raw, null, 2)}
+\`\`\``;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to query metric', error, {
+                metric: args.metric,
+                timeRange: args.timeRange,
+            });
+            const errorMessage = error instanceof Error
+                ? error.message
+                : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to query metric: ${errorMessage}\n\n💡 **Troubleshooting:**\n- Verify the metric name is correct (use list_metrics to see available metrics)\n- Check time range is valid (1h, 24h, 3d, 7d, 30d)\n- Ensure filters match existing labels\n- Verify Victoria Metrics connection settings`,
+                    },
+                ],
+            };
+        }
+    },
+};
+// ============================================================================
+// TOOL 2: LIST METRICS
+// ============================================================================
+exports.listMetricsTool = {
+    name: 'list_metrics',
+    group: tool_registry_1.ToolGroup.READ,
+    description: 'List all available Hailer metrics from Victoria Metrics',
+    schema: zod_1.z.object({}),
+    async execute(_args, _context) {
+        try {
+            logger.info('Listing available metrics');
+            // Query Victoria Metrics for all metric names
+            const baseUrl = getMetricsBaseUrl();
+            const url = `${baseUrl}/api/v1/label/__name__/values`;
+            const response = await axios_1.default.get(url, {
+                auth: getAuthHeader(),
+                timeout: 10000,
+            });
+            if (response.data.status !== 'success') {
+                throw new Error(`Query failed: ${response.data.error || 'Unknown error'}`);
+            }
+            const metrics = response.data.data || [];
+            // Filter for Hailer metrics only
+            const hailerMetrics = metrics.filter((m) => m.startsWith('hailer.'));
+            // Group metrics by category
+            const categorized = {
+                activity: [],
+                message: [],
+                file: [],
+                telemetry: [],
+                other: [],
+            };
+            for (const metric of hailerMetrics) {
+                if (metric.includes('activity')) {
+                    categorized.activity.push(metric);
+                }
+                else if (metric.includes('message')) {
+                    categorized.message.push(metric);
+                }
+                else if (metric.includes('file')) {
+                    categorized.file.push(metric);
+                }
+                else if (metric.includes('telemetry')) {
+                    categorized.telemetry.push(metric);
+                }
+                else {
+                    categorized.other.push(metric);
+                }
+            }
+            // Format output
+            let formatted = `📊 **Available Hailer Metrics** (${hailerMetrics.length} total)\n\n`;
+            if (categorized.activity.length > 0) {
+                formatted += `**Activity Metrics:**\n`;
+                for (const metric of categorized.activity) {
+                    formatted += `- \`${metric}\` - Activities created/updated\n`;
+                }
+                formatted += '\n';
+            }
+            if (categorized.message.length > 0) {
+                formatted += `**Message Metrics:**\n`;
+                for (const metric of categorized.message) {
+                    formatted += `- \`${metric}\` - Messages and discussions\n`;
+                }
+                formatted += '\n';
+            }
+            if (categorized.file.length > 0) {
+                formatted += `**File Metrics:**\n`;
+                for (const metric of categorized.file) {
+                    formatted += `- \`${metric}\` - File uploads and operations\n`;
+                }
+                formatted += '\n';
+            }
+            if (categorized.telemetry.length > 0) {
+                formatted += `**Telemetry Metrics:**\n`;
+                for (const metric of categorized.telemetry) {
+                    formatted += `- \`${metric}\` - UI events and user interactions\n`;
+                }
+                formatted += '\n';
+            }
+            if (categorized.other.length > 0) {
+                formatted += `**Other Metrics:**\n`;
+                for (const metric of categorized.other) {
+                    formatted += `- \`${metric}\`\n`;
+                }
+                formatted += '\n';
+            }
+            formatted += `\n💡 **Usage:**\nUse \`query_metric\` with any of these metric names to query data.\n\n`;
+            formatted += `**Common Labels:**\n- workspace: Workspace ID\n- process: Workflow ID\n- team: Team ID\n- userRole: User role (admin, member, etc.)\n- discussion: Discussion ID\n- user: User ID\n- element: UI element name`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: formatted,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list metrics', error);
+            const errorMessage = error instanceof Error
+                ? error.message
+                : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to list metrics: ${errorMessage}\n\n💡 **Troubleshooting:**\n- Verify Victoria Metrics connection settings\n- Check network connectivity to ${METRICS_CONFIG.host}\n- Ensure credentials are correct`,
+                    },
+                ],
+            };
+        }
+    },
+};
+// ============================================================================
+// TOOL 3: SEARCH WORKSPACE FOR METRICS
+// ============================================================================
+exports.searchWorkspaceForMetricsTool = {
+    name: 'search_workspace_for_metrics',
+    group: tool_registry_1.ToolGroup.READ,
+    description: `Search for workspaces by name to get their IDs for metric queries.
+Use this tool when user mentions a workspace by name (e.g. "Sales Team") to find its ID for filtering metrics.`,
+    schema: zod_1.z.object({
+        name: zod_1.z.string().min(3).describe("Workspace name to search (min 3 characters)"),
+        limit: zod_1.z.number().min(1).max(100).optional().default(20).describe("Maximum results to return (default 20, max 100)"),
+    }),
+    async execute(args, _context) {
+        try {
+            logger.info('Searching workspace for metrics', { name: args.name });
+            // Use admin credentials for this privileged operation
+            const result = await metricsAdminRequest('v3.metrics.workspaceSearch', [{ name: args.name }]);
+            if (!result || result.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `No workspaces found matching "${args.name}"`,
+                        }],
+                };
+            }
+            const totalCount = result.length;
+            const limitedResults = result.slice(0, args.limit || 20);
+            const workspaceList = limitedResults
+                .map((ws) => `- ${ws.name} (ID: ${ws._id})`)
+                .join('\n');
+            const truncationNote = totalCount > limitedResults.length
+                ? `\n\n⚠️ Showing ${limitedResults.length} of ${totalCount} results. Use a more specific search term or increase limit.`
+                : '';
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Found ${totalCount} workspace(s)${totalCount > limitedResults.length ? ` (showing first ${limitedResults.length})` : ''}:\n${workspaceList}${truncationNote}\n\n💡 Use the ID in metric queries with filters: { "workspace": "ID" }`,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to search workspaces for metrics', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Error searching workspaces: ${errorMessage}`,
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// TOOL 4: SEARCH USER FOR METRICS
+// ============================================================================
+exports.searchUserForMetricsTool = {
+    name: 'search_user_for_metrics',
+    group: tool_registry_1.ToolGroup.READ,
+    description: `Look up user details by ID for metric analysis.
+Use this after getting user IDs from grouped metric results to see who they are.`,
+    schema: zod_1.z.object({
+        userIds: zod_1.z.preprocess((val) => {
+            if (typeof val === 'string') {
+                try {
+                    return JSON.parse(val);
+                }
+                catch {
+                    return val.split(',').map(s => s.trim()).filter(Boolean);
+                }
+            }
+            return val;
+        }, zod_1.z.array(zod_1.z.string())).describe("Array of user IDs to look up"),
+    }),
+    async execute(args, _context) {
+        try {
+            logger.info('Looking up users for metrics', { userIds: args.userIds });
+            // Use admin credentials for this privileged operation
+            const result = await metricsAdminRequest('v3.metrics.user.list', [{ userIds: args.userIds }]);
+            if (!result || result.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `No users found for provided IDs`,
+                        }],
+                };
+            }
+            const userList = result
+                .map((user) => `- ${user.name || 'No name'} (${user.email || 'no email'}) - ID: ${user._id}`)
+                .join('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Found ${result.length} user(s):\n${userList}`,
+                    }],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to look up users for metrics', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Error looking up users: ${errorMessage}`,
+                    }],
+            };
+        }
+    },
+};
+//# sourceMappingURL=metrics.js.map

package/dist/mcp/tools/user.d.ts

@@ -7,4 +7,5 @@
  */
 import { Tool } from '../tool-registry';
 export declare const searchWorkspaceUsersTool: Tool;
+export declare const getWorkspaceBalanceTool: Tool;
 //# sourceMappingURL=user.d.ts.map

package/dist/mcp/tools/user.js

@@ -7,7 +7,7 @@
  * - Get initialization data (READ) - currently disabled
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchWorkspaceUsersTool = void 0;
+exports.getWorkspaceBalanceTool = exports.searchWorkspaceUsersTool = void 0;
 const zod_1 = require("zod");
 const tool_registry_1 = require("../tool-registry");
 const index_1 = require("../utils/index");
@@ -80,4 +80,97 @@ exports.searchWorkspaceUsersTool = {
         }
     },
 };
+// ============================================================================
+// TOOL 2: GET WORKSPACE BALANCE
+// ============================================================================
+const getWorkspaceBalanceDescription = `Check the current token balance for the workspace. Use this when users ask about their balance, credits, or usage limits.`;
+exports.getWorkspaceBalanceTool = {
+    name: 'get_workspace_balance',
+    group: tool_registry_1.ToolGroup.READ,
+    description: getWorkspaceBalanceDescription,
+    schema: zod_1.z.object({
+        workspaceId: zod_1.z
+            .string()
+            .optional()
+            .describe("The workspace ID to check balance for. If not provided, uses the current workspace context."),
+    }),
+    async execute(args, context) {
+        logger.debug('Checking workspace balance', {
+            workspaceId: args.workspaceId,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        try {
+            // Get workspace ID from args or default to current workspace
+            const workspaceId = (0, tool_helpers_1.getResolvedWorkspaceId)(args, context);
+            if (!workspaceId) {
+                return (0, tool_helpers_1.missingWorkspaceCacheResponse)();
+            }
+            // Call the Hailer API to get token balance
+            const result = await context.hailer.request('v3.mcp.getTokenBalance', [workspaceId]);
+            // Parse the balance from response
+            const balance = typeof result?.balance === "number" ? result.balance :
+                typeof result === "number" ? result : 0;
+            // Determine status
+            let status;
+            let hasBalance;
+            if (balance < 0) {
+                status = 'NEGATIVE';
+                hasBalance = false;
+            }
+            else if (balance === 0) {
+                status = 'EMPTY';
+                hasBalance = false;
+            }
+            else if (balance < 100) {
+                status = 'LOW';
+                hasBalance = true;
+            }
+            else {
+                status = 'OK';
+                hasBalance = true;
+            }
+            // Format the balance with commas for readability
+            const formattedBalance = balance.toLocaleString();
+            // Build response message
+            let message;
+            if (status === 'OK') {
+                message = `Workspace has ${formattedBalance} tokens available`;
+            }
+            else if (status === 'LOW') {
+                message = `Workspace balance is low: ${formattedBalance} tokens remaining`;
+            }
+            else if (status === 'EMPTY') {
+                message = `Workspace has no tokens available`;
+            }
+            else {
+                message = `Workspace balance is negative: ${formattedBalance} tokens`;
+            }
+            const response = {
+                balance,
+                status,
+                hasBalance,
+                message,
+                workspaceId,
+            };
+            logger.debug('Workspace balance retrieved', {
+                workspaceId,
+                balance,
+                status
+            });
+            // Return formatted response
+            const statusEmoji = status === 'OK' ? '✅' :
+                status === 'LOW' ? '⚠️' :
+                    '❌';
+            return (0, index_1.textResponse)(`${statusEmoji} **Workspace Balance**\n\n` +
+                `- Balance: **${formattedBalance}** tokens\n` +
+                `- Status: ${status}\n` +
+                `- Has sufficient balance: ${hasBalance ? 'Yes' : 'No'}\n\n` +
+                `${message}`);
+        }
+        catch (error) {
+            logger.error("Error checking workspace balance", error);
+            return (0, index_1.errorResponse)(`Error checking workspace balance: ${(0, index_1.getErrorMessage)(error)}`);
+        }
+    },
+};
 //# sourceMappingURL=user.js.map