@inkeep/agents-work-apps 0.47.5 → 0.48.0

package/dist/slack/services/events/utils.d.ts

@@ -0,0 +1,146 @@
+import { DefaultAgentConfig, SlackWorkspaceConnection } from "../nango.js";
+import { AgentOption } from "../modals.js";
+
+//#region src/slack/services/events/utils.d.ts
+
+/**
+ * Find a user mapping with bounded in-memory caching (5 min TTL, max 5000 entries).
+ * Called on every @mention and /inkeep command — caching avoids redundant DB queries.
+ */
+declare function findCachedUserMapping(tenantId: string, slackUserId: string, teamId: string, clientId?: string): Promise<{
+  createdAt: string;
+  updatedAt: string;
+  id: string;
+  tenantId: string;
+  clientId: string;
+  slackUserId: string;
+  slackTeamId: string;
+  slackEnterpriseId: string | null;
+  inkeepUserId: string;
+  slackUsername: string | null;
+  slackEmail: string | null;
+  linkedAt: string;
+  lastUsedAt: string | null;
+} | null>;
+/**
+ * Convert standard Markdown to Slack's mrkdwn format
+ *
+ * Key differences:
+ * - **bold** or __bold__ → *bold*
+ * - *italic* (when not bold) → _italic_
+ * - # Header → *Header* (Slack has no headers)
+ * - [text](url) → <url|text>
+ * - Keeps code blocks, inline code, and lists as-is
+ */
+declare function markdownToMrkdwn(markdown: string): string;
+/**
+ * Error types for user-friendly error messages
+ */
+declare enum SlackErrorType {
+  TIMEOUT = "timeout",
+  RATE_LIMIT = "rate_limit",
+  API_ERROR = "api_error",
+  AUTH_ERROR = "auth_error",
+  UNKNOWN = "unknown",
+}
+/**
+ * Classify an error into a SlackErrorType for appropriate user messaging
+ */
+declare function classifyError(error: unknown, httpStatus?: number): SlackErrorType;
+/**
+ * Get a user-friendly error message based on error type
+ */
+declare function getUserFriendlyErrorMessage(errorType: SlackErrorType, agentName?: string): string;
+type ProjectOption = {
+  id: string;
+  name: string;
+};
+declare function fetchProjectsForTenant(tenantId: string): Promise<ProjectOption[]>;
+declare function fetchAgentsForProject(tenantId: string, projectId: string): Promise<AgentOption[]>;
+declare function getWorkspaceDefaultAgent(teamId: string): Promise<DefaultAgentConfig | null>;
+declare function getChannelAgentConfig(teamId: string, channelId: string): Promise<DefaultAgentConfig | null>;
+/**
+ * Resolve channel agent config using a pre-resolved workspace connection.
+ * Avoids redundant workspace lookups when the connection is already available.
+ */
+declare function resolveChannelAgentConfig(teamId: string, channelId: string, workspace: SlackWorkspaceConnection | null): Promise<DefaultAgentConfig | null>;
+declare function sendResponseUrlMessage(responseUrl: string, message: {
+  text: string;
+  response_type?: 'ephemeral' | 'in_channel';
+  replace_original?: boolean;
+  delete_original?: boolean;
+  blocks?: unknown[];
+}): Promise<void>;
+/**
+ * Generate a deterministic conversation ID for Slack threads/DMs.
+ * This ensures the same thread + agent combination gets the same conversation ID,
+ * allowing the agent to maintain conversation history.
+ *
+ * Including agentId ensures switching agents in the same thread starts a fresh
+ * conversation, avoiding sub-agent conflicts when the Run API tries to resume
+ * a conversation that was started by a different agent.
+ *
+ * Format: slack-thread-{teamId}-{identifier}[-{agentId}]
+ */
+declare function generateSlackConversationId(params: {
+  teamId: string;
+  threadTs?: string;
+  channel: string;
+  isDM?: boolean;
+  agentId?: string;
+}): string;
+/**
+ * Check if a thread was initiated by the bot (i.e., the parent message is from the bot).
+ * This helps distinguish "bot threads" (where users are conversing with the bot)
+ * from "user threads" (where users are having their own conversation).
+ *
+ * Uses conversations.replies which returns thread messages with the parent as the first message.
+ */
+declare function checkIfBotThread(slackClient: {
+  conversations: {
+    replies: (params: {
+      channel: string;
+      ts: string;
+      limit?: number;
+    }) => Promise<{
+      messages?: Array<{
+        bot_id?: string;
+        user?: string;
+        text?: string;
+      }>;
+    }>;
+  };
+}, channel: string, threadTs: string): Promise<boolean>;
+interface ThreadContextOptions {
+  includeLastMessage?: boolean;
+  resolveUserNames?: boolean;
+}
+declare function getThreadContext(slackClient: {
+  conversations: {
+    replies: (params: {
+      channel: string;
+      ts: string;
+      limit?: number;
+    }) => Promise<{
+      messages?: Array<{
+        bot_id?: string;
+        user?: string;
+        text?: string;
+        ts?: string;
+      }>;
+    }>;
+  };
+  users?: {
+    info: (params: {
+      user: string;
+    }) => Promise<{
+      user?: {
+        real_name?: string;
+        display_name?: string;
+        name?: string;
+      };
+    }>;
+  };
+}, channel: string, threadTs: string, options?: ThreadContextOptions): Promise<string>;
+//#endregion
+export { ProjectOption, SlackErrorType, checkIfBotThread, classifyError, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage };

