@hailer/mcp 0.1.14 → 0.1.16

package/dist/agents/shared/services/session-logger.js

@@ -0,0 +1,446 @@
+"use strict";
+/**
+ * Session Logger Service
+ *
+ * Manages per-activity session tracking and logging to Hailer workflows:
+ * - Tracks metrics (tokens, tool calls, messages)
+ * - Logs completed sessions to SESSION_LOG workflow
+ * - Manages idle session detection and flushing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionLoggerService = void 0;
+const types_1 = require("../../shared/types");
+class SessionLoggerService {
+    agentDirectoryId;
+    logger;
+    callMcpTool;
+    getDefaultTeamId;
+    activitySessions = new Map();
+    lastGlobalLogId = null;
+    idleCheckTimer = null;
+    anthropicClient = null;
+    schemaCache = null;
+    _currentWorkspaceId = null;
+    constructor(agentDirectoryId, logger, callMcpTool, getDefaultTeamId) {
+        this.agentDirectoryId = agentDirectoryId;
+        this.logger = logger;
+        this.callMcpTool = callMcpTool;
+        this.getDefaultTeamId = getDefaultTeamId;
+    }
+    /**
+     * Set the workspace schema cache for dynamic ID lookup
+     */
+    setSchemaCache(cache, workspaceId) {
+        this.schemaCache = cache;
+        this._currentWorkspaceId = workspaceId;
+    }
+    /**
+     * Get Session Log schema from cache for a specific workspace
+     */
+    getSessionLogSchema(workspaceId) {
+        if (!this.schemaCache || !workspaceId) {
+            return null;
+        }
+        return this.schemaCache.getSessionLogSchema(workspaceId) || null;
+    }
+    /**
+     * Set Anthropic client for generating summaries
+     */
+    setAnthropicClient(client) {
+        this.anthropicClient = client;
+    }
+    /**
+     * Get or create an activity session for tracking
+     * Multi-tenant: workspaceId is required for proper schema lookup
+     */
+    getOrCreateActivitySession(message) {
+        // Use linked activity ID as key, fallback to discussion ID
+        const sessionKey = message.linkedActivityId || message.discussionId;
+        let session = this.activitySessions.get(sessionKey);
+        if (!session) {
+            session = {
+                activityId: message.linkedActivityId || "",
+                activityName: message.linkedActivityName || `Discussion ${message.discussionId.substring(0, 8)}`,
+                discussionId: message.discussionId,
+                workspaceId: message.workspaceId, // Multi-tenant: store workspace for this session
+                startTime: Date.now(),
+                lastActivityTime: Date.now(),
+                metrics: {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    toolCalls: 0,
+                    writeOperations: 0,
+                    messagesProcessed: 0,
+                    responsesPosted: 0,
+                },
+                actions: [],
+                previousLogId: this.lastGlobalLogId,
+                conversation: [],
+                writeDetails: [],
+                triggerRequest: null,
+                requestedBy: null,
+                requestedById: null,
+            };
+            this.activitySessions.set(sessionKey, session);
+            this.logger.debug("Created new activity session", {
+                sessionKey,
+                workspaceId: message.workspaceId,
+                activityName: session.activityName,
+            });
+        }
+        return session;
+    }
+    /**
+     * Get session by key
+     */
+    getSession(key) {
+        return this.activitySessions.get(key);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return new Map(this.activitySessions);
+    }
+    /**
+     * Check for idle sessions and flush them
+     * Called periodically by timer
+     */
+    async checkAndFlushIdleSessions() {
+        const now = Date.now();
+        const sessionsToFlush = [];
+        for (const [key, session] of this.activitySessions) {
+            const idleTime = now - session.lastActivityTime;
+            if (idleTime >= types_1.SESSION_IDLE_TIMEOUT) {
+                sessionsToFlush.push(key);
+            }
+        }
+        for (const key of sessionsToFlush) {
+            const session = this.activitySessions.get(key);
+            if (session) {
+                await this.flushActivitySession(key, session);
+                this.activitySessions.delete(key);
+            }
+        }
+        if (sessionsToFlush.length > 0) {
+            this.logger.debug("Flushed idle sessions", { count: sessionsToFlush.length });
+        }
+    }
+    /**
+     * Flush a single activity session to the session log
+     */
+    async flushActivitySession(_key, session) {
+        // Only log if WRITE operations occurred (skip read-only sessions)
+        if (session.metrics.writeOperations === 0) {
+            this.logger.debug("Skipping session log - no write operations", {
+                activity: session.activityName,
+                toolCalls: session.metrics.toolCalls,
+            });
+            return;
+        }
+        // Get dynamic schema for this session's workspace
+        const schema = this.getSessionLogSchema(session.workspaceId);
+        if (!schema) {
+            this.logger.debug("Skipping session log - no Session Log workflow in workspace", {
+                workspaceId: session.workspaceId,
+            });
+            return;
+        }
+        if (!this.agentDirectoryId) {
+            this.logger.debug("Skipping session log - no agent directory ID");
+            return;
+        }
+        try {
+            // Build descriptive session name from first write operation
+            let sessionName;
+            if (session.writeDetails.length > 0) {
+                sessionName = session.writeDetails[0].what;
+            }
+            else {
+                sessionName = session.activityName || `Session ${new Date().toISOString()}`;
+            }
+            // Build context summary (now async - includes conversation summary)
+            const summary = await this.buildActivitySessionSummary(session);
+            // Calculate total tokens
+            const totalTokens = session.metrics.inputTokens + session.metrics.outputTokens;
+            // Get field IDs from schema (use our standard keys that were mapped)
+            const contextSummaryFieldId = schema.fields["contextSummary"] || schema.fields["Context summary"];
+            const madeByFieldId = schema.fields["madeBy"] || schema.fields["Log entry made by"];
+            const costFieldId = schema.fields["cost"] || schema.fields["Tokens Used"];
+            const previousLogFieldId = schema.fields["previousLog"] || schema.fields["Previus log entry"];
+            const linkedWorkFieldId = schema.fields["linkedWork"] || schema.fields["Most relevant link to work"];
+            // Build fields
+            const fields = {};
+            if (contextSummaryFieldId) {
+                fields[contextSummaryFieldId] = summary;
+            }
+            if (madeByFieldId && this.agentDirectoryId) {
+                fields[madeByFieldId] = this.agentDirectoryId;
+            }
+            if (costFieldId) {
+                fields[costFieldId] = totalTokens;
+            }
+            // Chain to previous log
+            if (session.previousLogId && previousLogFieldId) {
+                fields[previousLogFieldId] = session.previousLogId;
+            }
+            // Link to activity being worked on
+            if (session.activityId && linkedWorkFieldId) {
+                fields[linkedWorkFieldId] = session.activityId;
+            }
+            // Get phase ID (try "active" first, then first available)
+            const phaseId = schema.phases["active"] || Object.values(schema.phases)[0];
+            const createParams = {
+                workflowId: schema.workflowId,
+                name: sessionName,
+                phaseId,
+                fields,
+            };
+            const wsTeamId = this.getDefaultTeamId();
+            if (wsTeamId) {
+                createParams.teamId = wsTeamId;
+            }
+            const result = await this.callMcpTool("create_activity", createParams);
+            // Extract created ID for chaining
+            const resultText = result?.content?.[0]?.text;
+            if (resultText) {
+                const idMatch = resultText.match(/"_id":\s*"([a-f0-9]{24})"/i) ||
+                    resultText.match(/`([a-f0-9]{24})`/);
+                if (idMatch) {
+                    this.lastGlobalLogId = idMatch[1];
+                }
+            }
+            const durationSec = Math.round((Date.now() - session.startTime) / 1000);
+            this.logger.info("Activity session logged", {
+                activity: session.activityName,
+                durationSec,
+                messages: session.metrics.messagesProcessed,
+                toolCalls: session.metrics.toolCalls,
+                tokens: totalTokens,
+            });
+        }
+        catch (error) {
+            this.logger.warn("Failed to flush activity session", {
+                activity: session.activityName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Flush all active sessions (called on shutdown)
+     */
+    async flushAllSessions() {
+        for (const [key, session] of this.activitySessions) {
+            await this.flushActivitySession(key, session);
+        }
+        this.activitySessions.clear();
+    }
+    /**
+     * Build summary for an activity session
+     * Now includes conversation summary for memory recall
+     */
+    async buildActivitySessionSummary(session) {
+        const lines = [];
+        // Who requested this
+        if (session.requestedBy) {
+            lines.push(`**Requested by:** ${session.requestedBy}`);
+        }
+        // What they asked for
+        if (session.triggerRequest) {
+            lines.push(`**Request:** "${session.triggerRequest}"`);
+        }
+        // What was changed (write operations only)
+        if (session.writeDetails.length > 0) {
+            lines.push("");
+            lines.push(`**Changes made:**`);
+            for (const detail of session.writeDetails) {
+                lines.push(`- ${detail.what}`);
+            }
+        }
+        // Generate and include conversation summary for memory
+        const conversationSummary = await this.generateConversationSummary(session);
+        if (conversationSummary) {
+            lines.push("");
+            lines.push(`**Conversation:** ${conversationSummary}`);
+        }
+        lines.push("");
+        lines.push("---");
+        lines.push("");
+        // Metrics (compact)
+        const duration = Math.round((Date.now() - session.startTime) / 1000);
+        const totalTokens = session.metrics.inputTokens + session.metrics.outputTokens;
+        lines.push(`**Stats:** ${session.metrics.writeOperations} writes, ${totalTokens} tokens, ${duration}s`);
+        return lines.join("\n");
+    }
+    /**
+     * Start periodic idle session checking
+     */
+    startIdleCheckTimer(intervalMs = 30_000) {
+        if (this.idleCheckTimer) {
+            clearInterval(this.idleCheckTimer);
+        }
+        this.idleCheckTimer = setInterval(() => {
+            this.checkAndFlushIdleSessions().catch(err => {
+                this.logger.warn("Error checking idle sessions", { error: err });
+            });
+        }, intervalMs);
+    }
+    /**
+     * Stop idle check timer
+     */
+    stopIdleCheckTimer() {
+        if (this.idleCheckTimer) {
+            clearInterval(this.idleCheckTimer);
+            this.idleCheckTimer = null;
+        }
+    }
+    // ===== MEMORY SYSTEM =====
+    /**
+     * Generate a conversation summary using LLM
+     * Creates a condensed memory of what was discussed
+     */
+    async generateConversationSummary(session) {
+        if (!this.anthropicClient || session.conversation.length === 0) {
+            return null;
+        }
+        try {
+            const response = await this.anthropicClient.messages.create({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 500,
+                messages: [
+                    {
+                        role: "user",
+                        content: `Summarize this conversation in 2-3 sentences for future context. Focus on:
+- What the user wanted to accomplish
+- Key decisions or preferences expressed
+- Important context for future interactions
+
+Conversation:
+${session.conversation.join("\n")}
+
+Summary:`,
+                    },
+                ],
+            });
+            const textBlock = response.content.find((b) => b.type === "text");
+            return textBlock?.text || null;
+        }
+        catch (error) {
+            this.logger.warn("Failed to generate conversation summary", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Load memory entries for an activity from SESSION_LOG
+     * Returns past conversation summaries for context injection
+     *
+     * NOTE: ActivityLink fields store objects {_id, name}, so we fetch recent
+     * session logs and filter client-side by checking the nested _id.
+     */
+    async loadMemoryForActivity(activityId, workspaceId, limit = 5) {
+        if (!activityId || !workspaceId) {
+            return [];
+        }
+        // Get dynamic schema for this workspace
+        const schema = this.getSessionLogSchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("Cannot load memory - no Session Log workflow in workspace", { workspaceId });
+            return [];
+        }
+        // Get field IDs from schema
+        const contextSummaryFieldId = schema.fields["contextSummary"] || schema.fields["Context summary"];
+        const linkedWorkFieldId = schema.fields["linkedWork"] || schema.fields["Most relevant link to work"];
+        const phaseId = schema.phases["active"] || Object.values(schema.phases)[0];
+        if (!contextSummaryFieldId || !linkedWorkFieldId || !phaseId) {
+            this.logger.debug("Cannot load memory - missing required fields in schema");
+            return [];
+        }
+        try {
+            // Query SESSION_LOG for recent sessions (fetch more to filter client-side)
+            // ActivityLink filters don't work with simple equals, so we filter after
+            const result = await this.callMcpTool("list_activities", {
+                workflowId: schema.workflowId,
+                phaseId,
+                fields: [contextSummaryFieldId, linkedWorkFieldId],
+                limit: 50, // Fetch more, filter client-side
+                sortBy: "created",
+                sortOrder: "desc",
+            });
+            const resultText = result?.content?.[0]?.text;
+            if (!resultText) {
+                return [];
+            }
+            // Parse the response to extract memory entries
+            const entries = [];
+            // Try to parse as JSON array
+            try {
+                const parsed = JSON.parse(resultText);
+                const activities = parsed.activities || parsed.data || parsed;
+                if (Array.isArray(activities)) {
+                    for (const activity of activities) {
+                        // Get linkedWork field - it's an ActivityLink with nested {_id, name}
+                        const linkedWorkField = activity.fields?.[linkedWorkFieldId];
+                        const linkedWorkId = linkedWorkField?.value?._id || linkedWorkField?._id;
+                        // Filter: only include entries linked to our target activity
+                        if (linkedWorkId !== activityId) {
+                            continue;
+                        }
+                        // Get context summary
+                        const summaryField = activity.fields?.[contextSummaryFieldId];
+                        const summary = summaryField?.value || summaryField;
+                        if (summary) {
+                            // Extract conversation summary section if present
+                            const conversationMatch = summary.match(/\*\*Conversation:\*\*\s*([\s\S]*?)(?=\n\n\*\*|---\n|$)/);
+                            const memorySummary = conversationMatch?.[1]?.trim() || summary;
+                            entries.push({
+                                sessionId: activity._id,
+                                timestamp: activity.created || Date.now(),
+                                summary: memorySummary,
+                                linkedActivityId: activityId,
+                            });
+                            // Stop once we have enough
+                            if (entries.length >= limit) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Not JSON, try regex extraction (fallback)
+                this.logger.debug("Failed to parse as JSON, using regex fallback");
+            }
+            this.logger.debug("Loaded memory entries", {
+                activityId,
+                count: entries.length,
+            });
+            return entries;
+        }
+        catch (error) {
+            this.logger.warn("Failed to load memory for activity", {
+                activityId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Format memory entries for injection into conversation context
+     */
+    formatMemoryForContext(entries) {
+        if (entries.length === 0) {
+            return "";
+        }
+        const lines = ["<previous_memory>", "Past interactions with this activity:"];
+        for (const entry of entries) {
+            const date = new Date(entry.timestamp).toLocaleDateString();
+            lines.push(`- [${date}] ${entry.summary}`);
+        }
+        lines.push("</previous_memory>");
+        return lines.join("\n");
+    }
+}
+exports.SessionLoggerService = SessionLoggerService;
+//# sourceMappingURL=session-logger.js.map

package/dist/agents/shared/services/tool-executor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Tool Executor Service
+ *
+ * Handles MCP tool execution:
+ * - Executes tool calls from LLM
+ * - Tracks write operations
+ * - Extracts write details for logging
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { Logger } from "../../../lib/logger";
+import { McpClientService } from "./mcp-client";
+import { WriteDetail, ActivitySession, ToolInput, McpToolResult } from "../../shared/types";
+export interface ToolExecutionResult {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+}
+export interface ToolExecutionContext {
+    session?: ActivitySession;
+    preprocessToolInput?: (toolName: string, input: ToolInput) => ToolInput;
+}
+export declare class ToolExecutor {
+    private mcpClient;
+    private logger;
+    private static WRITE_TOOLS;
+    constructor(mcpClient: McpClientService, logger: Logger);
+    /**
+     * Check if a tool is a write operation
+     */
+    isWriteTool(toolName: string): boolean;
+    /**
+     * Execute a list of tool calls and return results
+     */
+    executeTools(toolUseBlocks: Anthropic.ToolUseBlock[], context?: ToolExecutionContext): Promise<ToolExecutionResult[]>;
+    /**
+     * Extract details about a write operation for logging
+     */
+    extractWriteDetail(toolName: string, input: ToolInput, result: McpToolResult): WriteDetail | null;
+}
+//# sourceMappingURL=tool-executor.d.ts.map

package/dist/agents/shared/services/tool-executor.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Tool Executor Service
+ *
+ * Handles MCP tool execution:
+ * - Executes tool calls from LLM
+ * - Tracks write operations
+ * - Extracts write details for logging
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = void 0;
+class ToolExecutor {
+    mcpClient;
+    logger;
+    // Tools that modify data in Hailer (vs read-only tools)
+    static WRITE_TOOLS = new Set([
+        "create_activity",
+        "update_activity",
+        "add_discussion_message",
+        "invite_discussion_members",
+        "join_discussion",
+        "create_insight",
+        "update_insight",
+        "remove_insight",
+        "create_app",
+        "update_app",
+        "remove_app",
+        "install_workflow",
+        "remove_workflow",
+        "update_workflow_field",
+        "update_workflow_phase",
+        "upload_files",
+    ]);
+    constructor(mcpClient, logger) {
+        this.mcpClient = mcpClient;
+        this.logger = logger;
+    }
+    /**
+     * Check if a tool is a write operation
+     */
+    isWriteTool(toolName) {
+        return ToolExecutor.WRITE_TOOLS.has(toolName);
+    }
+    /**
+     * Execute a list of tool calls and return results
+     */
+    async executeTools(toolUseBlocks, context = {}) {
+        const { session, preprocessToolInput } = context;
+        const toolResults = [];
+        for (const toolUse of toolUseBlocks) {
+            this.logger.info("Executing tool", { tool: toolUse.name });
+            // Track tool call in session
+            if (session) {
+                session.metrics.toolCalls++;
+                session.actions.push(`Tool: ${toolUse.name}`);
+                session.lastActivityTime = Date.now();
+            }
+            try {
+                // Load full schema if needed (uses service's cache)
+                await this.mcpClient.loadToolSchemaIfNeeded(toolUse.name);
+                // Allow preprocessing of tool input (cast from Anthropic's unknown type)
+                const rawInput = toolUse.input;
+                const toolInput = preprocessToolInput
+                    ? preprocessToolInput(toolUse.name, rawInput)
+                    : rawInput;
+                const result = await this.mcpClient.callMcpTool(toolUse.name, toolInput);
+                const resultContent = JSON.stringify(result?.content || {});
+                // Track write operations for session logging
+                if (session && this.isWriteTool(toolUse.name)) {
+                    session.metrics.writeOperations++;
+                    const writeDetail = this.extractWriteDetail(toolUse.name, toolInput, result);
+                    if (writeDetail) {
+                        session.writeDetails.push(writeDetail);
+                    }
+                }
+                toolResults.push({
+                    type: "tool_result",
+                    tool_use_id: toolUse.id,
+                    content: resultContent,
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.warn("Tool execution failed", {
+                    tool: toolUse.name,
+                    error: errorMessage,
+                });
+                toolResults.push({
+                    type: "tool_result",
+                    tool_use_id: toolUse.id,
+                    content: `Error: ${errorMessage}`,
+                    is_error: true,
+                });
+            }
+        }
+        return toolResults;
+    }
+    /**
+     * Extract details about a write operation for logging
+     */
+    extractWriteDetail(toolName, input, result) {
+        try {
+            const resultText = result?.content?.[0]?.text || "";
+            // Extract activity ID from result if present
+            const idMatch = resultText.match(/"_id":\s*"([a-f0-9]{24})"/i) ||
+                resultText.match(/`([a-f0-9]{24})`/);
+            const targetId = idMatch?.[1] || input.activityId || input.discussionId;
+            switch (toolName) {
+                case "create_activity":
+                    return {
+                        tool: toolName,
+                        what: `Created activity "${input.name || 'unnamed'}"`,
+                        targetId,
+                    };
+                case "update_activity": {
+                    const fieldCount = input.fields ? Object.keys(input.fields).length : 0;
+                    return {
+                        tool: toolName,
+                        what: `Updated ${fieldCount} field(s)${input.name ? ` on "${input.name}"` : ''}`,
+                        targetId: input.activityId,
+                    };
+                }
+                case "add_discussion_message": {
+                    const msgPreview = input.content?.substring(0, 50) || "";
+                    return {
+                        tool: toolName,
+                        what: `Posted message: "${msgPreview}${msgPreview.length >= 50 ? '...' : ''}"`,
+                        targetId: input.discussionId,
+                    };
+                }
+                case "invite_discussion_members":
+                    return {
+                        tool: toolName,
+                        what: `Invited ${input.userIds?.length || 0} member(s) to discussion`,
+                        targetId: input.discussionId,
+                    };
+                case "join_discussion":
+                    return {
+                        tool: toolName,
+                        what: input.inviteUserId ? "Invited user to discussion" : "Joined discussion",
+                        targetId: input.activityId || input.discussionId,
+                    };
+                case "create_insight":
+                    return {
+                        tool: toolName,
+                        what: `Created insight "${input.name || 'unnamed'}"`,
+                        targetId,
+                    };
+                case "update_insight":
+                    return {
+                        tool: toolName,
+                        what: `Updated insight`,
+                        targetId: input.insightId,
+                    };
+                default:
+                    return {
+                        tool: toolName,
+                        what: `Executed ${toolName}`,
+                        targetId,
+                    };
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.ToolExecutor = ToolExecutor;
+//# sourceMappingURL=tool-executor.js.map