@hailer/mcp 0.1.16 → 0.2.1

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

@@ -1,446 +0,0 @@
-"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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,169 +0,0 @@
-"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