package/dist/slack/services/events/utils.js

@@ -0,0 +1,370 @@
+import { env } from "../../../env.js";
+import { getLogger } from "../../../logger.js";
+import runDbClient_default from "../../../db/runDbClient.js";
+import { findWorkspaceConnectionByTeamId } from "../nango.js";
+import { InternalServices, findWorkAppSlackChannelAgentConfig, findWorkAppSlackUserMapping, generateInternalServiceToken } from "@inkeep/agents-core";
+
+//#region src/slack/services/events/utils.ts
+/**
+* Shared utilities for Slack event handlers
+*/
+const logger = getLogger("slack-event-utils");
+const USER_MAPPING_CACHE_TTL_MS = 300 * 1e3;
+const USER_MAPPING_CACHE_MAX_SIZE = 5e3;
+const userMappingCache = /* @__PURE__ */ new Map();
+function evictExpiredEntries() {
+	if (userMappingCache.size <= USER_MAPPING_CACHE_MAX_SIZE) return;
+	const now = Date.now();
+	for (const [key, entry] of userMappingCache) if (entry.expiresAt <= now) userMappingCache.delete(key);
+	if (userMappingCache.size > USER_MAPPING_CACHE_MAX_SIZE) {
+		const excess = userMappingCache.size - USER_MAPPING_CACHE_MAX_SIZE;
+		const keys = userMappingCache.keys();
+		for (let i = 0; i < excess; i++) {
+			const { value } = keys.next();
+			if (value) userMappingCache.delete(value);
+		}
+	}
+}
+/**
+* Find a user mapping with bounded in-memory caching (5 min TTL, max 5000 entries).
+* Called on every @mention and /inkeep command — caching avoids redundant DB queries.
+*/
+async function findCachedUserMapping(tenantId, slackUserId, teamId, clientId = "work-apps-slack") {
+	const cacheKey = `${tenantId}:${slackUserId}:${teamId}:${clientId}`;
+	const cached = userMappingCache.get(cacheKey);
+	if (cached && cached.expiresAt > Date.now()) return cached.mapping;
+	const mapping = await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, slackUserId, teamId, clientId);
+	if (userMappingCache.size >= USER_MAPPING_CACHE_MAX_SIZE) {
+		evictExpiredEntries();
+		if (userMappingCache.size >= USER_MAPPING_CACHE_MAX_SIZE) {
+			const oldestKey = userMappingCache.keys().next().value;
+			if (oldestKey) userMappingCache.delete(oldestKey);
+		}
+	}
+	userMappingCache.set(cacheKey, {
+		mapping,
+		expiresAt: Date.now() + USER_MAPPING_CACHE_TTL_MS
+	});
+	return mapping;
+}
+/**
+* Convert standard Markdown to Slack's mrkdwn format
+*
+* Key differences:
+* - **bold** or __bold__ → *bold*
+* - *italic* (when not bold) → _italic_
+* - # Header → *Header* (Slack has no headers)
+* - [text](url) → <url|text>
+* - Keeps code blocks, inline code, and lists as-is
+*/
+function markdownToMrkdwn(markdown) {
+	if (!markdown) return markdown;
+	let result = markdown;
+	result = result.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
+	result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "<$2|$1>");
+	result = result.replace(/\*\*([^*]+)\*\*/g, "*$1*");
+	result = result.replace(/__([^_]+)__/g, "*$1*");
+	result = result.replace(/~~([^~]+)~~/g, "~$1~");
+	return result;
+}
+/**
+* Error types for user-friendly error messages
+*/
+let SlackErrorType = /* @__PURE__ */ function(SlackErrorType$1) {
+	SlackErrorType$1["TIMEOUT"] = "timeout";
+	SlackErrorType$1["RATE_LIMIT"] = "rate_limit";
+	SlackErrorType$1["API_ERROR"] = "api_error";
+	SlackErrorType$1["AUTH_ERROR"] = "auth_error";
+	SlackErrorType$1["UNKNOWN"] = "unknown";
+	return SlackErrorType$1;
+}({});
+/**
+* Classify an error into a SlackErrorType for appropriate user messaging
+*/
+function classifyError(error, httpStatus) {
+	if (httpStatus === 429) return SlackErrorType.RATE_LIMIT;
+	if (httpStatus === 401 || httpStatus === 403) return SlackErrorType.AUTH_ERROR;
+	if (httpStatus && httpStatus >= 400) return SlackErrorType.API_ERROR;
+	const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+	if (errorMessage.includes("timeout") || errorMessage.includes("timed out") || errorMessage.includes("aborted") || errorMessage.includes("econnreset")) return SlackErrorType.TIMEOUT;
+	if (errorMessage.includes("rate limit") || errorMessage.includes("too many requests")) return SlackErrorType.RATE_LIMIT;
+	if (errorMessage.includes("unauthorized") || errorMessage.includes("forbidden")) return SlackErrorType.AUTH_ERROR;
+	return SlackErrorType.UNKNOWN;
+}
+/**
+* Get a user-friendly error message based on error type
+*/
+function getUserFriendlyErrorMessage(errorType, agentName) {
+	const agent = agentName || "The agent";
+	switch (errorType) {
+		case SlackErrorType.TIMEOUT: return `⏱️ *Request timed out*\n\n${agent} took too long to respond. This can happen with complex queries.\n\n*Try:*\n• Simplifying your question\n• Breaking it into smaller parts\n• Trying again in a moment`;
+		case SlackErrorType.RATE_LIMIT: return `⚠️ *Too many requests*\n\nYou've hit the rate limit. Please wait a moment before trying again.\n\n*Tip:* Space out your requests to avoid this.`;
+		case SlackErrorType.AUTH_ERROR: return `🔐 *Authentication issue*\n\nThere was a problem with your account connection.\n\n*Try:*\n• Running \`/inkeep link\` to re-link your account\n• Contacting your workspace admin if the issue persists`;
+		case SlackErrorType.API_ERROR: return `❌ *Something went wrong*\n\n${agent} encountered an error processing your request.\n\n*Try:*\n• Rephrasing your question\n• Trying again in a moment\n• Using \`/inkeep help\` for more options`;
+		default: return `❌ *Unexpected error*\n\nSomething went wrong while processing your request.\n\n*Try:*\n• Trying again in a moment\n• Using \`/inkeep help\` for more options`;
+	}
+}
+const INTERNAL_FETCH_TIMEOUT_MS = 1e4;
+async function fetchProjectsForTenant(tenantId) {
+	const apiUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+	const token = await generateInternalServiceToken({
+		serviceId: InternalServices.INKEEP_AGENTS_MANAGE_API,
+		tenantId
+	});
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), INTERNAL_FETCH_TIMEOUT_MS);
+	try {
+		const response = await fetch(`${apiUrl}/manage/tenants/${tenantId}/projects?limit=50`, {
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			},
+			signal: controller.signal
+		});
+		if (!response.ok) {
+			const errorBody = await response.text().catch(() => "");
+			logger.warn({
+				status: response.status,
+				tenantId,
+				errorBody
+			}, "Failed to fetch projects from API");
+			return [];
+		}
+		const result = await response.json();
+		logger.debug({
+			tenantId,
+			projectCount: result.data.length
+		}, "Fetched projects from API");
+		return result.data.map((p) => ({
+			id: p.id,
+			name: p.name || p.id
+		}));
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId
+		}, "Error fetching projects from API");
+		return [];
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function fetchAgentsForProject(tenantId, projectId) {
+	const apiUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+	const token = await generateInternalServiceToken({
+		serviceId: InternalServices.INKEEP_AGENTS_MANAGE_API,
+		tenantId,
+		projectId
+	});
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), INTERNAL_FETCH_TIMEOUT_MS);
+	try {
+		const response = await fetch(`${apiUrl}/manage/tenants/${tenantId}/projects/${projectId}/agents?limit=50`, {
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json",
+				"x-inkeep-project-id": projectId
+			},
+			signal: controller.signal
+		});
+		if (!response.ok) {
+			const errorBody = await response.text().catch(() => "");
+			logger.warn({
+				status: response.status,
+				tenantId,
+				projectId,
+				errorBody
+			}, "Failed to fetch agents from API");
+			return [];
+		}
+		const result = await response.json();
+		logger.debug({
+			tenantId,
+			projectId,
+			agentCount: result.data.length
+		}, "Fetched agents from API");
+		return result.data.map((a) => ({
+			id: a.id,
+			name: a.name || a.id,
+			projectId,
+			projectName: projectId
+		}));
+	} catch (error) {
+		logger.error({
+			error,
+			tenantId,
+			projectId
+		}, "Error fetching agents from API");
+		return [];
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function getWorkspaceDefaultAgent(teamId) {
+	const workspace = await findWorkspaceConnectionByTeamId(teamId);
+	if (workspace?.defaultAgent) {
+		logger.debug({ teamId }, "Found workspace default agent");
+		return workspace.defaultAgent;
+	}
+	return null;
+}
+async function getChannelAgentConfig(teamId, channelId) {
+	return resolveChannelAgentConfig(teamId, channelId, await findWorkspaceConnectionByTeamId(teamId));
+}
+/**
+* Resolve channel agent config using a pre-resolved workspace connection.
+* Avoids redundant workspace lookups when the connection is already available.
+*/
+async function resolveChannelAgentConfig(teamId, channelId, workspace) {
+	const tenantId = workspace?.tenantId;
+	if (!tenantId) return null;
+	const channelConfig = await findWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
+	if (channelConfig?.enabled) return {
+		projectId: channelConfig.projectId,
+		agentId: channelConfig.agentId,
+		agentName: channelConfig.agentName || channelConfig.agentId,
+		projectName: channelConfig.projectId
+	};
+	return workspace?.defaultAgent || null;
+}
+async function sendResponseUrlMessage(responseUrl, message) {
+	try {
+		const payload = { text: message.text };
+		if (message.replace_original) payload.replace_original = true;
+		else if (message.delete_original) payload.delete_original = true;
+		else if (message.response_type) payload.response_type = message.response_type;
+		if (message.blocks) payload.blocks = message.blocks;
+		logger.info({
+			hasBlocks: !!message.blocks,
+			blockCount: Array.isArray(message.blocks) ? message.blocks.length : 0,
+			replace: !!message.replace_original
+		}, "Sending response_url message");
+		const controller = new AbortController();
+		const responseTimeout = setTimeout(() => controller.abort(), INTERNAL_FETCH_TIMEOUT_MS);
+		const response = await fetch(responseUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: controller.signal
+		});
+		clearTimeout(responseTimeout);
+		const responseBody = await response.text().catch(() => "");
+		logger.info({
+			status: response.status,
+			responseBody: responseBody.slice(0, 300)
+		}, "response_url response received");
+		if (!response.ok) logger.error({
+			status: response.status,
+			errorBody: responseBody
+		}, "response_url request failed");
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error({ errorMessage }, "Failed to send response_url message");
+	}
+}
+/**
+* Generate a deterministic conversation ID for Slack threads/DMs.
+* This ensures the same thread + agent combination gets the same conversation ID,
+* allowing the agent to maintain conversation history.
+*
+* Including agentId ensures switching agents in the same thread starts a fresh
+* conversation, avoiding sub-agent conflicts when the Run API tries to resume
+* a conversation that was started by a different agent.
+*
+* Format: slack-thread-{teamId}-{identifier}[-{agentId}]
+*/
+function generateSlackConversationId(params) {
+	const { teamId, threadTs, channel, isDM, agentId } = params;
+	const base = isDM ? `slack-dm-${teamId}-${channel}` : `slack-thread-${teamId}-${threadTs || channel}`;
+	return agentId ? `${base}-${agentId}` : base;
+}
+/**
+* Check if a thread was initiated by the bot (i.e., the parent message is from the bot).
+* This helps distinguish "bot threads" (where users are conversing with the bot)
+* from "user threads" (where users are having their own conversation).
+*
+* Uses conversations.replies which returns thread messages with the parent as the first message.
+*/
+async function checkIfBotThread(slackClient, channel, threadTs) {
+	try {
+		const parentMessage = (await slackClient.conversations.replies({
+			channel,
+			ts: threadTs,
+			limit: 1
+		})).messages?.[0];
+		if (!parentMessage) {
+			logger.debug({
+				channel,
+				threadTs
+			}, "No parent message found for thread");
+			return false;
+		}
+		const isBotThread = Boolean(parentMessage.bot_id);
+		logger.debug({
+			channel,
+			threadTs,
+			isBotThread,
+			botId: parentMessage.bot_id
+		}, "Checked if thread is bot-owned");
+		return isBotThread;
+	} catch (error) {
+		logger.warn({
+			error,
+			channel,
+			threadTs
+		}, "Failed to check if thread is bot-owned");
+		return false;
+	}
+}
+async function getThreadContext(slackClient, channel, threadTs, options = {}) {
+	const { includeLastMessage = false, resolveUserNames = true } = options;
+	try {
+		const threadMessages = await slackClient.conversations.replies({
+			channel,
+			ts: threadTs,
+			limit: 50
+		});
+		if (!threadMessages.messages || threadMessages.messages.length === 0) return "";
+		const messagesToProcess = includeLastMessage ? threadMessages.messages : threadMessages.messages.slice(0, -1);
+		if (messagesToProcess.length === 0) return "";
+		const userNameCache = /* @__PURE__ */ new Map();
+		if (resolveUserNames && slackClient.users) {
+			const uniqueUserIds = [...new Set(messagesToProcess.filter((m) => !!m.user).map((m) => m.user))];
+			await Promise.all(uniqueUserIds.map(async (userId) => {
+				try {
+					const userInfo = await slackClient.users?.info({ user: userId });
+					const name = userInfo?.user?.display_name || userInfo?.user?.real_name || userInfo?.user?.name || userId;
+					userNameCache.set(userId, name);
+				} catch {
+					userNameCache.set(userId, userId);
+				}
+			}));
+		}
+		return messagesToProcess.map((msg, index) => {
+			const isBot = !!msg.bot_id;
+			const isParent = index === 0;
+			let role;
+			if (isBot) role = "Inkeep Agent";
+			else if (msg.user) role = resolveUserNames ? userNameCache.get(msg.user) || msg.user : `<@${msg.user}>`;
+			else role = "Unknown";
+			const prefix = isParent ? "[Thread Start] " : "";
+			const messageText = msg.text?.replace(/<@U[A-Z0-9]+>/g, (match) => {
+				const userId = match.slice(2, -1);
+				return `@${userNameCache.get(userId) || userId}`;
+			}) || "";
+			return `${prefix}${role}: ${messageText}`;
+		}).join("\n\n");
+	} catch (threadError) {
+		logger.warn({
+			threadError,
+			channel,
+			threadTs
+		}, "Failed to fetch thread context");
+	}
+	return "";
+}
+
+//#endregion
+export { SlackErrorType, checkIfBotThread, classifyError, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage };

