@hotmeshio/long-tail 0.1.0

package/build/system/mcp-servers/db-query/tools.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+const db_1 = require("../../../services/db");
+const taskService = __importStar(require("../../../services/task"));
+const escalationService = __importStar(require("../../../services/escalation"));
+const configService = __importStar(require("../../../services/config"));
+const sql_1 = require("../../../services/mcp/sql");
+const schemas_1 = require("./schemas");
+/**
+ * Register all six read-only query tools on the given MCP server instance.
+ */
+function registerTools(instance) {
+    // ── find_tasks ──────────────────────────────────────────────────
+    instance.registerTool('find_tasks', {
+        title: 'Find Tasks',
+        description: 'Search tasks with optional filters. Returns task records with workflow_id, status, ' +
+            'workflow_type, milestones, created/completed timestamps, and metadata.',
+        inputSchema: schemas_1.findTasksSchema,
+    }, async (args) => {
+        const { tasks, total } = await taskService.listTasks({
+            status: args.status,
+            workflow_type: args.workflow_type,
+            workflow_id: args.workflow_id,
+            origin_id: args.origin_id,
+            limit: args.limit,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: tasks.length,
+                        tasks: tasks.map((t) => ({
+                            id: t.id,
+                            workflow_id: t.workflow_id,
+                            workflow_type: t.workflow_type,
+                            status: t.status,
+                            priority: t.priority,
+                            origin_id: t.origin_id,
+                            created_at: t.created_at,
+                            completed_at: t.completed_at,
+                            error: t.error,
+                            trace_id: t.trace_id,
+                            span_id: t.span_id,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // ── find_escalations ────────────────────────────────────────────
+    instance.registerTool('find_escalations', {
+        title: 'Find Escalations',
+        description: 'Search escalations with optional filters. Returns escalation records with type, ' +
+            'role, priority, status, description, and assignment info.',
+        inputSchema: schemas_1.findEscalationsSchema,
+    }, async (args) => {
+        const { escalations, total } = await escalationService.listEscalations({
+            status: args.status,
+            role: args.role,
+            type: args.type,
+            priority: args.priority,
+            limit: args.limit,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: escalations.length,
+                        escalations: escalations.map((e) => ({
+                            id: e.id,
+                            type: e.type,
+                            subtype: e.subtype,
+                            role: e.role,
+                            priority: e.priority,
+                            status: e.status,
+                            description: e.description,
+                            workflow_type: e.workflow_type,
+                            assigned_to: e.assigned_to,
+                            created_at: e.created_at,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // ── get_process_summary ─────────────────────────────────────────
+    instance.registerTool('get_process_summary', {
+        title: 'Get Process Summary',
+        description: 'List business processes grouped by origin_id. Each process shows task count, ' +
+            'completed/escalated counts, workflow types involved, and time range.',
+        inputSchema: schemas_1.getProcessSummarySchema,
+    }, async (args) => {
+        const { processes, total } = await taskService.listProcesses({
+            workflow_type: args.workflow_type,
+            limit: args.limit,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: processes.length,
+                        processes: processes.map((p) => ({
+                            origin_id: p.origin_id,
+                            task_count: p.task_count,
+                            completed: p.completed,
+                            escalated: p.escalated,
+                            workflow_types: p.workflow_types,
+                            started_at: p.started_at,
+                            last_activity: p.last_activity,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // ── get_escalation_stats ────────────────────────────────────────
+    instance.registerTool('get_escalation_stats', {
+        title: 'Get Escalation Stats',
+        description: 'Real-time escalation statistics: pending/claimed counts, created/resolved in last ' +
+            '1h and 24h, breakdown by role.',
+        inputSchema: schemas_1.getEscalationStatsSchema,
+    }, async (_args) => {
+        const stats = await escalationService.getEscalationStats();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(stats),
+                }],
+        };
+    });
+    // ── get_workflow_types ──────────────────────────────────────────
+    instance.registerTool('get_workflow_types', {
+        title: 'Get Workflow Types',
+        description: 'List all registered workflow configurations. Shows workflow type, whether it is ' +
+            'an LT workflow or container, its task queue, roles, and description.',
+        inputSchema: schemas_1.getWorkflowTypesSchema,
+    }, async (_args) => {
+        const configs = await configService.listWorkflowConfigs();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        count: configs.length,
+                        workflows: configs.map((c) => ({
+                            workflow_type: c.workflow_type,
+                            invocable: c.invocable,
+                            task_queue: c.task_queue,
+                            default_role: c.default_role,
+                            description: c.description,
+                            roles: c.roles,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // ── get_system_health ──────────────────────────────────────────
+    instance.registerTool('get_system_health', {
+        title: 'Get System Health',
+        description: 'Overall system health snapshot: task counts by status, escalation counts by status, ' +
+            'active workflow types, and recent activity window.',
+        inputSchema: schemas_1.getSystemHealthSchema,
+    }, async (_args) => {
+        const pool = (0, db_1.getPool)();
+        const [taskCounts, escalationCounts, activeTypes, recentActivity] = await Promise.all([
+            pool.query(sql_1.HEALTH_TASK_COUNTS),
+            pool.query(sql_1.HEALTH_ESCALATION_COUNTS),
+            pool.query(sql_1.HEALTH_ACTIVE_WORKFLOW_TYPES),
+            pool.query(sql_1.HEALTH_RECENT_ACTIVITY),
+        ]);
+        const tasksByStatus = {};
+        for (const row of taskCounts.rows) {
+            tasksByStatus[row.status] = row.count;
+        }
+        const escalationsByStatus = {};
+        for (const row of escalationCounts.rows) {
+            escalationsByStatus[row.status] = row.count;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        tasks: tasksByStatus,
+                        escalations: escalationsByStatus,
+                        active_workflow_types: activeTypes.rows.map((r) => r.workflow_type),
+                        recent_activity: recentActivity.rows[0],
+                    }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/document-vision.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create the Document Vision MCP server.
+ *
+ * Returns a fresh McpServer instance each time. The MCP SDK only allows
+ * one transport per server, so each consumer (triage activities, pipeline
+ * workers, tests) needs its own instance to avoid "already connected" errors.
+ */
+export declare function createVisionServer(options?: {
+    name?: string;
+}): Promise<McpServer>;
+/**
+ * Stop a Vision MCP server instance and release resources.
+ */
+export declare function stopVisionServer(): Promise<void>;

package/build/system/mcp-servers/document-vision.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVisionServer = createVisionServer;
+exports.stopVisionServer = stopVisionServer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const llm_1 = require("../../services/llm");
+const defaults_1 = require("../../modules/defaults");
+const logger_1 = require("../../services/logger");
+const prompts_1 = require("./prompts");
+// ── Resolve fixtures directory ──────────────────────────────────────────────
+function fixturesDir() {
+    // Works from both ts-node (root) and compiled (build/) contexts
+    const candidates = [
+        path.join(__dirname, '..', '..', 'tests', 'fixtures'),
+        path.join(__dirname, '..', '..', '..', 'tests', 'fixtures'),
+    ];
+    for (const dir of candidates) {
+        if (fs.existsSync(dir))
+            return dir;
+    }
+    return candidates[0];
+}
+// ── Schemas (extracted to break TS2589 deep-instantiation in registerTool generics) ──
+const listDocumentPagesSchema = zod_1.z.object({});
+const rotatePageSchema = zod_1.z.object({
+    image_ref: zod_1.z.string().describe('Storage reference to the image to rotate'),
+    degrees: zod_1.z.number().int().describe('Rotation degrees (90, 180, 270)'),
+    replace_original: zod_1.z.boolean().optional().default(true).describe('Delete the original file after rotation (default: true)'),
+});
+const translateContentSchema = zod_1.z.object({
+    content: zod_1.z.string().describe('The content text to translate'),
+    target_language: zod_1.z.string().describe('Target language code (e.g. "en", "es")'),
+});
+/**
+ * List available document page images from storage.
+ */
+async function listDocumentPages() {
+    const dir = fixturesDir();
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir)
+        .filter(f => f.endsWith('.png') || f.endsWith('.jpg'));
+}
+/**
+ * Register all three vision tools on an McpServer instance.
+ */
+function registerTools(srv) {
+    // ── list_document_pages ─────────────────────────────────────────
+    srv.registerTool('list_document_pages', {
+        title: 'List Document Pages',
+        description: 'List available document page images from storage. Returns an array of image references.',
+        inputSchema: listDocumentPagesSchema,
+    }, async (_args) => {
+        const pages = await listDocumentPages();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ pages }) }],
+        };
+    });
+    // ── rotate_page ───────────────────────────────────────────────
+    srv.registerTool('rotate_page', {
+        title: 'Rotate Page',
+        description: 'Rotate a document page image by the given degrees using sharp. Writes the corrected image to storage and returns the new image reference.',
+        inputSchema: rotatePageSchema,
+    }, async (args) => {
+        const dir = fixturesDir();
+        const srcPath = path.join(dir, args.image_ref);
+        if (!fs.existsSync(srcPath)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: `Image not found: ${args.image_ref}` }),
+                    }],
+            };
+        }
+        // Build output filename: page1_upside_down.png → page1_upside_down_rotated.png
+        const ext = path.extname(args.image_ref);
+        const base = path.basename(args.image_ref, ext);
+        const rotatedName = `${base}_rotated${ext}`;
+        const destPath = path.join(dir, rotatedName);
+        await (0, sharp_1.default)(srcPath)
+            .rotate(args.degrees)
+            .toFile(destPath);
+        // Clean up original if requested (default: true)
+        if (args.replace_original !== false) {
+            try {
+                fs.unlinkSync(srcPath);
+                logger_1.loggerRegistry.info(`[lt-mcp:vision-server] rotated ${args.image_ref} by ${args.degrees}° → ${rotatedName} (original deleted)`);
+            }
+            catch (err) {
+                logger_1.loggerRegistry.warn(`[lt-mcp:vision-server] rotated ${args.image_ref} but failed to delete original: ${err}`);
+            }
+        }
+        else {
+            logger_1.loggerRegistry.info(`[lt-mcp:vision-server] rotated ${args.image_ref} by ${args.degrees}° → ${rotatedName}`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        rotated_ref: rotatedName,
+                        degrees: args.degrees,
+                        source_ref: args.image_ref,
+                        original_deleted: args.replace_original !== false,
+                    }),
+                }],
+        };
+    });
+    // ── translate_content ──────────────────────────────────────────
+    srv.registerTool('translate_content', {
+        title: 'Translate Content',
+        description: 'Translate content text to the target language using OpenAI. Returns the translated content and detected source language.',
+        inputSchema: translateContentSchema,
+    }, async (args) => {
+        const { hasLLMApiKey } = await Promise.resolve().then(() => __importStar(require('../../services/llm')));
+        if (!hasLLMApiKey(defaults_1.LLM_MODEL_SECONDARY)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            translated_content: args.content,
+                            source_language: 'unknown',
+                            target_language: args.target_language,
+                            note: 'LLM API key not configured — returned content unchanged',
+                        }),
+                    }],
+            };
+        }
+        const response = await (0, llm_1.callLLM)({
+            model: defaults_1.LLM_MODEL_SECONDARY,
+            messages: [
+                {
+                    role: 'system',
+                    content: (0, prompts_1.TRANSLATE_SYSTEM_PROMPT)(args.target_language),
+                },
+                { role: 'user', content: args.content },
+            ],
+            max_tokens: defaults_1.LLM_MAX_TOKENS_VISION,
+        });
+        const raw = response.content || '';
+        try {
+            const cleaned = raw.replace(/^```json\n?|\n?```$/g, '').trim();
+            const parsed = JSON.parse(cleaned);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            translated_content: parsed.translated_content || args.content,
+                            source_language: parsed.source_language || 'unknown',
+                            target_language: args.target_language,
+                        }),
+                    }],
+            };
+        }
+        catch {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            translated_content: raw,
+                            source_language: 'unknown',
+                            target_language: args.target_language,
+                        }),
+                    }],
+            };
+        }
+    });
+}
+/**
+ * Create the Document Vision MCP server.
+ *
+ * Returns a fresh McpServer instance each time. The MCP SDK only allows
+ * one transport per server, so each consumer (triage activities, pipeline
+ * workers, tests) needs its own instance to avoid "already connected" errors.
+ */
+async function createVisionServer(options) {
+    const name = options?.name || 'long-tail-document-vision';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    registerTools(instance);
+    logger_1.loggerRegistry.info(`[lt-mcp:vision-server] ${name} ready (3 tools registered)`);
+    return instance;
+}
+/**
+ * Stop a Vision MCP server instance and release resources.
+ */
+async function stopVisionServer() {
+    // No-op — instances are now independent and cleaned up by their callers
+    logger_1.loggerRegistry.info('[lt-mcp:vision-server] stopped');
+}

package/build/system/mcp-servers/file-storage.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createFileStorageServer(options?: {
+    name?: string;
+}): Promise<McpServer>;

package/build/system/mcp-servers/file-storage.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileStorageServer = createFileStorageServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../../services/logger");
+const fileStorage = __importStar(require("../activities/file-storage"));
+const writeFileSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('File path relative to storage root'),
+    content: zod_1.z.string().describe('File content (text or base64-encoded binary)'),
+    encoding: zod_1.z.enum(['utf-8', 'base64']).optional().default('utf-8')
+        .describe('Content encoding'),
+});
+const readFileSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('File path relative to storage root'),
+    encoding: zod_1.z.enum(['utf-8', 'base64']).optional().default('utf-8')
+        .describe('Return encoding'),
+});
+const listFilesSchema = zod_1.z.object({
+    directory: zod_1.z.string().optional().describe('Subdirectory to list (default: root)'),
+    pattern: zod_1.z.string().optional().describe('Glob-like filter pattern (e.g., "*.json")'),
+});
+const deleteFileSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('File path relative to storage root'),
+});
+async function createFileStorageServer(options) {
+    const name = options?.name || 'long-tail-file-storage';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    instance.registerTool('write_file', {
+        title: 'Write File',
+        description: 'Write content to a file in storage. Creates directories as needed. Returns the storage reference and size.',
+        inputSchema: writeFileSchema,
+    }, async (args) => {
+        const result = await fileStorage.writeFile(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    instance.registerTool('read_file', {
+        title: 'Read File',
+        description: 'Read file content from storage. Returns content, size, and detected MIME type.',
+        inputSchema: readFileSchema,
+    }, async (args) => {
+        try {
+            const result = await fileStorage.readFile(args);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }], isError: true };
+        }
+    });
+    instance.registerTool('list_files', {
+        title: 'List Files',
+        description: 'List files in a storage directory. Returns file paths, sizes, and modification timestamps.',
+        inputSchema: listFilesSchema,
+    }, async (args) => {
+        const result = await fileStorage.listFiles(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    instance.registerTool('delete_file', {
+        title: 'Delete File',
+        description: 'Remove a file from storage.',
+        inputSchema: deleteFileSchema,
+    }, async (args) => {
+        const result = await fileStorage.deleteFile(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    logger_1.loggerRegistry.info(`[lt-mcp:file-storage] ${name} ready (4 tools registered)`);
+    return instance;
+}

package/build/system/mcp-servers/http-fetch.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createHttpFetchServer(options?: {
+    name?: string;
+}): Promise<McpServer>;

package/build/system/mcp-servers/http-fetch.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpFetchServer = createHttpFetchServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../../services/logger");
+const http = __importStar(require("../activities/http"));
+const httpRequestSchema = zod_1.z.object({
+    url: zod_1.z.string().describe('URL to request'),
+    method: zod_1.z.string().optional().default('GET').describe('HTTP method'),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe('Request headers'),
+    body: zod_1.z.string().optional().describe('Request body'),
+    timeout_ms: zod_1.z.number().optional().describe('Request timeout in milliseconds'),
+});
+const fetchJsonSchema = zod_1.z.object({
+    url: zod_1.z.string().describe('URL to fetch JSON from'),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe('Request headers'),
+});
+const fetchTextSchema = zod_1.z.object({
+    url: zod_1.z.string().describe('URL to fetch text from'),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe('Request headers'),
+});
+async function createHttpFetchServer(options) {
+    const name = options?.name || 'long-tail-http-fetch';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    instance.registerTool('http_request', {
+        title: 'HTTP Request',
+        description: 'Make an HTTP request to any URL. Supports all methods, custom headers, and request bodies. Returns status, headers, and body.',
+        inputSchema: httpRequestSchema,
+    }, async (args) => {
+        try {
+            const result = await http.httpRequest(args);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }], isError: true };
+        }
+    });
+    instance.registerTool('fetch_json', {
+        title: 'Fetch JSON',
+        description: 'GET a URL and parse the response as JSON. Convenience wrapper around http_request.',
+        inputSchema: fetchJsonSchema,
+    }, async (args) => {
+        try {
+            const result = await http.fetchJson(args);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }], isError: true };
+        }
+    });
+    instance.registerTool('fetch_text', {
+        title: 'Fetch Text',
+        description: 'GET a URL and return the response as text. Returns content, status, and content type.',
+        inputSchema: fetchTextSchema,
+    }, async (args) => {
+        try {
+            const result = await http.fetchText(args);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }], isError: true };
+        }
+    });
+    logger_1.loggerRegistry.info(`[lt-mcp:http-fetch] ${name} ready (3 tools registered)`);
+    return instance;
+}