@hailer/mcp 0.0.1

package/dist/client/providers/llm-provider.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlmProvider = void 0;
+const logger_1 = require("../../lib/logger");
+const agent_tracker_1 = require("../agent-tracker");
+const prompt_length_manager_1 = require("../../lib/prompt-length-manager");
+const UserContextCache_1 = require("../../mcp/UserContextCache");
+// TODO:
+// Move all message responding logic out of LLMProvider to a separate place.
+// Read config from a global variable.
+// Replace LLM provider pattern with thin API wrappers.
+class LlmProvider {
+    name;
+    type;
+    config;
+    logger;
+    agentTracker;
+    promptLengthManager;
+    constructor(config) {
+        this.config = config;
+        this.name = config.name;
+        this.type = config.type;
+        this.logger = (0, logger_1.createLogger)({
+            component: `${config.type}Provider`,
+            provider: config.name,
+        });
+        this.agentTracker = (0, agent_tracker_1.createAgentTracker)(this.logger);
+        this.promptLengthManager = new prompt_length_manager_1.PromptLengthManager();
+    }
+    isEnabled() {
+        return this.config.enabled && !!this.config.apiKey;
+    }
+    /**
+     * Get the confirmation prompt template
+     */
+    getConfirmationPrompt(userMessage) {
+        return `You are an AI assistant. Generate a brief, friendly confirmation message (1-2 sentences) that acknowledges what the user is asking for and indicates you're working on it. Make it clear that you'll follow up with the results shortly. Be conversational and personalized.
+
+User message: "${this.removeMentions(userMessage)}"
+User name: ${userMessage.userName}
+
+Examples of good confirmations:
+- "I'll help you find information about the project status and get back to you shortly with the results."
+- "I'll look into that workflow for you right away and share what I find."
+- "Let me check the recent activities and I'll have the details for you in a moment."
+- "I'll analyze that data and provide you with the complete results shortly."
+
+IMPORTANT: Respond in the same language as the user message. Respond very concisely.
+
+Generate a similar confirmation message:`;
+    }
+    /**
+     * Fetch additional context for the bot to better understand the current situation
+     */
+    async fetchContextualInformation(mcpServerUrl, mcpServerApiKey, message) {
+        let workspaceInfo = "";
+        let recentMessages = "";
+        try {
+            // Fetch current workspace information
+            const workspaceResponse = await this.callMcpTool(mcpServerUrl, mcpServerApiKey, {
+                name: "get_current_workspace",
+                arguments: {},
+            });
+            if (workspaceResponse?.content?.[0]?.text) {
+                workspaceInfo = workspaceResponse.content[0].text;
+            }
+        }
+        catch (error) {
+            this.logger.warn("Failed to fetch workspace context", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            workspaceInfo = "Unable to fetch current workspace information";
+        }
+        try {
+            // Fetch recent discussion messages (last 10)
+            const messagesResponse = await this.callMcpTool(mcpServerUrl, mcpServerApiKey, {
+                name: "fetch_discussion_messages",
+                arguments: {
+                    discussionId: message.discussionId,
+                },
+            });
+            if (messagesResponse?.content?.[0]?.text) {
+                recentMessages = messagesResponse.content[0].text;
+            }
+        }
+        catch (error) {
+            this.logger.warn("Failed to fetch discussion messages", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            recentMessages = "Unable to fetch recent discussion messages";
+        }
+        return { workspaceInfo, recentMessages };
+    }
+    logToolCall(toolName, args, duration) {
+        this.logger.toolCall(toolName, this.name, args, { duration });
+    }
+    logError(error, context) {
+        this.logger.error(`${this.name} Provider Error (${context})`, error, {
+            provider: this.name,
+            context,
+        });
+    }
+    async createSystemPrompt(options) {
+        const { userMessage, mcpServerUrl, mcpServerApiKey, botEmail } = options;
+        const agentSpecificPrompt = await this.fetchAgentSpecificPrompt(botEmail, mcpServerUrl, mcpServerApiKey);
+        const workspacesPrompt = await this.buildWorkspacesPrompt(mcpServerApiKey);
+        const systemPrompt = this.buildSystemPrompt(userMessage, agentSpecificPrompt, workspacesPrompt);
+        this.logger.debug("Generated system prompt", {
+            promptLength: systemPrompt.length,
+            hasAgentPrompt: !!agentSpecificPrompt,
+        });
+        return systemPrompt;
+    }
+    async buildWorkspacesPrompt(mcpServerApiKey) {
+        const userContext = await UserContextCache_1.UserContextCache.getContext(mcpServerApiKey);
+        return `- Workspaces
+${Object.values(userContext.workspaceCache.allWorkspaces)
+            .map(({ _id, name }) => `\n  - Name: ${name}\n  - Id: ${_id}`)
+            .join()}`;
+    }
+    async fetchAgentSpecificPrompt(botEmail, mcpServerUrl, mcpServerApiKey) {
+        try {
+            // I. Find "HR for AI Agents" workspace and get its ID
+            const workspacesResponse = await this.callMcpTool(mcpServerUrl, mcpServerApiKey, {
+                name: "list_workspaces",
+                arguments: {},
+            });
+            // Extract workspace info from the response
+            let hrWorkspaceId = null;
+            if (workspacesResponse?.content?.[0]?.text) {
+                const workspaceText = workspacesResponse.content[0].text;
+                // Look for "HR for AI Agents" workspace in the response
+                const hrWorkspaceMatch = workspaceText.match(/\*\*HR for AI Agents\*\*[^]*?ID:\s*(\w{24})/i);
+                if (hrWorkspaceMatch) {
+                    hrWorkspaceId = hrWorkspaceMatch[1];
+                }
+            }
+            if (!hrWorkspaceId) {
+                this.logger.warn("HR for AI Agents workspace not found, no agent-specific prompt fetched", {
+                    botEmail,
+                });
+                return "";
+            }
+            // II. Find 'Agent Directory' workflow and get its ID
+            const workflowsResponse = await this.callMcpTool(mcpServerUrl, mcpServerApiKey, {
+                name: "list_workflows",
+                arguments: {
+                    workspaceId: hrWorkspaceId,
+                    limit: 1000,
+                },
+            });
+            // Look for the Agent Directory workflow
+            let agentDirectoryWorkflowId = null;
+            if (workflowsResponse?.content?.[0]?.text) {
+                const workflowText = workflowsResponse.content[0].text;
+                // Look for "🤖 Agent Directory" workflow - find the specific workflow object
+                const agentDirMatch = workflowText.match(/\{\s*"id":\s*"(\w{24})"[^}]*"name":\s*"🤖 Agent Directory"[^}]*\}/i);
+                if (agentDirMatch) {
+                    agentDirectoryWorkflowId = agentDirMatch[1];
+                }
+            }
+            if (!agentDirectoryWorkflowId) {
+                this.logger.warn("Agent Directory workflow not found in HR workspace, no agent-specific prompt fetched", {
+                    botEmail,
+                    hrWorkspaceId,
+                });
+                return "";
+            }
+            // III. Get workflow schema to find the email and description (agent specific prompt) fields' IDs
+            const workflowInfoResponse = await this.callMcpTool(mcpServerUrl, mcpServerApiKey, {
+                name: "get_workflow_info",
+                arguments: {
+                    workflowId: agentDirectoryWorkflowId,
+                    includeFields: true,
+                    includePhases: true,
+                },
+            });
+            // Extract field IDs for email and description fields, and phase ID for deployed agents
+            let emailFieldId = null;
+            let descriptionFieldId = null;
+            let deployedAgentsPhaseId = null;
+            if (workflowInfoResponse?.content?.[0]?.text) {
+                const schemaText = workflowInfoResponse.content[0].text;
+                // Look for email field by finding the field with key "agentEmailInHailer"
+                const emailFieldMatch = schemaText.match(/"id":\s*"(\w{24})"[^}]*"key":\s*"agentEmailInHailer"/i);
+                if (emailFieldMatch) {
+                    emailFieldId = emailFieldMatch[1];
+                }
+                // Look for description field by finding the field with key "agentmemoryThatAgentUsesToFindWhatToDo"
+                const descFieldMatch = schemaText.match(/"id":\s*"(\w{24})"[^}]*"key":\s*"agentmemoryThatAgentUsesToFindWhatToDo"/i);
+                if (descFieldMatch) {
+                    descriptionFieldId = descFieldMatch[1];
+                }
+                // Look for "Deployed agents" phase ID by finding the ID that comes right before the name
+                const deployedPhaseMatch = schemaText.match(/"id":\s*"6836bcbb7f06312dd30dfd60"[^}]*"name":\s*"Deployed agents"/i);
+                if (deployedPhaseMatch) {
+                    deployedAgentsPhaseId = "6836bcbb7f06312dd30dfd60";
+                }
+                else {
+                    // Fallback: try to extract it dynamically
+                    const dynamicMatch = schemaText.match(/"name":\s*"Deployed agents"[^}]*"id":\s*"(\w{24})"|"id":\s*"(\w{24})"[^}]*"name":\s*"Deployed agents"/i);
+                    if (dynamicMatch) {
+                        deployedAgentsPhaseId = dynamicMatch[1] || dynamicMatch[2];
+                    }
+                }
+            }
+            if (!emailFieldId) {
+                this.logger.warn("Email field not found in Agent Directory schema", {
+                    botEmail,
+                    agentDirectoryWorkflowId,
+                });
+                return "";
+            }
+            // IV. Get the agent specific activity by email
+            // Filter activities to find the agent with matching email
+            const agentActivitiesResponse = await this.callMcpTool(mcpServerUrl, mcpServerApiKey, {
+                name: "filter_activities",
+                arguments: {
+                    workflowId: agentDirectoryWorkflowId,
+                    phaseId: deployedAgentsPhaseId,
+                    filters: {
+                        [emailFieldId]: {
+                            operator: "equals",
+                            value: botEmail,
+                        },
+                    },
+                    limit: 1,
+                },
+            });
+            // Extract the agent description from the response
+            if (agentActivitiesResponse?.content?.[0]?.text) {
+                const responseText = agentActivitiesResponse.content[0].text;
+                // Try to find the description field directly from the text without JSON parsing
+                try {
+                    // Look for the Description field value in the text response
+                    const descriptionMatch = responseText.match(/"fieldName":\s*"Description",\s*"value":\s*"([^"]*(?:\\.[^"]*)*)"/);
+                    if (descriptionMatch && descriptionMatch[1]) {
+                        // Unescape JSON string
+                        const description = descriptionMatch[1]
+                            .replace(/\\"/g, '"')
+                            .replace(/\\\\/g, "\\");
+                        this.logger.info("Found agent-specific prompt", {
+                            botEmail,
+                            description: description.substring(0, 100) +
+                                (description.length > 100 ? "..." : ""),
+                        });
+                        return description;
+                    }
+                    // Fallback: Try JSON parsing with better regex
+                    const jsonMatch = responseText.match(/\[[\s\S]*\]/);
+                    if (jsonMatch) {
+                        const activities = JSON.parse(jsonMatch[0]);
+                        if (activities.length > 0) {
+                            const agentActivity = activities[0];
+                            // Look for description in fieldsAndValues array (new format)
+                            if (agentActivity.fieldsAndValues &&
+                                Array.isArray(agentActivity.fieldsAndValues)) {
+                                const descriptionField = agentActivity.fieldsAndValues.find((field) => field.fieldName === "Description");
+                                if (descriptionField &&
+                                    descriptionField.value &&
+                                    typeof descriptionField.value === "string") {
+                                    this.logger.info("Found agent-specific prompt from fieldsAndValues", { botEmail });
+                                    return descriptionField.value;
+                                }
+                            }
+                            // Fallback: Look in old format (fields object)
+                            if (descriptionFieldId) {
+                                const description = agentActivity.fields?.[descriptionFieldId]?.value ||
+                                    agentActivity.data?.[descriptionFieldId] ||
+                                    agentActivity[descriptionFieldId];
+                                if (description && typeof description === "string") {
+                                    this.logger.info("Found agent-specific prompt from legacy fields", { botEmail });
+                                    return description;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (parseError) {
+                    this.logger.warn("Failed to parse agent activities response", {
+                        parseError: parseError instanceof Error
+                            ? parseError.message
+                            : String(parseError),
+                        botEmail,
+                    });
+                }
+            }
+            this.logger.warn("No agent description found for email", { botEmail });
+            return "";
+        }
+        catch (error) {
+            this.logger.warn("Agent-specific prompt not available (optional feature)", {
+                botEmail,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+            return "";
+        }
+    }
+    buildSystemPrompt(userMessage, agentSpecificPrompt, workspacesPrompt) {
+        const now = new Date();
+        const currentYear = now.getFullYear();
+        const currentMonth = now.toLocaleString('en-US', { month: 'long' });
+        const currentDate = now.toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+        const systemPrompt = `You are an AI assistant helping with Hailer workspace management.
+
+⏰ CURRENT DATE & TIME (CRITICAL - USE THIS FOR ALL DATE CALCULATIONS):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📅 Today: ${currentDate}
+📅 Current Year: ${currentYear}
+📅 Current Month: ${currentMonth} ${currentYear}
+
+IMPORTANT: When users mention months like "January", "February", "March" without a year:
+- Use ${currentYear} (THIS year)
+- "January" = January ${currentYear}, NOT any past year
+- Calculate Unix timestamps for ${currentYear} dates
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Context:
+- User: ${userMessage.userName} (ID: ${userMessage.userId})
+- Discussion: ${userMessage.discussionId}
+${workspacesPrompt}
+- Message: "${this.removeMentions(userMessage)}"
+
+Core Knowledge of Hailer:
+Hailer is a SaaS-based platform for managing business processes and communication.
+1. The system is built around Workspaces (previously called Networks), which contain two core structures:
+- Workflows (formerly Processes)
+- Datasets
+Both Workflows and Datasets can be viewed as tables of Activities, where each Activity is similar to a row containing structured fields.
+Datasets hold static records, typically used for reference or background data.
+Workflows are similar to datasets, but each activity includes a phase field, enabling Kanban visualization. Activities can also be viewed in a table view, one phase at a time.
+To list activities, list workflows first.
+2. Activities:
+Activities are the core data units in Hailer. They can include many types of fields (text, date, user, number, linked activity, etc.) and support custom logic fields (function fields) that use simple code (e.g. JavaScript). These fields allow dynamic data updates, aggregations, and calculations based on related activities.
+This makes Hailer a powerful, modular, and customizable platform—especially effective for automating workflows and managing structured data across teams.
+Each activity also includes its own discussion thread, which users can join or leave. These discussions allow team members to collaborate directly in context, share files, and keep communication structured around specific tasks or data entries.
+3. Each workspace contains feed (same idea as in Facebook).
+4. Visibility and access are controlled via user roles and teams.
+5. Workspace data is isolated, and cannot be shared across workspaces.
+
+
+IMPORTANT INSTRUCTIONS:
+
+- IF THERE IS A WORKFLOW RELATED TO THE USER'S QUESTION, USE list_activities TOOL. OTHERWISE USE search_activities TOOL.
+- **CONVERSATION HISTORY**: Recent conversation history (last 10 messages) is already loaded and visible in the message context above. You can see previous messages directly - DO NOT call fetch_discussion_messages unless you specifically need older messages beyond what's already visible.
+- Don't hesitate to call multiple tools to get a complete picture before providing your response.
+- **DATE FILTERING**: When filtering activities by date ranges (months, weeks, etc.), ALWAYS use ${currentYear} unless the user explicitly mentions a different year. For example, "January" means "January ${currentYear}", not any past year. Calculate Unix timestamps based on the current year shown above.
+- **COMPREHENSIVE ANALYSIS**: For generic/broad questions, combine quantitative data (counts, metrics, trends) with qualitative data (discussions, comments) from multiple sources before concluding. Don't rely on limited data for generic questions.
+- **EXPLAIN YOUR REASONING**: For complex queries where you analyzed data, searched activities, or used multiple tools, end your response with a brief "How I analyzed this:" section (1-5 sentences) explaining what data you examined. Use user-friendly language (e.g., "I reviewed activities and discussions" not "I called list_activities tool"). For simple conversational questions (greetings, simple facts, clarifications), skip this section entirely.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+SISKON SIIVOUS QUALITY CONTROL AI AGENT - DATE FIELD INSTRUCTIONS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+You are the Siskon siivous quality control AI agent. When asked about dates referring to quality control visits or customer service process tickets, ALWAYS base the analysis on the "date" field by default, which is the date the visit happened or the topic is about. Do NOT use the created or updated date fields unless the user specifically asks about those fields. When explaining your analysis, and applicable depending on the question, specify which date field you used (e.g., "I analyzed visits based on the 'date' field" or "I used the 'created' date field as requested").
+
+${agentSpecificPrompt}`;
+        return systemPrompt;
+    }
+    removeMentions(message) {
+        return message.content
+            .replace(/\[hailerTag\|[^\]]+\]\([^)]+\)/g, "") // Remove hailerTag mentions
+            .replace(/@mcp-agent\s*/gi, "") // Fallback for old format
+            .trim();
+    }
+}
+exports.LlmProvider = LlmProvider;
+//# sourceMappingURL=llm-provider.js.map

package/dist/client/providers/openai-provider.d.ts

@@ -0,0 +1,23 @@
+import { ChatMessage, McpResponse } from "../types";
+import { LlmProvider } from "./llm-provider";
+export declare class OpenAIProvider extends LlmProvider {
+    private client;
+    private contextManager;
+    private toolSchemaLoader;
+    private toolExecutor;
+    constructor(config: any);
+    generateConfirmationMessage(userMessage: ChatMessage): Promise<string>;
+    processMessage(userMessage: ChatMessage, mcpServerUrl: string, botMcpApiKey: string, botEmail: string): Promise<McpResponse>;
+    /**
+     * Convert tool index to OpenAI tool format
+     * Loads full schemas for all tools (for now - could optimize with on-demand loading later)
+     */
+    private convertToolIndexToOpenAIFormat;
+    /**
+     * Build optimized tools list: full schemas for loaded tools, minimal stubs for others
+     */
+    private buildOptimizedTools;
+    protected callMcpTool(mcpServerUrl: string, mcpServerApiKey: string, request: any): Promise<any>;
+    private handleDirectResponse;
+}
+//# sourceMappingURL=openai-provider.d.ts.map