@getverbal/cli 0.7.0 → 0.8.0

package/dist/mcp/server.js

@@ -0,0 +1,689 @@
+/**
+ * Verbal MCP Server with native SDK hooks
+ *
+ * This MCP server provides tools for logging LLM usage to Verbal and can be used
+ * with the hook adapters for transparent SDK integration.
+ *
+ * Based on the MCP Ingestion spec with native SDK hooks support.
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { VerbalIngestor, attachExitHooks } from './ingestor.js';
+import { getRoiMetrics, analyzeSpendingTrend, getModelEfficiency, optimizePromptTool, MCP_TOOLS } from './tools/index.js';
+import { syncFromTokscale } from '../agent-hooks/tokscale.js';
+import { sessionTracker } from './session-tracker.js';
+import { VERSION } from '../version.js';
+// Load configuration from environment
+const config = {
+    apiKey: process.env.VERBAL_API_KEY ?? '',
+    endpoint: process.env.VERBAL_INGEST_URL ?? '',
+    hmacSecret: process.env.VERBAL_HMAC_SECRET,
+    orgId: process.env.VERBAL_ORG_ID,
+    defaultProject: process.env.VERBAL_DEFAULT_PROJECT,
+    defaultProvider: process.env.VERBAL_DEFAULT_PROVIDER,
+    defaultModel: process.env.VERBAL_DEFAULT_MODEL,
+    source: process.env.VERBAL_SOURCE ?? 'mcp',
+    batchSize: Number(process.env.VERBAL_BATCH_SIZE ?? '50'),
+    flushIntervalMs: Number(process.env.VERBAL_FLUSH_INTERVAL_MS ?? '5000'),
+    httpTimeoutMs: Number(process.env.VERBAL_HTTP_TIMEOUT_MS ?? '5000'),
+    gitContextEnabled: process.env.VERBAL_GIT_CONTEXT_ENABLED !== 'false',
+    costCalcEnabled: process.env.VERBAL_COST_CALC_ENABLED !== 'false',
+    maxRetries: Number(process.env.VERBAL_MAX_RETRIES ?? '3'),
+    retryBaseDelayMs: Number(process.env.VERBAL_RETRY_BASE_DELAY_MS ?? '200'),
+    deadLetterPath: process.env.VERBAL_DEAD_LETTER_PATH,
+};
+// Initialize ingestor
+const ingestor = new VerbalIngestor(config);
+attachExitHooks(ingestor);
+// Create MCP server
+const server = new Server({
+    name: 'verbal-mcp',
+    version: VERSION,
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Helper functions
+function ensureString(value) {
+    if (typeof value === 'string' && value.trim().length > 0)
+        return value;
+    return undefined;
+}
+function ensureNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function ensureStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const filtered = value.filter((item) => typeof item === 'string' && item.trim().length > 0);
+    return filtered.length > 0 ? filtered : undefined;
+}
+// ListTools handler — includes ingestion tools + Phase 2 query tools from MCP_TOOLS
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            // Phase 2 query tools (get_roi_metrics, analyze_spending_trend, get_model_efficiency, etc.)
+            ...MCP_TOOLS,
+            // Ingestion tools
+            {
+                name: 'log_prompt',
+                description: 'Log a prompt (and optional response/usage metadata) to Verbal.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['prompt'],
+                    properties: {
+                        prompt: { type: 'string', description: 'The prompt text.' },
+                        response: { type: 'string', description: 'Optional model response.' },
+                        provider: {
+                            type: 'string',
+                            description: 'Provider name (e.g., OpenAI, Anthropic).',
+                        },
+                        model: { type: 'string', description: 'Model identifier.' },
+                        tokens_in: { type: 'number', description: 'Input tokens.' },
+                        tokens_out: { type: 'number', description: 'Output tokens.' },
+                        cache_read_tokens: { type: 'number', description: 'Cache read tokens.' },
+                        cache_write_tokens: { type: 'number', description: 'Cache write tokens.' },
+                        cost: { type: 'number', description: 'Cost in currency units.' },
+                        currency: {
+                            type: 'string',
+                            description: 'Currency code (e.g., USD).',
+                        },
+                        user: {
+                            type: 'string',
+                            description: 'End user or operator identifier.',
+                        },
+                        project: {
+                            type: 'string',
+                            description: 'Project or cost center identifier.',
+                        },
+                        org_id: { type: 'string', description: 'Organization identifier.' },
+                        prompt_name: {
+                            type: 'string',
+                            description: 'Human-friendly prompt name.',
+                        },
+                        prompt_version: { type: 'string', description: 'Prompt version.' },
+                        session_id: { type: 'string', description: 'Session identifier.' },
+                        request_id: { type: 'string', description: 'Upstream request id.' },
+                        response_id: {
+                            type: 'string',
+                            description: 'Upstream response id.',
+                        },
+                        timestamp: { type: 'string', description: 'ISO 8601 timestamp.' },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Tags for grouping/analysis.',
+                        },
+                        metadata: {
+                            type: 'object',
+                            description: 'Additional structured metadata.',
+                        },
+                        conversation_title: {
+                            type: 'string',
+                            description: 'Conversation title for JSON export format.',
+                        },
+                        conversation_id: {
+                            type: 'string',
+                            description: 'Verbal conversation ID to link this event to.',
+                        },
+                        source: { type: 'string', description: 'Capture source identifier.' },
+                        client: { type: 'string', description: 'Capture client identifier.' },
+                    },
+                },
+            },
+            {
+                name: 'log_usage',
+                description: 'Log usage-only events when prompt content is unavailable or excluded.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        provider: {
+                            type: 'string',
+                            description: 'Provider name (e.g., OpenAI, Anthropic).',
+                        },
+                        model: { type: 'string', description: 'Model identifier.' },
+                        tokens_in: { type: 'number', description: 'Input tokens.' },
+                        tokens_out: { type: 'number', description: 'Output tokens.' },
+                        cache_read_tokens: { type: 'number', description: 'Cache read tokens.' },
+                        cache_write_tokens: { type: 'number', description: 'Cache write tokens.' },
+                        cost: { type: 'number', description: 'Cost in currency units.' },
+                        currency: {
+                            type: 'string',
+                            description: 'Currency code (e.g., USD).',
+                        },
+                        user: {
+                            type: 'string',
+                            description: 'End user or operator identifier.',
+                        },
+                        project: {
+                            type: 'string',
+                            description: 'Project or cost center identifier.',
+                        },
+                        org_id: { type: 'string', description: 'Organization identifier.' },
+                        session_id: { type: 'string', description: 'Session identifier.' },
+                        request_id: { type: 'string', description: 'Upstream request id.' },
+                        timestamp: { type: 'string', description: 'ISO 8601 timestamp.' },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Tags for grouping/analysis.',
+                        },
+                        metadata: {
+                            type: 'object',
+                            description: 'Additional structured metadata.',
+                        },
+                        conversation_id: {
+                            type: 'string',
+                            description: 'Verbal conversation ID to link this event to.',
+                        },
+                        source: { type: 'string', description: 'Capture source identifier.' },
+                        client: { type: 'string', description: 'Capture client identifier.' },
+                    },
+                },
+            },
+            {
+                name: 'log_events_bulk',
+                description: 'Log multiple prompt/usage events in a single request.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['events'],
+                    properties: {
+                        events: {
+                            type: 'array',
+                            description: 'Array of prompt/usage events.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    event_type: {
+                                        type: 'string',
+                                        description: 'prompt or usage. If omitted, inferred.',
+                                    },
+                                    prompt: { type: 'string', description: 'The prompt text.' },
+                                    response: {
+                                        type: 'string',
+                                        description: 'Optional model response.',
+                                    },
+                                    provider: {
+                                        type: 'string',
+                                        description: 'Provider name (e.g., OpenAI, Anthropic).',
+                                    },
+                                    model: { type: 'string', description: 'Model identifier.' },
+                                    tokens_in: { type: 'number', description: 'Input tokens.' },
+                                    tokens_out: { type: 'number', description: 'Output tokens.' },
+                                    cost: {
+                                        type: 'number',
+                                        description: 'Cost in currency units.',
+                                    },
+                                    currency: {
+                                        type: 'string',
+                                        description: 'Currency code (e.g., USD).',
+                                    },
+                                    user: {
+                                        type: 'string',
+                                        description: 'End user or operator identifier.',
+                                    },
+                                    project: {
+                                        type: 'string',
+                                        description: 'Project or cost center identifier.',
+                                    },
+                                    org_id: {
+                                        type: 'string',
+                                        description: 'Organization identifier.',
+                                    },
+                                    tags: {
+                                        type: 'array',
+                                        items: { type: 'string' },
+                                        description: 'Tags for grouping/analysis.',
+                                    },
+                                    metadata: {
+                                        type: 'object',
+                                        description: 'Additional structured metadata.',
+                                    },
+                                    cache_read_tokens: { type: 'number', description: 'Cache read tokens.' },
+                                    cache_write_tokens: { type: 'number', description: 'Cache write tokens.' },
+                                    prompt_name: { type: 'string', description: 'Prompt name.' },
+                                    prompt_version: { type: 'string', description: 'Prompt version.' },
+                                    session_id: { type: 'string', description: 'Session identifier.' },
+                                    request_id: { type: 'string', description: 'Request identifier.' },
+                                    response_id: { type: 'string', description: 'Response identifier.' },
+                                    timestamp: { type: 'string', description: 'ISO timestamp.' },
+                                    conversation_id: { type: 'string', description: 'Verbal conversation identifier.' },
+                                    conversation_title: { type: 'string', description: 'Conversation title.' },
+                                    source: { type: 'string', description: 'Capture source.' },
+                                    client: { type: 'string', description: 'Capture client.' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                name: 'sync_tokscale',
+                description: 'Sync usage data from local AI tool sessions via tokscale. Scans Claude Code, Codex, Cursor, Gemini, and other supported platforms.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        since: {
+                            type: 'string',
+                            description: 'Start date (YYYY-MM-DD). Defaults to last sync date.',
+                        },
+                        until: {
+                            type: 'string',
+                            description: 'End date (YYYY-MM-DD). Defaults to today.',
+                        },
+                        platforms: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Platforms to sync (e.g. claude, codex, cursor). Defaults to all.',
+                        },
+                        project: {
+                            type: 'string',
+                            description: 'Project identifier to tag events with.',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'submit_session_review',
+                description: 'Submit a review for a completed AI session. Rate usefulness and estimate time saved.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['session_id', 'usefulness_rating', 'effectiveness_rating', 'time_saved_bucket'],
+                    properties: {
+                        session_id: {
+                            type: 'string',
+                            description: 'The session identifier to review.',
+                        },
+                        usefulness_rating: {
+                            type: 'integer',
+                            minimum: 1,
+                            maximum: 5,
+                            description: 'How useful was the AI assistance? (1=not useful, 5=extremely useful)',
+                        },
+                        effectiveness_rating: {
+                            type: 'integer',
+                            minimum: 1,
+                            maximum: 5,
+                            description: 'How effective were the AI responses? (1=poor, 5=excellent)',
+                        },
+                        time_saved_bucket: {
+                            type: 'string',
+                            enum: ['time_lost', 'none', '0_5min', '6_15min', '16_30min', '31_60min', '60plus_min'],
+                            description: 'Estimated time saved (or lost) compared to working without AI.',
+                        },
+                        improvement_text: {
+                            type: 'string',
+                            description: 'Optional feedback on how the AI could have been more helpful.',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'get_pending_session_reviews',
+                description: 'Get sessions awaiting review.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+        ],
+    };
+});
+// Tool handlers
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const name = request.params.name;
+    const args = (request.params.arguments ?? {});
+    if (name === 'log_prompt') {
+        const prompt = ensureString(args.prompt);
+        if (!prompt) {
+            throw new Error('log_prompt requires a non-empty prompt string');
+        }
+        const event = {
+            event_type: 'prompt',
+            prompt,
+            response: ensureString(args.response),
+            provider: ensureString(args.provider),
+            model: ensureString(args.model),
+            tokens_in: ensureNumber(args.tokens_in),
+            tokens_out: ensureNumber(args.tokens_out),
+            cache_read_tokens: ensureNumber(args.cache_read_tokens),
+            cache_write_tokens: ensureNumber(args.cache_write_tokens),
+            cost: ensureNumber(args.cost),
+            currency: ensureString(args.currency),
+            user: ensureString(args.user),
+            project: ensureString(args.project),
+            org_id: ensureString(args.org_id),
+            prompt_name: ensureString(args.prompt_name),
+            prompt_version: ensureString(args.prompt_version),
+            session_id: ensureString(args.session_id),
+            request_id: ensureString(args.request_id),
+            response_id: ensureString(args.response_id),
+            timestamp: ensureString(args.timestamp),
+            tags: ensureStringArray(args.tags),
+            metadata: typeof args.metadata === 'object' && args.metadata !== null
+                ? args.metadata
+                : undefined,
+            conversation_id: ensureString(args.conversation_id),
+            conversation_title: ensureString(args.conversation_title),
+            source: ensureString(args.source),
+            client: ensureString(args.client),
+        };
+        await ingestor.track(event);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Logged prompt event ${event.event_id}`,
+                },
+            ],
+        };
+    }
+    if (name === 'log_usage') {
+        const tokensIn = ensureNumber(args.tokens_in);
+        const tokensOut = ensureNumber(args.tokens_out);
+        const cost = ensureNumber(args.cost);
+        if (tokensIn === undefined && tokensOut === undefined && cost === undefined) {
+            throw new Error('log_usage requires tokens_in, tokens_out, or cost');
+        }
+        const event = {
+            event_type: 'usage',
+            provider: ensureString(args.provider),
+            model: ensureString(args.model),
+            tokens_in: tokensIn,
+            tokens_out: tokensOut,
+            cache_read_tokens: ensureNumber(args.cache_read_tokens),
+            cache_write_tokens: ensureNumber(args.cache_write_tokens),
+            cost,
+            currency: ensureString(args.currency),
+            user: ensureString(args.user),
+            project: ensureString(args.project),
+            org_id: ensureString(args.org_id),
+            session_id: ensureString(args.session_id),
+            request_id: ensureString(args.request_id),
+            timestamp: ensureString(args.timestamp),
+            tags: ensureStringArray(args.tags),
+            metadata: typeof args.metadata === 'object' && args.metadata !== null
+                ? args.metadata
+                : undefined,
+            conversation_id: ensureString(args.conversation_id),
+            source: ensureString(args.source),
+            client: ensureString(args.client),
+        };
+        await ingestor.track(event);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Logged usage event ${event.event_id}`,
+                },
+            ],
+        };
+    }
+    if (name === 'log_events_bulk') {
+        const eventsArg = args.events;
+        if (!Array.isArray(eventsArg)) {
+            throw new Error('log_events_bulk requires an events array');
+        }
+        let successCount = 0;
+        let errorCount = 0;
+        for (const eventData of eventsArg) {
+            if (typeof eventData !== 'object' ||
+                eventData === null ||
+                Array.isArray(eventData)) {
+                errorCount++;
+                continue;
+            }
+            const eventArgs = eventData;
+            const eventType = ensureString(eventArgs.event_type);
+            // Determine event type
+            const isPromptEvent = eventType === 'prompt' || ensureString(eventArgs.prompt);
+            const event = {
+                event_type: isPromptEvent ? 'prompt' : 'usage',
+                prompt: ensureString(eventArgs.prompt),
+                response: ensureString(eventArgs.response),
+                provider: ensureString(eventArgs.provider),
+                model: ensureString(eventArgs.model),
+                tokens_in: ensureNumber(eventArgs.tokens_in),
+                tokens_out: ensureNumber(eventArgs.tokens_out),
+                cost: ensureNumber(eventArgs.cost),
+                currency: ensureString(eventArgs.currency),
+                user: ensureString(eventArgs.user),
+                project: ensureString(eventArgs.project),
+                org_id: ensureString(eventArgs.org_id),
+                tags: ensureStringArray(eventArgs.tags),
+                cache_read_tokens: ensureNumber(eventArgs.cache_read_tokens),
+                cache_write_tokens: ensureNumber(eventArgs.cache_write_tokens),
+                prompt_name: ensureString(eventArgs.prompt_name),
+                prompt_version: ensureString(eventArgs.prompt_version),
+                session_id: ensureString(eventArgs.session_id),
+                request_id: ensureString(eventArgs.request_id),
+                response_id: ensureString(eventArgs.response_id),
+                timestamp: ensureString(eventArgs.timestamp),
+                conversation_id: ensureString(eventArgs.conversation_id),
+                conversation_title: ensureString(eventArgs.conversation_title),
+                source: ensureString(eventArgs.source),
+                client: ensureString(eventArgs.client),
+                metadata: typeof eventArgs.metadata === 'object' && eventArgs.metadata !== null
+                    ? eventArgs.metadata
+                    : undefined,
+            };
+            try {
+                await ingestor.track(event);
+                successCount++;
+            }
+            catch (error) {
+                errorCount++;
+                console.error('[MCP] Failed to track event:', error);
+            }
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Bulk ingest complete. sent=${successCount}, failed=${errorCount}`,
+                },
+            ],
+        };
+    }
+    // Phase 2 Tools - ROI Metrics
+    if (name === 'get_roi_metrics') {
+        const apiKey = process.env.VERBAL_API_KEY || '';
+        const apiUrl = process.env.VERBAL_API_URL || 'http://localhost:3000';
+        if (!apiKey) {
+            throw new Error('VERBAL_API_KEY environment variable not set');
+        }
+        const timeframe = args.timeframe || '30d';
+        const result = await getRoiMetrics(apiKey, apiUrl, { timeframe: timeframe });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    }
+    if (name === 'analyze_spending_trend') {
+        const apiKey = process.env.VERBAL_API_KEY || '';
+        const apiUrl = process.env.VERBAL_API_URL || 'http://localhost:3000';
+        if (!apiKey) {
+            throw new Error('VERBAL_API_KEY environment variable not set');
+        }
+        const timeframe = args.timeframe || '30d';
+        const metric = args.metric || 'cost';
+        const result = await analyzeSpendingTrend(apiKey, apiUrl, {
+            timeframe: timeframe,
+            metric: metric
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    }
+    if (name === 'get_model_efficiency') {
+        const apiKey = process.env.VERBAL_API_KEY || '';
+        const apiUrl = process.env.VERBAL_API_URL || 'http://localhost:3000';
+        if (!apiKey) {
+            throw new Error('VERBAL_API_KEY environment variable not set');
+        }
+        const timeframe = args.timeframe || '30d';
+        const result = await getModelEfficiency(apiKey, apiUrl, { timeframe: timeframe });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    }
+    if (name === 'sync_tokscale') {
+        const syncConfig = {
+            apiKey: config.apiKey,
+            ingestUrl: config.endpoint,
+            hmacSecret: config.hmacSecret ?? undefined,
+            orgId: config.orgId ?? undefined,
+            batchSize: config.batchSize,
+            flushIntervalMs: 0,
+            httpTimeoutMs: config.httpTimeoutMs,
+            stateDir: path.join(os.homedir(), '.claude', 'verbal-logs'),
+        };
+        const syncOptions = {
+            since: typeof args.since === 'string' ? args.since : undefined,
+            until: typeof args.until === 'string' ? args.until : undefined,
+            platforms: Array.isArray(args.platforms)
+                ? args.platforms.filter((p) => typeof p === 'string')
+                : undefined,
+            project: typeof args.project === 'string' ? args.project : config.defaultProject,
+        };
+        const result = await syncFromTokscale(syncConfig, syncOptions);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Tokscale sync complete: ${result.events} events, ${result.days} days, $${result.totalCost.toFixed(2)} total cost`,
+                },
+            ],
+        };
+    }
+    if (name === 'submit_session_review') {
+        const sessionId = ensureString(args.session_id);
+        if (!sessionId) {
+            throw new Error('submit_session_review requires a non-empty session_id');
+        }
+        const usefulnessRating = ensureNumber(args.usefulness_rating);
+        const effectivenessRating = ensureNumber(args.effectiveness_rating);
+        const timeSavedBucket = ensureString(args.time_saved_bucket);
+        if (usefulnessRating === undefined || effectivenessRating === undefined || !timeSavedBucket) {
+            throw new Error('submit_session_review requires usefulness_rating, effectiveness_rating, and time_saved_bucket');
+        }
+        const ratings = {
+            usefulness_rating: usefulnessRating,
+            effectiveness_rating: effectivenessRating,
+            time_saved_bucket: timeSavedBucket,
+            improvement_text: ensureString(args.improvement_text),
+        };
+        await sessionTracker.submitReview(sessionId, ratings);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Session review submitted for session ${sessionId}`,
+                },
+            ],
+        };
+    }
+    if (name === 'get_pending_session_reviews') {
+        const pending = await sessionTracker.getPendingReviews();
+        if (pending.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No sessions pending review.',
+                    },
+                ],
+            };
+        }
+        const lines = pending.map((s) => `- session_id: ${s.session_id} | start: ${s.session_start} | end: ${s.session_end} | events: ${s.event_count}`);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${pending.length} session(s) pending review:\n${lines.join('\n')}`,
+                },
+            ],
+        };
+    }
+    if (name === 'optimize_prompt') {
+        const apiKey = process.env.VERBAL_API_KEY || '';
+        const apiUrl = process.env.VERBAL_API_URL || 'http://localhost:3000';
+        if (!apiKey) {
+            throw new Error('VERBAL_API_KEY environment variable not set');
+        }
+        const prompt = ensureString(args.prompt);
+        if (!prompt) {
+            throw new Error('optimize_prompt requires a non-empty prompt string');
+        }
+        const context = ensureString(args.context);
+        const thresholdRaw = ensureNumber(args.threshold);
+        const result = await optimizePromptTool({ prompt, context, threshold: thresholdRaw }, apiKey, apiUrl);
+        if (!result.available) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Prompt optimization is not available on your current plan. Upgrade at ${result.upgrade_url ?? '/pricing'}`,
+                    },
+                ],
+            };
+        }
+        let text = `Prompt score: ${result.original_score}/100`;
+        if (result.optimized_prompt) {
+            text += `\nImprovement: +${result.improvement_delta} points\nOptimized prompt:\n\n${result.optimized_prompt}`;
+        }
+        else if (result.rewrite_triggered) {
+            text += '\nRewrite attempted but did not improve the prompt. Original is already good.';
+        }
+        else {
+            text += '\nPrompt is already strong (above threshold). No rewrite needed.';
+        }
+        if (result.issues && result.issues.length > 0) {
+            text += `\nIssues detected: ${result.issues.join(', ')}`;
+        }
+        return {
+            content: [{ type: 'text', text }],
+        };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+});
+// Exported entry point — called by CLI `getverbal mcp-serve`
+export async function startMcpServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[MCP] Verbal MCP server started with native SDK hooks support');
+    console.error(`[MCP] Ingesting to: ${config.endpoint || '(not configured)'}`);
+}
+// Auto-start when run directly (backwards compat during transition)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    startMcpServer().catch((err) => {
+        console.error('[MCP] Fatal error:', err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=server.js.map