package/dist/slack/services/index.d.ts

@@ -0,0 +1,16 @@
+import { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
+import { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, buildConversationResponseBlocks, buildFollowUpButton, createAgentListMessage, createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
+import { checkUserIsChannelMember, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken } from "./client.js";
+import { DefaultAgentConfig, SlackWorkspaceConnection, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.js";
+import { SlackCommandPayload, SlackCommandResponse } from "./types.js";
+import { handleAgentListCommand, handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleRunCommand, handleStatusCommand, handleUnlinkCommand } from "./commands/index.js";
+import { InlineSelectorMetadata, handleAppMention } from "./events/app-mention.js";
+import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal } from "./events/block-actions.js";
+import { handleFollowUpSubmission, handleModalSubmission } from "./events/modal-submission.js";
+import { AgentOption, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, FollowUpModalMetadata, ModalMetadata, buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "./modals.js";
+import { SlackErrorType, checkIfBotThread, classifyError, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
+import { StreamResult, streamAgentResponse } from "./events/streaming.js";
+import "./events/index.js";
+import { parseSlackCommandBody, parseSlackEventBody, verifySlackRequest } from "./security.js";
+import { getBotTokenForTeam, setBotTokenForTeam } from "./workspace-tokens.js";
+export { AgentConfigSources, AgentOption, AgentResolutionParams, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, ContextBlockParams, DefaultAgentConfig, FollowUpButtonParams, FollowUpModalMetadata, InlineSelectorMetadata, ModalMetadata, ResolvedAgentConfig, SlackCommandPayload, SlackCommandResponse, SlackErrorType, SlackWorkspaceConnection, StreamResult, WorkspaceInstallData, buildAgentSelectorModal, buildConversationResponseBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAgentListMessage, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentListCommand, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleRunCommand, handleStatusCommand, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };

package/dist/slack/services/index.js

@@ -0,0 +1,16 @@
+import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.js";
+import { getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
+import { buildConversationResponseBlocks, buildFollowUpButton, createAgentListMessage, createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
+import { checkUserIsChannelMember, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken } from "./client.js";
+import { SlackErrorType, checkIfBotThread, classifyError, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
+import { buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "./modals.js";
+import { handleAgentListCommand, handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleRunCommand, handleStatusCommand, handleUnlinkCommand } from "./commands/index.js";
+import { getBotTokenForTeam, setBotTokenForTeam } from "./workspace-tokens.js";
+import { streamAgentResponse } from "./events/streaming.js";
+import { handleAppMention } from "./events/app-mention.js";
+import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal } from "./events/block-actions.js";
+import { handleFollowUpSubmission, handleModalSubmission } from "./events/modal-submission.js";
+import "./events/index.js";
+import { parseSlackCommandBody, parseSlackEventBody, verifySlackRequest } from "./security.js";
+
+export { SlackErrorType, buildAgentSelectorModal, buildConversationResponseBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAgentListMessage, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentListCommand, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleRunCommand, handleStatusCommand, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };

package/dist/slack/services/modals.d.ts

@@ -0,0 +1,86 @@
+import { ModalView } from "@slack/web-api";
+
+//#region src/slack/services/modals.d.ts
+
+/** Agent option for dropdown selection */
+interface AgentOption {
+  id: string;
+  name: string | null;
+  projectId: string;
+  projectName: string | null;
+}
+interface ModalMetadata {
+  channel: string;
+  threadTs?: string;
+  messageTs: string;
+  teamId: string;
+  slackUserId: string;
+  tenantId: string;
+  isInThread: boolean;
+  threadMessageCount?: number;
+  buttonResponseUrl?: string;
+  messageContext?: string;
+}
+interface FollowUpModalMetadata {
+  conversationId: string;
+  agentId: string;
+  projectId: string;
+  tenantId: string;
+  teamId: string;
+  slackUserId: string;
+  channel: string;
+}
+interface BuildAgentSelectorModalParams {
+  projects: Array<{
+    id: string;
+    name: string;
+  }>;
+  agents: AgentOption[];
+  metadata: ModalMetadata;
+  selectedProjectId?: string;
+}
+/**
+ * Build the agent selector modal.
+ *
+ * Shows:
+ * - Project dropdown
+ * - Agent dropdown (updates based on project selection)
+ * - Include thread context checkbox (if in thread)
+ * - Question/instructions input
+ * - Dashboard link
+ *
+ * All responses from this modal are private (ephemeral).
+ */
+declare function buildAgentSelectorModal(params: BuildAgentSelectorModalParams): ModalView;
+/**
+ * Build a follow-up modal for continuing a conversation.
+ *
+ * Shows only a prompt input. Agent and project are carried from the previous turn
+ * via metadata. The conversationId ensures the agent has full history.
+ */
+declare function buildFollowUpModal(metadata: FollowUpModalMetadata): ModalView;
+interface BuildMessageShortcutModalParams {
+  projects: Array<{
+    id: string;
+    name: string;
+  }>;
+  agents: AgentOption[];
+  metadata: ModalMetadata;
+  selectedProjectId?: string;
+  messageContext: string;
+}
+/**
+ * Build the modal for message shortcut (context menu on a message).
+ *
+ * Shows:
+ * - Message context (read-only display)
+ * - Project dropdown
+ * - Agent dropdown
+ * - Additional instructions input
+ * - Dashboard link
+ *
+ * All responses from this modal are private (ephemeral).
+ */
+declare function buildMessageShortcutModal(params: BuildMessageShortcutModalParams): ModalView;
+//#endregion
+export { AgentOption, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, FollowUpModalMetadata, ModalMetadata, buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal };