@memberjunction/messaging-adapters 0.0.1 → 5.17.0

package/dist/base/BaseMessagingAdapter.d.ts

@@ -0,0 +1,428 @@
+/**
+ * @module @memberjunction/messaging-adapters
+ * @description Abstract base class for messaging platform adapters.
+ *
+ * Handles the common flow: receive message -> resolve user -> fetch thread history
+ * -> run agent -> stream updates -> send final response.
+ *
+ * Platform subclasses (Slack, Teams) implement the abstract methods for
+ * platform-specific operations like sending messages and fetching threads.
+ */
+import { ExecuteAgentResult, MJAIAgentEntityExtended } from '@memberjunction/ai-core-plus';
+import { UserInfo } from '@memberjunction/core';
+import { MessagingAdapterSettings, IncomingMessage, FormattedResponse, AgentIdentity, AgentResponseMetadata } from './types.js';
+/**
+ * Abstract base class for messaging platform adapters.
+ *
+ * Handles the common orchestration flow that is shared across all messaging
+ * platforms (Slack, Teams, Discord, etc.):
+ *
+ * 1. Receive an incoming message
+ * 2. Determine if the bot should respond (DM, @mention, etc.)
+ * 3. Resolve the platform user to an MJ UserInfo
+ * 4. Show a typing/thinking indicator
+ * 5. Fetch thread history for conversation context
+ * 6. Route to the correct agent (default or @mentioned)
+ * 7. Run the agent via `AgentRunner.RunAgent()` with streaming
+ * 8. Send progressive streaming updates to the platform
+ * 9. Send the final formatted response
+ *
+ * Platform subclasses implement the abstract methods for platform-specific
+ * operations (sending messages, fetching threads, formatting responses).
+ *
+ * This class is NOT a `BaseServerExtension` itself — the platform-specific
+ * Extension classes (e.g., `SlackMessagingExtension`) own the Express route
+ * registration and delegate message handling to their adapter instance.
+ *
+ * ## Multi-Agent Routing
+ *
+ * Users can @mention different agents in different messages within the same
+ * thread. Each message routes to exactly one agent. If multiple agents are
+ * mentioned in a single message, the first one is used and a note is included
+ * in the response.
+ *
+ * ## Multi-Word Agent Names
+ *
+ * Agent names can be multi-word (e.g., "Research Agent"). At initialization,
+ * all active agents are loaded from the database. When parsing @mentions,
+ * known agent names are matched longest-first to avoid prefix collisions.
+ *
+ * ## User Identity Mapping
+ *
+ * The adapter resolves the platform user's email to an MJ `UserInfo` record.
+ * This gives proper per-user permission scoping without a separate auth flow.
+ * Falls back to the configured service account email if no MJ user matches.
+ */
+export declare abstract class BaseMessagingAdapter {
+    /** Extension settings from `mj.config.cjs`. */
+    protected settings: MessagingAdapterSettings;
+    /** Fallback context user (service account) loaded from config email. */
+    protected fallbackContextUser: UserInfo | null;
+    /** Default agent loaded from config DefaultAgentName. */
+    protected defaultAgent: MJAIAgentEntityExtended | null;
+    /** All active agents, loaded at init for multi-word name matching. Sorted longest-name-first. */
+    protected availableAgents: MJAIAgentEntityExtended[];
+    /**
+     * Maps platform thread IDs to MJ Conversation IDs.
+     * Ensures all messages in the same Slack/Teams thread share a single MJ Conversation,
+     * preserving context across follow-up messages.
+     *
+     * Entries are evicted after 24 hours to prevent unbounded growth on long-running servers.
+     */
+    private threadConversationMap;
+    /** Max age for thread→conversation mappings (24 hours). */
+    private static readonly THREAD_MAP_TTL_MS;
+    /** Max entries in the thread map before forced eviction of oldest entries. */
+    private static readonly THREAD_MAP_MAX_SIZE;
+    constructor(settings: MessagingAdapterSettings);
+    /**
+     * Initialize the adapter: resolve the fallback context user, load the default
+     * MJ agent (using the fallback user as contextUser), load all available agents,
+     * then run platform init.
+     * Must be called before handling any messages.
+     *
+     * @throws Error if the configured agent or fallback user cannot be found.
+     */
+    Initialize(): Promise<void>;
+    /**
+     * Main entry point: handle an incoming message from the platform.
+     *
+     * Orchestrates the full flow from message receipt to response delivery.
+     * Errors are caught and reported as user-facing error messages — this
+     * method never throws.
+     *
+     * @param message - Normalized incoming message from the platform adapter.
+     */
+    HandleMessage(message: IncomingMessage): Promise<void>;
+    /**
+     * Get the list of available agent names, sorted longest-first.
+     * Useful for subclasses implementing multi-word agent name matching.
+     */
+    get AvailableAgentNames(): string[];
+    /**
+     * Platform-specific initialization (e.g., fetch bot user ID, open WebSocket).
+     * Called at the end of `Initialize()`.
+     */
+    protected abstract onInitialize(): Promise<void>;
+    /**
+     * Show a typing/thinking indicator in the channel.
+     * Some platforms (Teams) have explicit typing APIs; others (Slack) use a
+     * first streaming message as the "thinking" indicator.
+     *
+     * @param message - The incoming message triggering the indicator.
+     * @param agent - The agent that will respond (for per-agent identity).
+     */
+    protected abstract showTypingIndicator(message: IncomingMessage, agent?: MJAIAgentEntityExtended): Promise<void>;
+    /**
+     * Fetch the thread history for the given message from the platform API.
+     *
+     * @param channelId - Channel/conversation ID.
+     * @param threadId - Thread/reply chain ID.
+     * @returns Array of messages in the thread, oldest first.
+     */
+    protected abstract fetchThreadHistory(channelId: string, threadId: string): Promise<IncomingMessage[]>;
+    /**
+     * Send or update a streaming progress message. Returns the message ID.
+     *
+     * If `existingMessageId` is `null`, posts a new message.
+     * If `existingMessageId` is provided, updates the existing message in place.
+     *
+     * @param originalMessage - The message being responded to.
+     * @param currentContent - Accumulated streamed content so far.
+     * @param existingMessageId - ID of an existing progress message to update, or `null`.
+     * @param agent - The agent generating the response (for per-agent identity).
+     * @returns The message ID of the progress message (new or existing).
+     */
+    protected abstract sendOrUpdateStreamingMessage(originalMessage: IncomingMessage, currentContent: string, existingMessageId: string | null, agent?: MJAIAgentEntityExtended): Promise<string>;
+    /**
+     * Send the final formatted response as a new message in the thread.
+     */
+    protected abstract sendFinalMessage(originalMessage: IncomingMessage, response: FormattedResponse): Promise<void>;
+    /**
+     * Update an existing streaming message with the final formatted response.
+     */
+    protected abstract updateFinalMessage(originalMessage: IncomingMessage, messageId: string, response: FormattedResponse): Promise<void>;
+    /**
+     * Convert an agent execution result to the platform's rich format.
+     *
+     * @param result - The full agent execution result.
+     * @param agent - The agent that produced the result.
+     * @param responseText - Extracted human-readable response text.
+     * @param metadata - Optional metadata about the conversation/artifact for deep linking.
+     */
+    protected abstract formatResponse(result: ExecuteAgentResult | null, agent: MJAIAgentEntityExtended, responseText: string, metadata?: AgentResponseMetadata): Promise<FormattedResponse>;
+    /**
+     * Human-readable platform name (e.g., "Slack", "Teams") used in conversation names
+     * and log messages. Subclasses must return their platform identifier.
+     */
+    protected abstract get PlatformName(): string;
+    /**
+     * Get the bot's own user ID on this platform (to identify bot messages in thread history).
+     */
+    protected abstract getBotUserId(): string;
+    /**
+     * Strip the bot @mention from the message text so the agent sees clean input.
+     */
+    protected abstract stripBotMention(text: string): string;
+    /**
+     * Look up the email address for a platform user ID.
+     * Used for mapping platform identity to MJ user.
+     *
+     * @param platformUserId - Platform-specific user ID.
+     * @returns Email address, or `null` if not available.
+     */
+    protected abstract lookupUserEmail(platformUserId: string): Promise<string | null>;
+    /**
+     * Build an `AgentIdentity` from an agent entity.
+     * Only includes `IconURL` if it's a valid HTTPS URL.
+     */
+    protected buildAgentIdentity(agent: MJAIAgentEntityExtended): AgentIdentity;
+    /**
+     * Match agent names mentioned in the message text against known agents.
+     *
+     * Strips the bot's platform mention, then checks for known agent names
+     * preceded by `@` (case-insensitive). Names are checked longest-first
+     * to avoid prefix collisions (e.g., "Research Agent" before "Research").
+     *
+     * @param text - The raw message text.
+     * @returns Array of matched agent names.
+     */
+    protected matchAgentMentions(text: string): string[];
+    /**
+     * Match @mentions against full agent names (exact match, case-insensitive).
+     */
+    private matchExactAgentNames;
+    /**
+     * Match @mentions by first-word prefix — e.g., "@Codesmith" matches agent "Codesmith Agent".
+     *
+     * Extracts all `@word` tokens from the text and checks if any agent name starts with
+     * that word. Only matches if exactly one agent matches to avoid ambiguity.
+     */
+    private matchPrefixAgentNames;
+    /**
+     * Match agent names at the start of the message without an @ prefix.
+     *
+     * Handles the common Slack pattern where the user types `@Bot Marketing Agent help me`
+     * — the `@Bot` becomes `<@U123>` and gets stripped, leaving `Marketing Agent help me`.
+     * We check if the cleaned text starts with a known agent name (case-insensitive,
+     * longest-first to avoid prefix collisions).
+     */
+    private matchBareAgentNames;
+    /**
+     * Match agent names appearing anywhere in the message text.
+     *
+     * This is the lowest-priority matching pass. It handles cases like
+     * "write a blog for me marketing agent" where the agent name is at the
+     * end or middle of the message. Uses word boundary matching and checks
+     * longest names first to avoid false positives.
+     *
+     * Only returns a match if exactly one agent is found, to avoid ambiguity.
+     */
+    private matchAnywhereAgentNames;
+    /**
+     * Determine whether the bot should respond to this message.
+     *
+     * Responds to:
+     * - Direct messages (DMs)
+     * - Explicit @mentions (`app_mention` events)
+     * - Thread replies (any reply in a thread the bot is participating in)
+     *
+     * Thread replies are included because the bot only has threads it started
+     * (via slash commands or @mention responses), so a reply in such a thread
+     * is implicitly directed at the bot.
+     *
+     * Subclasses can override for platform-specific logic.
+     */
+    protected shouldRespond(message: IncomingMessage): boolean;
+    /**
+     * Resolve the MJ user for the platform sender.
+     *
+     * Flow:
+     * 1. If IncomingMessage has SenderEmail, look up in UserCache
+     * 2. If not, call `lookupUserEmail()` (platform API) then look up
+     * 3. Fall back to the configured service account
+     */
+    protected resolveContextUser(message: IncomingMessage): Promise<UserInfo>;
+    /**
+     * Resolve which agent to use for this message.
+     *
+     * Priority:
+     * 1. Explicit @mention in the current message
+     * 2. Thread affinity — if this is a reply in a thread, use the same agent
+     *    that was originally @mentioned in the thread's first message
+     * 3. Fall back to the default agent from config
+     *
+     * If the mentioned agent is not found, responds with available agents.
+     */
+    protected resolveAgent(message: IncomingMessage, contextUser: UserInfo, threadHistory?: IncomingMessage[]): Promise<{
+        agent: MJAIAgentEntityExtended;
+        multiAgentNote: string | null;
+    }>;
+    /**
+     * Look through the thread history to find the agent that was originally invoked.
+     *
+     * Checks the first user message in the thread for @agent mentions. This provides
+     * thread affinity — follow-up messages in a thread continue with the same agent
+     * without requiring the user to @mention it again, matching MJ Explorer behavior.
+     *
+     * @returns The agent from the thread's first message, or `null` if none found.
+     */
+    private resolveThreadAgent;
+    /** Maximum number of delegation hops to prevent infinite loops. */
+    private static readonly MAX_DELEGATION_HOPS;
+    /**
+     * Execute the agent and send the response, with streaming support.
+     * Handles delegation automatically: when the agent returns `payload.invokeAgent`,
+     * the target agent is auto-executed (matching MJ Explorer behavior).
+     */
+    /**
+     * Get the thread key for conversation mapping.
+     * Uses ThreadID if in a thread, otherwise MessageID (for thread-root messages).
+     */
+    private getThreadKey;
+    private executeAgentAndRespond;
+    /**
+     * Run an agent within a conversation context, with streaming progress updates.
+     *
+     * Uses `AgentRunner.RunAgentInConversation()` so that:
+     * - An MJ Conversation is created (or reused) for the interaction
+     * - Artifacts are automatically created from the agent's payload
+     * - The artifact ID is returned for deep-linking into MJ Explorer
+     *
+     * @returns The agent result plus conversation/artifact metadata.
+     */
+    private runAgentWithStreaming;
+    /**
+     * Detect if an agent result contains a delegation request.
+     *
+     * Three detection strategies, tried in order:
+     * 1. `payload.invokeAgent` — formal delegation field (same as MJ Explorer)
+     * 2. `agentRun.FinalPayload` — serialized payload fallback (in case in-memory payload is empty)
+     * 3. Message text pattern matching — detects "I'll have the {Agent Name}..." phrasing
+     *    when the agent describes delegation intent without formally setting the payload
+     *
+     * @returns The target agent name, or null if no delegation.
+     */
+    private detectDelegation;
+    /**
+     * Extract `invokeAgent` from the in-memory payload object.
+     */
+    private extractInvokeAgentFromPayload;
+    /**
+     * Extract `invokeAgent` from the serialized FinalPayload string on the agentRun.
+     * Fallback for cases where the in-memory payload is empty but FinalPayload was persisted.
+     */
+    private extractInvokeAgentFromFinalPayload;
+    /**
+     * Detect delegation intent from the agent's message text.
+     *
+     * Matches patterns like:
+     * - "I'll have the Marketing Agent write..."
+     * - "I'll delegate to the Research Agent..."
+     * - "Routing to Marketing Agent"
+     * - "Let me have the Codesmith Agent handle this"
+     *
+     * Only matches against known agent names from `availableAgents` to avoid false positives.
+     */
+    private extractDelegationFromMessage;
+    /**
+     * Handle agent delegation: send a delegation note, then auto-execute the target agent.
+     *
+     * Mirrors MJ Explorer's `handleSubAgentInvocation()`:
+     * 1. Show the delegating agent's message (e.g., "Delegating to Marketing Agent")
+     * 2. Find the target agent in availableAgents
+     * 3. Execute the target agent with the same conversation context
+     * 4. Send the target agent's result
+     *
+     * Supports chained delegation up to MAX_DELEGATION_HOPS.
+     */
+    private handleDelegation;
+    /**
+     * Extract response text, format it, and send the final message.
+     */
+    private sendAgentResult;
+    /**
+     * Extract the user-facing response text from an `ExecuteAgentResult`.
+     *
+     * Mirrors MJ Explorer's approach: the data model itself tells us what's user-facing.
+     * `agentRun.Message` is the field agents explicitly set for the user. Everything
+     * else (payload, FinalPayload, step outputs) is internal agent state.
+     *
+     * We do NOT mine payloads for content — that approach requires hardcoding
+     * agent-specific payload shapes and inevitably leaks internal LLM state
+     * (research plans, orchestration metadata, etc.) to the user.
+     *
+     * When `Message` is a JSON blob (some agents dump structured payloads there),
+     * we don't try to extract content from it. If an artifact exists, the
+     * "View in MJ Explorer" link handles rendering. If not, we fall through
+     * to a generic message rather than showing raw JSON.
+     *
+     * Fallback chain (only when Message is absent or is raw JSON):
+     * 1. `agentRun.Message` — the primary human-readable field (skipped if JSON)
+     * 2. `agentRun.Result` — simple string result (skipped if JSON)
+     * 3. Generic fallback message
+     */
+    private extractResponseText;
+    /**
+     * Quick check: does this string look like a JSON object or array?
+     * Used to avoid showing raw JSON to users when agents dump structured
+     * payloads into the Message field instead of human-readable text.
+     */
+    private looksLikeJSON;
+    /**
+     * Extract error text from a failed agent result.
+     */
+    private extractErrorText;
+    /**
+     * Fetch thread history with error handling. Returns empty array on failure.
+     */
+    private safeGetThreadHistory;
+    /**
+     * Show typing indicator with error handling. Failures are silently ignored.
+     * Now passes the resolved agent for per-agent identity on the indicator.
+     */
+    private safeShowTypingIndicator;
+    /**
+     * Convert thread history + current message into `ChatMessage[]` for `AgentRunner`.
+     *
+     * Maps platform messages to roles:
+     * - Messages from the bot → `assistant`
+     * - Messages from anyone else → `user`
+     *
+     * Bot @mentions are stripped from user messages.
+     */
+    private buildConversationMessages;
+    /**
+     * Load the default MJ agent entity from database by name.
+     * Matches the pattern used by the conversation UI (ConversationAgentService).
+     * @throws Error if the configured agent name cannot be found.
+     */
+    private loadDefaultAgent;
+    /**
+     * Load all active agents for multi-word name matching.
+     * Sorted longest-name-first to avoid prefix collisions.
+     */
+    private loadAvailableAgents;
+    /**
+     * Resolve the fallback context user from the configured email.
+     * @throws Error if the configured email cannot be found.
+     */
+    private loadFallbackContextUser;
+    /**
+     * Get a conversation ID from the thread map, respecting TTL.
+     */
+    private getThreadConversationId;
+    /**
+     * Store a conversation ID in the thread map with TTL and max-size eviction.
+     */
+    private setThreadConversationId;
+    /**
+     * Evict expired and overflow entries from the thread conversation map.
+     */
+    private evictExpiredThreadEntries;
+    /**
+     * Escape special regex characters in a string.
+     */
+    private escapeRegex;
+}
+//# sourceMappingURL=BaseMessagingAdapter.d.ts.map

package/dist/base/BaseMessagingAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseMessagingAdapter.d.ts","sourceRoot":"","sources":["../../src/base/BaseMessagingAdapter.ts"],"names":[],"mappings":"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"}