@hailer/mcp 0.0.1

package/dist/client/tool-executor.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Tool Executor
+ *
+ * Handles MCP tool call execution and result processing.
+ * Shared between all LLM providers (Anthropic, OpenAI, etc.)
+ *
+ * Key Features:
+ * - Execute tool calls via MCP server
+ * - Handle tool call iterations and loops
+ * - Process and format tool results
+ * - Track tool execution metrics
+ */
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: any;
+}
+export interface ToolResult {
+    tool_use_id: string;
+    content: string;
+    isError?: boolean;
+}
+export interface ExecuteToolOptions {
+    mcpServerUrl: string;
+    mcpServerApiKey: string;
+    toolCall: ToolCall;
+}
+export interface ToolExecutionMetrics {
+    toolName: string;
+    success: boolean;
+    duration: number;
+    error?: string;
+}
+export declare class ToolExecutor {
+    private executionMetrics;
+    /**
+     * Execute a tool call via MCP server
+     */
+    executeTool(options: ExecuteToolOptions): Promise<ToolResult>;
+    /**
+     * Execute multiple tool calls in parallel
+     */
+    executeToolsParallel(options: Omit<ExecuteToolOptions, 'toolCall'>, toolCalls: ToolCall[]): Promise<ToolResult[]>;
+    /**
+     * Get execution metrics
+     */
+    getMetrics(): ToolExecutionMetrics[];
+    /**
+     * Get successful tool call count
+     */
+    getSuccessCount(): number;
+    /**
+     * Get total tool call count
+     */
+    getTotalCount(): number;
+    /**
+     * Clear metrics
+     */
+    clearMetrics(): void;
+    /**
+     * Get list of tool names called
+     */
+    getToolNamesCalled(): string[];
+    /**
+     * Call MCP tool via JSON-RPC
+     */
+    private callMcpTool;
+}
+//# sourceMappingURL=tool-executor.d.ts.map

package/dist/client/tool-executor.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Tool Executor
+ *
+ * Handles MCP tool call execution and result processing.
+ * Shared between all LLM providers (Anthropic, OpenAI, etc.)
+ *
+ * Key Features:
+ * - Execute tool calls via MCP server
+ * - Handle tool call iterations and loops
+ * - Process and format tool results
+ * - Track tool execution metrics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = void 0;
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'ToolExecutor' });
+class ToolExecutor {
+    executionMetrics = [];
+    /**
+     * Execute a tool call via MCP server
+     */
+    async executeTool(options) {
+        const { mcpServerUrl, mcpServerApiKey, toolCall } = options;
+        const startTime = Date.now();
+        try {
+            logger.debug("[tool_call] Tool call", {
+                toolName: toolCall.name,
+                arguments: toolCall.arguments
+            });
+            const result = await this.callMcpTool(mcpServerUrl, mcpServerApiKey, toolCall.name, toolCall.arguments);
+            const duration = Date.now() - startTime;
+            logger.debug("[tool_call] Tool call", {
+                toolName: toolCall.name,
+                arguments: toolCall.arguments,
+                duration
+            });
+            // Track metrics
+            this.executionMetrics.push({
+                toolName: toolCall.name,
+                success: true,
+                duration
+            });
+            return {
+                tool_use_id: toolCall.id,
+                content: JSON.stringify(result),
+                isError: false
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error("[tool_call] Tool call failed", {
+                toolName: toolCall.name,
+                error: errorMessage,
+                duration
+            });
+            // Track error metrics
+            this.executionMetrics.push({
+                toolName: toolCall.name,
+                success: false,
+                duration,
+                error: errorMessage
+            });
+            return {
+                tool_use_id: toolCall.id,
+                content: `Error executing tool: ${errorMessage}`,
+                isError: true
+            };
+        }
+    }
+    /**
+     * Execute multiple tool calls in parallel
+     */
+    async executeToolsParallel(options, toolCalls) {
+        const promises = toolCalls.map(toolCall => this.executeTool({ ...options, toolCall }));
+        return Promise.all(promises);
+    }
+    /**
+     * Get execution metrics
+     */
+    getMetrics() {
+        return [...this.executionMetrics];
+    }
+    /**
+     * Get successful tool call count
+     */
+    getSuccessCount() {
+        return this.executionMetrics.filter(m => m.success).length;
+    }
+    /**
+     * Get total tool call count
+     */
+    getTotalCount() {
+        return this.executionMetrics.length;
+    }
+    /**
+     * Clear metrics
+     */
+    clearMetrics() {
+        this.executionMetrics = [];
+    }
+    /**
+     * Get list of tool names called
+     */
+    getToolNamesCalled() {
+        return this.executionMetrics.map(m => m.toolName);
+    }
+    // ===== PRIVATE METHODS =====
+    /**
+     * Call MCP tool via JSON-RPC
+     */
+    async callMcpTool(mcpServerUrl, mcpServerApiKey, toolName, args) {
+        const url = `${mcpServerUrl}${mcpServerUrl.includes("?") ? "&" : "?"}apiKey=${mcpServerApiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: Date.now(),
+                method: "tools/call",
+                params: {
+                    name: toolName,
+                    arguments: args,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`MCP tool call failed with ${response.status}: ${response.statusText}`);
+        }
+        // Parse SSE response
+        const responseText = await response.text();
+        const lines = responseText.split("\n");
+        let jsonData = null;
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    jsonData = JSON.parse(line.substring(6));
+                    break;
+                }
+                catch (e) {
+                    // Skip non-JSON lines
+                }
+            }
+        }
+        if (!jsonData) {
+            throw new Error("Failed to parse MCP server response");
+        }
+        if (jsonData.error) {
+            throw new Error(`MCP server error: ${jsonData.error.message || jsonData.error}`);
+        }
+        return jsonData.result;
+    }
+}
+exports.ToolExecutor = ToolExecutor;
+//# sourceMappingURL=tool-executor.js.map

package/dist/client/tool-schema-loader.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Tool Schema Loader
+ *
+ * Manages MCP tool discovery, schema loading, and filtering.
+ * Shared between all LLM providers (Anthropic, OpenAI, etc.)
+ *
+ * Key Features:
+ * - Load lightweight tool index from MCP server
+ * - Filter tools by groups (READ, WRITE, PLAYGROUND)
+ * - Load full schemas on-demand (token-efficient)
+ * - Cache loaded schemas
+ */
+import { ToolGroup } from '../mcp/tool-registry';
+export interface ToolIndexEntry {
+    name: string;
+    category: string;
+    description: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: any;
+}
+export interface LoadToolsOptions {
+    mcpServerUrl: string;
+    mcpServerApiKey: string;
+    allowedGroups: ToolGroup[];
+    excludeMessageFetchTools?: boolean;
+}
+export declare class ToolSchemaLoader {
+    private toolSchemaCache;
+    /**
+     * Load tool index with filtering
+     * Returns lightweight tool list with optional exclusions
+     */
+    loadToolIndex(options: LoadToolsOptions): Promise<ToolIndexEntry[]>;
+    /**
+     * Load full schema for a specific tool on-demand
+     */
+    loadToolSchema(mcpServerUrl: string, mcpServerApiKey: string, toolName: string): Promise<any>;
+    /**
+     * Convert tool index to minimal tool definitions (stubs)
+     * Full schemas will be loaded on-demand when needed
+     * Returns any[] to allow provider-specific extensions (like Anthropic's cache_control)
+     */
+    toMinimalToolDefinitions(toolIndex: ToolIndexEntry[]): any[];
+    /**
+     * Get count of loaded schemas
+     */
+    getLoadedSchemaCount(): number;
+    /**
+     * Clear schema cache
+     */
+    clearCache(): void;
+    /**
+     * Fetch tool index from MCP server
+     */
+    private fetchMcpToolIndex;
+}
+//# sourceMappingURL=tool-schema-loader.d.ts.map

package/dist/client/tool-schema-loader.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Tool Schema Loader
+ *
+ * Manages MCP tool discovery, schema loading, and filtering.
+ * Shared between all LLM providers (Anthropic, OpenAI, etc.)
+ *
+ * Key Features:
+ * - Load lightweight tool index from MCP server
+ * - Filter tools by groups (READ, WRITE, PLAYGROUND)
+ * - Load full schemas on-demand (token-efficient)
+ * - Cache loaded schemas
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolSchemaLoader = void 0;
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'ToolSchemaLoader' });
+class ToolSchemaLoader {
+    toolSchemaCache = new Map(); // In-memory cache for tool schemas
+    /**
+     * Load tool index with filtering
+     * Returns lightweight tool list with optional exclusions
+     */
+    async loadToolIndex(options) {
+        const { mcpServerUrl, mcpServerApiKey, allowedGroups, excludeMessageFetchTools } = options;
+        // Fetch tool index from MCP server with group filtering
+        let toolIndex = await this.fetchMcpToolIndex(mcpServerUrl, mcpServerApiKey, allowedGroups);
+        // Optionally exclude message fetch tools if explicitly requested
+        if (excludeMessageFetchTools) {
+            const excludedTools = ['fetch_discussion_messages', 'fetch_previous_discussion_messages'];
+            toolIndex = toolIndex.filter(tool => !excludedTools.includes(tool.name));
+            logger.info("Excluded message fetch tools (explicitly requested)", { excludedTools });
+        }
+        logger.info("Loaded tool index", {
+            toolCount: toolIndex.length,
+            allowedGroups: allowedGroups.join(', ')
+        });
+        return toolIndex;
+    }
+    /**
+     * Load full schema for a specific tool on-demand
+     */
+    async loadToolSchema(mcpServerUrl, mcpServerApiKey, toolName) {
+        // Check cache first
+        if (this.toolSchemaCache.has(toolName)) {
+            logger.debug("Using cached tool schema", { toolName });
+            return this.toolSchemaCache.get(toolName);
+        }
+        // Fetch from MCP server
+        logger.info("Fetching full schema for tool on-demand", { toolName });
+        const url = `${mcpServerUrl}${mcpServerUrl.includes("?") ? "&" : "?"}apiKey=${mcpServerApiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "tools/get_schema",
+                params: { name: toolName },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`MCP server responded with ${response.status}: ${response.statusText}`);
+        }
+        // Parse SSE response
+        const responseText = await response.text();
+        const lines = responseText.split("\n");
+        let jsonData = null;
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    jsonData = JSON.parse(line.substring(6));
+                    break;
+                }
+                catch (e) {
+                    // Skip non-JSON lines
+                }
+            }
+        }
+        if (!jsonData) {
+            throw new Error("Failed to parse MCP server response");
+        }
+        if (jsonData.error) {
+            throw new Error(`MCP server error: ${jsonData.error.message || jsonData.error}`);
+        }
+        const schema = jsonData.result;
+        // Cache the schema
+        this.toolSchemaCache.set(toolName, schema);
+        logger.debug("Cached tool schema", { toolName });
+        return schema;
+    }
+    /**
+     * Convert tool index to minimal tool definitions (stubs)
+     * Full schemas will be loaded on-demand when needed
+     * Returns any[] to allow provider-specific extensions (like Anthropic's cache_control)
+     */
+    toMinimalToolDefinitions(toolIndex) {
+        return toolIndex.map((tool, index) => {
+            const toolDef = {
+                name: tool.name,
+                description: tool.description,
+                input_schema: {
+                    type: "object",
+                    properties: {},
+                    required: [],
+                },
+            };
+            // Add cache control to last tool for Anthropic prompt caching
+            if (index === toolIndex.length - 1) {
+                toolDef.cache_control = { type: "ephemeral" };
+            }
+            return toolDef;
+        });
+    }
+    /**
+     * Get count of loaded schemas
+     */
+    getLoadedSchemaCount() {
+        return this.toolSchemaCache.size;
+    }
+    /**
+     * Clear schema cache
+     */
+    clearCache() {
+        this.toolSchemaCache.clear();
+        logger.debug("Tool schema cache cleared");
+    }
+    // ===== PRIVATE METHODS =====
+    /**
+     * Fetch tool index from MCP server
+     */
+    async fetchMcpToolIndex(mcpServerUrl, mcpServerApiKey, allowedGroups) {
+        const url = `${mcpServerUrl}${mcpServerUrl.includes("?") ? "&" : "?"}apiKey=${mcpServerApiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "tools/list",
+                params: allowedGroups ? { groups: allowedGroups } : {},
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`MCP server responded with ${response.status}: ${response.statusText}`);
+        }
+        // Parse SSE response format
+        const responseText = await response.text();
+        const lines = responseText.split("\n");
+        let jsonData = null;
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    jsonData = JSON.parse(line.substring(6));
+                    break;
+                }
+                catch (e) {
+                    // Skip non-JSON lines
+                }
+            }
+        }
+        if (!jsonData) {
+            throw new Error("Failed to parse MCP server response");
+        }
+        if (jsonData.error) {
+            throw new Error(`MCP server error: ${jsonData.error.message || jsonData.error}`);
+        }
+        return jsonData.result.tools;
+    }
+}
+exports.ToolSchemaLoader = ToolSchemaLoader;
+//# sourceMappingURL=tool-schema-loader.js.map

package/dist/client/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * MCP Client Types
+ * Defines interfaces for the MCP client system that supports multiple LLM providers
+ */
+import { HailerSignal } from "../mcp/signal-handler";
+export interface McpClientConfig {
+    enabled: boolean;
+    mcpServerUrl: string;
+    mcpServerApiKey: string;
+    providers: LlmProviderConfig[];
+    mcpAgentIds: string[];
+    botConfigs: BotClientConfig[];
+    enableDirectMessages: boolean;
+    tokenUsageBotEnabled: boolean;
+    agentActivityBotEnabled: boolean;
+}
+export interface LlmProviderConfig {
+    name: string;
+    type: "openai" | "anthropic" | "gemini";
+    apiKey: string;
+    model: string;
+    enabled: boolean;
+    maxTokens?: number;
+    temperature?: number;
+}
+export interface ChatMessage {
+    id: string;
+    content: string;
+    timestamp: number;
+    discussionId: string;
+    userId: string;
+    userName: string;
+    workspaceId?: string;
+    mentionedOrDirectMessagedBotId: string;
+}
+export interface McpResponse {
+    success: boolean;
+    messageId?: string;
+    toolCalls?: ToolCallInfo[];
+    response?: string;
+    error?: string;
+    tokens?: {
+        input: number;
+        output: number;
+        total: number;
+        cacheCreation?: number;
+        cacheRead?: number;
+        cost?: number;
+    };
+}
+export interface ToolCallInfo {
+    toolName: string;
+    args: any;
+    result?: any;
+    error?: string;
+    duration?: number;
+}
+export interface MessageProcessor {
+    shouldProcess(signal: HailerSignal): boolean;
+    extractMessage(signal: HailerSignal): Promise<ChatMessage[]>;
+    postMessage(discussionId: string, content: string, workspaceId?: string, botId?: string): Promise<boolean>;
+}
+export interface BotClientConfig {
+    email: string;
+    password: string;
+    apiBaseUrl: string;
+    mcpServerApiKey: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/client/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * MCP Client Types
+ * Defines interfaces for the MCP client system that supports multiple LLM providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/config.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Universal Application Configuration
+ *
+ * Single source of truth that replaces all scattered config files:
+ * - lib/env.ts - Environment variable loading
+ * - mcp/config.ts - getClientConfig() function
+ * - client/config.ts - Client configuration creation
+ * - mcp/mcp-config.ts - MCP context optimization settings
+ *
+ * Key Features:
+ * - Map-based CLIENT_CONFIGS for O(1) API key lookups
+ * - Preserves existing excellent connection architecture
+ * - Comprehensive Zod validation with clear error messages
+ * - Development defaults for seamless local setup
+ */
+import { ToolGroup } from './mcp/tool-registry';
+/**
+ * Validated environment - single source of truth
+ */
+export declare const environment: {
+    NODE_ENV: "production" | "development" | "test";
+    LOG_LEVEL: "error" | "debug" | "info" | "warn";
+    DISABLE_MCP_SERVER: boolean;
+    MCP_CLIENT_ENABLED: boolean;
+    ENABLE_NUCLEAR_TOOLS: boolean;
+    PORT: number;
+    CORS_ORIGINS: string[];
+    CLIENT_CONFIGS: Record<string, {
+        email: string;
+        password: string;
+        apiBaseUrl: string;
+    }>;
+    MCP_SERVER_URL: string;
+    MCP_CLIENT_API_KEY: string;
+    MCP_CLIENT_AGENT_IDS: string[];
+    TOKEN_USAGE_BOT_ENABLED: boolean;
+    AGENT_ACTIVITY_BOT_ENABLED: boolean;
+    ADAPTIVE_DOCUMENTATION_BOT_ENABLED: boolean;
+    ADAPTIVE_AUTO_UPDATE: boolean;
+    ADAPTIVE_UPDATE_INTERVAL: number;
+    ADAPTIVE_MIN_ERROR_COUNT: number;
+    ADAPTIVE_SKILL_GENERATION: boolean;
+    MCP_EXCLUDE_TRANSLATIONS: boolean;
+    MCP_COMPACT_DATA: boolean;
+    MCP_INCLUDE_WORKSPACE_NAMES: boolean;
+    CONTEXT_SAFETY_MARGIN_PERCENT: number;
+    CONTEXT_ENABLE_AUTO_SUMMARIZATION: boolean;
+    CONTEXT_MAX_SUMMARIZATION_CHUNKS: number;
+    WORKSPACE_CONFIG_PATH?: string | undefined;
+    DEV_APPS_PATH?: string | undefined;
+    OPENAI_API_KEY?: string | undefined;
+    ANTHROPIC_API_KEY?: string | undefined;
+};
+export interface HailerAccount {
+    email: string;
+    password: string;
+    apiBaseUrl: string;
+    allowedTools?: string[];
+    allowedGroups?: ToolGroup[];
+}
+export interface LlmProvider {
+    name: string;
+    type: 'openai' | 'anthropic';
+    apiKey: string;
+    model: string;
+    enabled: boolean;
+}
+export interface ServerConfig {
+    port: number;
+    corsOrigins: string[];
+    enableMcpServer: boolean;
+    enableClient: boolean;
+}
+/** MCP context optimization settings (replaces mcp-config.ts exports) */
+export interface McpConfig {
+    excludeTranslations: boolean;
+    excludeSystemMessages: boolean;
+    excludeEmptyFields: boolean;
+    compactUserData: boolean;
+    includeWorkspaceNamesInTools: boolean;
+}
+/** Context management configuration */
+export interface ContextConfig {
+    safetyMarginPercent: number;
+    enableAutoSummarization: boolean;
+    maxSummarizationChunks: number;
+}
+/** MCP Client configuration (replaces client/config.ts exports) */
+export interface McpClientConfig {
+    enabled: boolean;
+    mcpServerUrl: string;
+    mcpServerApiKey: string;
+    providers: LlmProvider[];
+    mcpAgentIds: string[];
+    botConfigs: BotClientConfig[];
+    enableDirectMessages: boolean;
+    tokenUsageBotEnabled: boolean;
+    agentActivityBotEnabled: boolean;
+}
+/** Bot client configuration for MultiBotManager compatibility */
+export interface BotClientConfig {
+    email: string;
+    password: string;
+    apiBaseUrl: string;
+    mcpServerApiKey: string;
+}
+/**
+ * Universal Application Configuration
+ *
+ * Single class that provides all configuration for the entire application.
+ * Replaces all scattered config files with one clean interface.
+ */
+export declare class ApplicationConfig {
+    constructor();
+    get server(): ServerConfig;
+    /**
+     * Efficient Map-based Hailer accounts (replaces CLIENT_CONFIGS array)
+     */
+    get hailerAccounts(): Record<string, HailerAccount>;
+    get llmProviders(): LlmProvider[];
+    /**
+     * MCP context optimization settings
+     */
+    get mcpConfig(): McpConfig;
+    /**
+     * Context management settings for token limits and summarization
+     */
+    get contextConfig(): ContextConfig;
+    /**
+     * Adaptive Documentation Bot configuration
+     */
+    get adaptiveDocumentation(): {
+        enabled: boolean;
+        autoUpdate: boolean;
+        updateInterval: number;
+        minErrorCount: number;
+        skillGeneration: boolean;
+    };
+    /**
+     * Create MCP Client configuration (replaces createMcpClientConfig())
+     */
+    get mcpClient(): McpClientConfig | null;
+    /**
+     * Find account by API key - O(1) lookup (replaces getClientConfig())
+     * This is the key efficiency improvement that eliminates array filtering
+     */
+    getClientConfig(apiKey: string | null): HailerAccount;
+    /**
+     * Alternative method with null return (safer)
+     */
+    findAccountByApiKey(apiKey: string): HailerAccount | null;
+    /**
+     * Get enabled LLM providers only
+     */
+    getEnabledLlmProviders(): LlmProvider[];
+}
+/**
+ * Create application configuration
+ * Configuration is determined by environment variables (DISABLE_MCP_SERVER, MCP_CLIENT_ENABLED)
+ */
+export declare function createApplicationConfig(): ApplicationConfig;
+//# sourceMappingURL=config.d.ts.map