@hailer/mcp 0.0.1

package/dist/lib/logger.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Unified Logger for Hailer MCP Server
+ * Based on backend logger pattern
+ * - Production: OpenTelemetry to Victoria Logs
+ * - Development: Console output only
+ * - Proper dependency injection pattern
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogTag = exports.LogLevel = void 0;
+exports.createLogger = createLogger;
+exports.getDefaultLogger = getDefaultLogger;
+// Import OpenTelemetry modules the same way as backend
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const exporter_logs_otlp_proto_1 = require("@opentelemetry/exporter-logs-otlp-proto");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const resources_1 = require("@opentelemetry/resources");
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+// Log tags for categorization
+var LogTag;
+(function (LogTag) {
+    LogTag["SYSTEM"] = "system";
+    LogTag["API_CALL"] = "api_call";
+    LogTag["TOOL_CALL"] = "tool_call";
+    LogTag["MCP_ACTIVITY"] = "mcp_activity";
+    LogTag["AUTH"] = "auth";
+    LogTag["WEBSOCKET"] = "websocket";
+    LogTag["ERROR"] = "error";
+})(LogTag || (exports.LogTag = LogTag = {}));
+/** Helper function to flatten objects for OTLP (from backend) */
+const flatten = (obj, prefix = '') => {
+    return Object.keys(obj).reduce((acc, k) => {
+        const pre = prefix.length ? prefix + '.' : '';
+        if (typeof obj[k] === 'object' && obj[k] !== null && !Array.isArray(obj[k])) {
+            Object.assign(acc, flatten(obj[k], pre + k));
+        }
+        else if (Array.isArray(obj[k])) {
+            acc[pre + k] = JSON.stringify(obj[k]);
+        }
+        else {
+            acc[pre + k] = obj[k];
+        }
+        return acc;
+    }, {});
+};
+class Logger {
+    otelLogger;
+    level = LogLevel.DEBUG;
+    context = {};
+    isProduction;
+    constructor(context = {}, level = LogLevel.DEBUG) {
+        this.context = context;
+        this.level = level;
+        this.isProduction = process.env.NODE_ENV === 'production';
+        if (this.isProduction) {
+            this.initializeOtelLogger();
+        }
+        // Development mode: console logging only (no JSON files)
+    }
+    initializeOtelLogger() {
+        try {
+            const logExporter = new exporter_logs_otlp_proto_1.OTLPLogExporter({
+                url: process.env.LOG_URL || 'https://logs.hailer.local.gd/insert/opentelemetry/v1/logs',
+                concurrencyLimit: 1,
+                keepAlive: true,
+                // Ignore certificate when in DEVLOCAL mode
+                ...process.env.DEVLOCAL ? {
+                    httpAgentOptions: {
+                        rejectUnauthorized: false,
+                    },
+                } : {},
+            });
+            const loggerProvider = new sdk_logs_1.LoggerProvider({
+                resource: new resources_1.Resource({ 'service.name': 'hailer-mcp-server' })
+            });
+            loggerProvider.addLogRecordProcessor(new sdk_logs_1.BatchLogRecordProcessor(logExporter));
+            this.otelLogger = loggerProvider.getLogger('hailer-mcp', '1.0.0');
+        }
+        catch (error) {
+            console.error('❌ Failed to initialize OTLP logger:', error);
+            // Fallback to console logging only
+        }
+    }
+    shouldLog(level) {
+        return level >= this.level;
+    }
+    generateRequestId() {
+        return `req-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    }
+    logToOtel(level, message, tag, context) {
+        if (!this.otelLogger)
+            return;
+        const fullContext = { ...this.context, ...context };
+        const severityMap = {
+            [LogLevel.DEBUG]: api_logs_1.SeverityNumber.DEBUG,
+            [LogLevel.INFO]: api_logs_1.SeverityNumber.INFO,
+            [LogLevel.WARN]: api_logs_1.SeverityNumber.WARN,
+            [LogLevel.ERROR]: api_logs_1.SeverityNumber.ERROR,
+        };
+        this.otelLogger.emit({
+            severityNumber: severityMap[level],
+            severityText: LogLevel[level].toLowerCase(),
+            body: message,
+            attributes: flatten({
+                'log.tag': tag,
+                'log.component': this.context.component || 'mcp-server',
+                ...fullContext
+            }),
+        });
+    }
+    log(level, message, tag = LogTag.SYSTEM, context = {}) {
+        if (!this.shouldLog(level))
+            return;
+        const fullContext = { ...this.context, ...context };
+        // Always log to console for immediate feedback
+        const emoji = this.getEmoji(level);
+        const levelName = LogLevel[level];
+        const contextStr = Object.keys(fullContext).length > 0
+            ? ` [${Object.entries(fullContext)
+                .filter(([_, value]) => value !== undefined && value !== null)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(', ')}]`
+            : '';
+        const consoleMessage = `${emoji} ${levelName}: [${tag}] ${message}${contextStr}`;
+        if (level === LogLevel.ERROR) {
+            console.error(consoleMessage);
+        }
+        else if (level === LogLevel.WARN) {
+            console.warn(consoleMessage);
+        }
+        else {
+            console.log(consoleMessage);
+        }
+        // Log to OTLP in production (console only in development)
+        if (this.isProduction && this.otelLogger) {
+            this.logToOtel(level, message, tag, fullContext);
+        }
+    }
+    getEmoji(level) {
+        switch (level) {
+            case LogLevel.DEBUG: return '🔍';
+            case LogLevel.INFO: return '📡';
+            case LogLevel.WARN: return '⚠️';
+            case LogLevel.ERROR: return '❌';
+            default: return '📝';
+        }
+    }
+    // Core logging methods
+    debug(message, context, tag = LogTag.SYSTEM) {
+        this.log(LogLevel.DEBUG, message, tag, context);
+    }
+    info(message, context, tag = LogTag.SYSTEM) {
+        this.log(LogLevel.INFO, message, tag, context);
+    }
+    warn(message, context, tag = LogTag.SYSTEM) {
+        this.log(LogLevel.WARN, message, tag, context);
+    }
+    error(message, error, context, tag = LogTag.ERROR) {
+        let fullMessage = message;
+        let fullContext = { ...context };
+        if (error instanceof Error) {
+            fullMessage = `${message}: ${error.message}`;
+            fullContext.errorStack = error.stack;
+            fullContext.errorName = error.name;
+        }
+        else if (error) {
+            // Better error object handling - stringify objects properly
+            let errorString;
+            let errorData;
+            if (typeof error === 'object' && error !== null) {
+                try {
+                    errorString = JSON.stringify(error, null, 2);
+                    errorData = error; // Keep raw object for structured logging
+                }
+                catch {
+                    errorString = String(error);
+                    errorData = String(error);
+                }
+            }
+            else {
+                errorString = String(error);
+                errorData = errorString;
+            }
+            fullMessage = `${message}: ${errorString}`;
+            fullContext.errorData = errorData;
+        }
+        this.log(LogLevel.ERROR, fullMessage, tag, fullContext);
+    }
+    // Convenience methods for common operations
+    apiCall(operation, endpoint, params, context) {
+        this.debug(`API call: ${operation}`, {
+            operation,
+            endpoint,
+            params: params ? JSON.stringify(params) : undefined,
+            ...context
+        }, LogTag.API_CALL);
+    }
+    apiSuccess(operation, endpoint, duration, context) {
+        this.info(`API success: ${operation}`, {
+            operation,
+            endpoint,
+            duration,
+            ...context
+        }, LogTag.API_CALL);
+    }
+    apiError(operation, endpoint, error, duration, context) {
+        this.error(`API error: ${operation}`, error, {
+            operation,
+            endpoint,
+            duration,
+            ...context
+        }, LogTag.API_CALL);
+    }
+    toolCall(toolName, provider, args, context) {
+        this.debug(`Tool call: ${toolName}`, {
+            toolName,
+            provider,
+            arguments: args ? JSON.stringify(args) : undefined,
+            ...context
+        }, LogTag.TOOL_CALL);
+    }
+    toolSuccess(toolName, provider, duration, context) {
+        this.info(`Tool success: ${toolName}`, {
+            toolName,
+            provider,
+            duration,
+            ...context
+        }, LogTag.TOOL_CALL);
+    }
+    toolError(toolName, provider, error, duration, context) {
+        this.error(`Tool error: ${toolName}`, error, {
+            toolName,
+            provider,
+            duration,
+            ...context
+        }, LogTag.TOOL_CALL);
+    }
+    mcpActivity(activity, context) {
+        this.info(`MCP Activity: ${activity}`, context, LogTag.MCP_ACTIVITY);
+    }
+    socketFallback(operation, reason, context) {
+        this.warn(`Socket fallback: ${operation} - ${reason}`, { operation, ...context }, LogTag.WEBSOCKET);
+    }
+    auth(message, context) {
+        this.info(`Auth: ${message}`, context, LogTag.AUTH);
+    }
+    authError(message, error, context) {
+        this.error(`Auth error: ${message}`, error, context, LogTag.AUTH);
+    }
+    // Create child logger with additional context
+    child(additionalContext) {
+        return new Logger({ ...this.context, ...additionalContext }, this.level);
+    }
+    // Set log level
+    setLevel(level) {
+        this.level = level;
+    }
+}
+exports.Logger = Logger;
+/**
+ * Logger factory function - replaces the old singleton pattern
+ * Use this to create loggers with specific context
+ */
+function createLogger(context = {}) {
+    return new Logger(context);
+}
+// Default logger for backward compatibility (but prefer createLogger)
+function getDefaultLogger() {
+    return new Logger({ component: 'default' });
+}
+//# sourceMappingURL=logger.js.map

package/dist/lib/materialize.d.ts

@@ -0,0 +1,3 @@
+import { HailerV2CoreInitResponse } from "../mcp/utils";
+export declare const materialize: (hailerResponse: any, init: HailerV2CoreInitResponse, authToken: string) => Promise<unknown>;
+//# sourceMappingURL=materialize.d.ts.map

package/dist/lib/materialize.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materialize = void 0;
+const getMaterializedProcess = (init, value) => {
+    const process = init.processes.find((process) => process._id === value);
+    if (!process)
+        return value;
+    return {
+        _id: process?._id,
+        name: process.name,
+        phases: process?.phasesOrder
+            .filter((phaseId) => !process.phasesRemoved.includes(phaseId))
+            .map((phaseId) => {
+            const phase = process.phases[phaseId];
+            return {
+                _id: process._id,
+                name: phase.name,
+                ...(phase.description ? { description: phase.description } : {}),
+            };
+        }),
+    };
+};
+const getMaterializedCurrentPhase = (init, value) => {
+    const phase = init.processes
+        .flatMap((process) => Object.values(process.phases))
+        .find((phase) => phase._id === value);
+    if (!phase)
+        return value;
+    return {
+        _id: phase._id,
+        name: phase.name,
+        ...(phase.description ? { description: phase.description } : {}),
+    };
+};
+const getMaterializedUID = (init, value) => {
+    const user = init.users[value];
+    if (!user)
+        return value;
+    return {
+        _id: user._id,
+        name: `${user.firstname} ${user.lastname}`,
+    };
+};
+const getMaterializedTime = (epoch) => ({
+    epoch,
+    humanReadable: new Intl.DateTimeFormat("en-GB", {
+        day: "numeric",
+        month: "short",
+        year: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    }).format(new Date(epoch)),
+});
+const getMaterializedValue = (key, value, init) => {
+    if (key === "process" && typeof value === "string") {
+        return getMaterializedProcess(init, value);
+    }
+    if (key === "currentPhase" && typeof value === "string") {
+        return getMaterializedCurrentPhase(init, value);
+    }
+    if (key === "uid" && typeof value === "string") {
+        return getMaterializedUID(init, value);
+    }
+    if ((key === "created" || key === "updated") && typeof value === "number") {
+        return getMaterializedTime(value);
+    }
+    return value;
+};
+const mergeResponseWithDependencies = (rootNode, init) => {
+    const traverse = (node) => {
+        if (Array.isArray(node)) {
+            return node.map(traverse);
+        }
+        if (node !== null && typeof node === "object") {
+            return Object.entries(node).reduce((acc, [key, value]) => {
+                const traversedValue = traverse(value);
+                if ((typeof value === "string" && value.trim() === "") ||
+                    (Array.isArray(value) && value.length === 0)) {
+                    return acc;
+                }
+                return {
+                    ...acc,
+                    [key]: getMaterializedValue(key, traversedValue, init),
+                };
+            }, {});
+        }
+        return node;
+    };
+    return traverse(rootNode);
+};
+const materialize = async (hailerResponse, init, authToken) => {
+    // TODO:
+    // const { activityIds } = findDependencies();
+    // const { activities } = loadDependencies(authToken);
+    const hailerResponseWithDependencies = mergeResponseWithDependencies(hailerResponse, init);
+    return hailerResponseWithDependencies;
+};
+exports.materialize = materialize;
+//# sourceMappingURL=materialize.js.map

package/dist/lib/normalizedName.d.ts

@@ -0,0 +1,7 @@
+export declare const getNormalizedName: (name: string) => string;
+export declare const getNormalizedNames: (names: string[]) => string[];
+export declare const getIdByNormalizedName: (name: string | undefined, options: {
+    name: string;
+    _id: string;
+}[]) => string | undefined;
+//# sourceMappingURL=normalizedName.d.ts.map

package/dist/lib/normalizedName.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdByNormalizedName = exports.getNormalizedNames = exports.getNormalizedName = void 0;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.createLogger)({ component: 'normalizedName' });
+const getNormalizedName = (name) => {
+    if (!name || typeof name !== "string") {
+        logger.warn("getNormalizedName called with invalid name", { name });
+        return "";
+    }
+    return name
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+};
+exports.getNormalizedName = getNormalizedName;
+const getNormalizedNames = (names) => names
+    .filter((name) => name && typeof name === "string")
+    .reduce((normalizedNames, name) => {
+    const normalizedName = (0, exports.getNormalizedName)(name);
+    if (normalizedNames.includes(normalizedName)) {
+        logger.error("Duplicate normalized name detected", { normalizedName, originalName: name });
+        return normalizedNames;
+    }
+    return [...normalizedNames, normalizedName];
+}, []);
+exports.getNormalizedNames = getNormalizedNames;
+const getIdByNormalizedName = (name, options) => {
+    if (!name) {
+        logger.warn("getIdByNormalizedName called with invalid name", { name });
+        return undefined;
+    }
+    const idByNormalizedName = options.reduce((acc, { name: optionName, _id }) => {
+        const normalizedName = (0, exports.getNormalizedName)(optionName);
+        if (acc[normalizedName]) {
+            logger.error("Duplicate normalized name in options", { normalizedName, optionName, _id });
+            return acc;
+        }
+        return { ...acc, [normalizedName]: _id };
+    }, {});
+    const normalizedInputName = (0, exports.getNormalizedName)(name);
+    const id = idByNormalizedName[normalizedInputName];
+    return id;
+};
+exports.getIdByNormalizedName = getIdByNormalizedName;
+//# sourceMappingURL=normalizedName.js.map

package/dist/lib/prompt-length-manager.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Prompt Length Manager
+ * Handles prompt length validation, truncation, and debugging
+ */
+export interface PromptComponent {
+    type: 'system' | 'user' | 'assistant' | 'tool_result' | 'tool_call';
+    content: string;
+    source?: string;
+    originalLength?: number;
+    truncated?: boolean;
+    originalContent?: string;
+    truncatedAt?: number;
+    truncationReason?: string;
+}
+export interface PromptAnalysis {
+    totalCharacters: number;
+    estimatedTokens: number;
+    components: PromptComponent[];
+    truncationApplied: boolean;
+    warnings: string[];
+}
+export interface TruncationConfig {
+    maxTotalTokens: number;
+    maxUserMessagesTokens: number;
+    maxTotalCharacters: number;
+    maxUserMessagesCharacters: number;
+    anthropicContextWindow: number;
+    openaiContextWindow: number;
+    preserveSystemPrompt: boolean;
+    preserveUserMessages: boolean;
+    preserveAssistantResponses: boolean;
+    truncateToolResponsesFirst: boolean;
+}
+export declare const DEFAULT_TRUNCATION_CONFIG: TruncationConfig;
+export declare class PromptLengthManager {
+    private logger;
+    private config;
+    constructor(config?: Partial<TruncationConfig>);
+    /**
+     * Estimate token count from character count
+     * Rough approximation: 1 token ≈ 4 characters for English text
+     */
+    private estimateTokens;
+    /**
+     * Count exact characters and estimate tokens for a text
+     */
+    private analyzeText;
+    /**
+     * Truncate text intelligently, preserving structure when possible
+     */
+    private truncateText;
+    /**
+     * Analyze prompt components and build analysis
+     */
+    analyzePrompt(components: PromptComponent[]): PromptAnalysis;
+    /**
+     * No longer truncate individual tool responses - only when total prompt exceeds limits
+     * This method now just passes through content unchanged and logs for monitoring
+     * TEMPORARILY DISABLED - Even monitoring/logging is disabled
+     */
+    truncateToolResponse(content: string, toolName: string): string;
+    /**
+     * Apply smart token-based truncation optimized for Claude 4
+     * TEMPORARILY DISABLED - All truncation logic commented out for testing
+     */
+    truncatePrompt(analysis: PromptAnalysis): PromptAnalysis;
+    /**
+     * Check if a provider-specific error indicates prompt too long
+     */
+    isPromptTooLongError(error: Error, provider: 'anthropic' | 'openai'): boolean;
+    /**
+     * Log comprehensive debug information about prompt structure
+     */
+    logPromptDebugInfo(analysis: PromptAnalysis, provider: string, botId?: string): void;
+    /**
+     * Generate a quick truncation summary for debugging
+     */
+    generateTruncationSummary(analysis: PromptAnalysis): string;
+}
+export declare const promptLengthManager: PromptLengthManager;
+//# sourceMappingURL=prompt-length-manager.d.ts.map