@inkeep/agents-work-apps 0.53.0 → 0.53.1

package/dist/slack/services/events/app-mention.js

@@ -1,36 +1,23 @@
 import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
 import { findWorkspaceConnectionByTeamId } from "../nango.js";
-import { checkIfBotThread, classifyError, findCachedUserMapping, formatChannelContext, generateSlackConversationId, getThreadContext, getUserFriendlyErrorMessage, timedOp } from "./utils.js";
+import { checkIfBotThread, classifyError, findCachedUserMapping, formatAttachments, formatChannelContext, generateSlackConversationId, getThreadContext, getUserFriendlyErrorMessage, timedOp } from "./utils.js";
 import { resolveEffectiveAgent } from "../agent-resolution.js";
 import { SlackStrings } from "../../i18n/strings.js";
 import { getSlackChannelInfo, getSlackClient, getSlackUserInfo, postMessageInThread } from "../client.js";
+import { buildLinkPromptMessage, resolveUnlinkedUserAction } from "../link-prompt.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
 import { streamAgentResponse } from "./streaming.js";
 import { signSlackUserToken } from "@inkeep/agents-core";
 
 //#region src/slack/services/events/app-mention.ts
-/**
-* Handler for Slack @mention events
-*
-* Flow:
-* 1. Resolve workspace connection (single lookup, cached)
-* 2. Parallel: resolve agent config + check user link
-* 3. If no agent configured → prompt to set up in dashboard
-* 4. If not linked → prompt to link account
-* 5. Handle based on context:
-*    - Channel + no query → Show usage hint
-*    - Channel + query → Execute agent with streaming response
-*    - Thread + no query → Auto-execute agent with thread context as query
-*    - Thread + query → Execute agent with thread context included
-*/
 const logger = getLogger("slack-app-mention");
 /**
 * Main handler for @mention events in Slack
 */
 async function handleAppMention(params) {
 	return tracer.startActiveSpan(SLACK_SPAN_NAMES.APP_MENTION, async (span) => {
-		const { slackUserId, channel, text, threadTs, messageTs, teamId, dispatchedAt } = params;
+		const { slackUserId, channel, text, attachments, threadTs, messageTs, teamId, dispatchedAt } = params;
 		const handlerStartedAt = Date.now();
 		const manageUiUrl = env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000";
 		const dispatchDelayMs = dispatchedAt ? handlerStartedAt - dispatchedAt : void 0;
@@ -123,11 +110,36 @@ async function handleAppMention(params) {
 					teamId,
 					channel
 				}, "User not linked — prompting account link");
+				const intent = {
+					entryPoint: "mention",
+					question: text.slice(0, 2e3),
+					channelId: channel,
+					threadTs: isInThread ? threadTs : void 0,
+					messageTs,
+					agentId: agentConfig.agentId,
+					projectId: agentConfig.projectId
+				};
+				const linkResult = await resolveUnlinkedUserAction({
+					tenantId,
+					teamId,
+					slackUserId,
+					botToken,
+					intent
+				});
+				const message = buildLinkPromptMessage(linkResult);
+				logger.info({
+					event: "smart_link_intent_captured",
+					entryPoint: "mention",
+					linkType: linkResult.type,
+					questionLength: intent.question.length,
+					channelId: channel
+				}, "Smart link intent captured");
 				await slackClient.chat.postEphemeral({
 					channel,
 					user: slackUserId,
 					thread_ts: isInThread ? threadTs : void 0,
-					text: "*Link your account to use @Inkeep*\n\nRun `/inkeep link` to connect your Slack and Inkeep accounts."
+					text: "To get started, let's connect your Inkeep account with Slack.",
+					blocks: message.blocks
 				});
 				span.end();
 				return;
@@ -241,6 +253,7 @@ Respond naturally as if you're joining the conversation to help.`;
 				return;
 			}
 			let queryText = text;
+			const attachmentContext = formatAttachments(attachments);
 			if (isInThread && threadTs) {
 				const { result: [contextMessages, channelInfo] } = await timedOp(Promise.all([getThreadContext(slackClient, channel, threadTs), getSlackChannelInfo(slackClient, channel)]), {
 					label: "thread context fetch",
@@ -250,7 +263,12 @@ Respond naturally as if you're joining the conversation to help.`;
 						threadTs
 					}
 				});
-				if (contextMessages) queryText = `The following is thread context from ${formatChannelContext(channelInfo)}:\n\n<slack_thread_context>\n${contextMessages}\n</slack_thread_context>\n\nMessage from ${slackUserId}: ${text}`;
+				if (contextMessages) {
+					const channelContext = formatChannelContext(channelInfo);
+					let messageContent = text;
+					if (attachmentContext) messageContent = `${text}\n\n<attached_content>\n${attachmentContext}\n</attached_content>`;
+					queryText = `The following is thread context from ${channelContext}:\n\n<slack_thread_context>\n${contextMessages}\n</slack_thread_context>\n\nMessage from ${slackUserId}: ${messageContent}`;
+				}
 			} else {
 				const { result: [channelInfo, userInfo] } = await timedOp(Promise.all([getSlackChannelInfo(slackClient, channel), getSlackUserInfo(slackClient, slackUserId)]), {
 					label: "channel/user info fetch",
@@ -259,7 +277,10 @@ Respond naturally as if you're joining the conversation to help.`;
 						channel
 					}
 				});
-				queryText = `The following is a message from ${formatChannelContext(channelInfo)} from ${userInfo?.displayName || "User"}: """${text}"""`;
+				const channelContext = formatChannelContext(channelInfo);
+				const userName = userInfo?.displayName || "User";
+				if (attachmentContext) queryText = `The following is a message from ${channelContext} from ${userName}: """${text}"""\n\nThe message also includes the following shared/forwarded content:\n\n<attached_content>\n${attachmentContext}\n</attached_content>`;
+				else queryText = `The following is a message from ${channelContext} from ${userName}: """${text}"""`;
 			}
 			const slackUserToken = await signSlackUserToken({
 				inkeepUserId: existingLink.inkeepUserId,

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

@@ -1,6 +1,6 @@
+import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./utils.js";
 import { InlineSelectorMetadata, handleAppMention } from "./app-mention.js";
 import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval } from "./block-actions.js";
 import { handleFollowUpSubmission, handleModalSubmission } from "./modal-submission.js";
-import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./utils.js";
 import { StreamResult, streamAgentResponse } from "./streaming.js";
 export { type InlineSelectorMetadata, SlackErrorType, type StreamResult, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, handleAppMention, handleFollowUpSubmission, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval, markdownToMrkdwn, sendResponseUrlMessage, streamAgentResponse };

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

@@ -11,9 +11,9 @@ declare function findCachedUserMapping(tenantId: string, slackUserId: string, te
   id: string;
   createdAt: string;
   updatedAt: string;
+  slackUserId: string;
   tenantId: string;
   clientId: string;
-  slackUserId: string;
   slackTeamId: string;
   slackEnterpriseId: string | null;
   inkeepUserId: string;
@@ -112,6 +112,24 @@ declare function checkIfBotThread(slackClient: {
     }>;
   };
 }, channel: string, threadTs: string): Promise<boolean>;
+interface SlackAttachment {
+  text?: string;
+  fallback?: string;
+  pretext?: string;
+  author_name?: string;
+  author_id?: string;
+  channel_name?: string;
+  channel_id?: string;
+  title?: string;
+  is_msg_unfurl?: boolean;
+  is_share?: boolean;
+  from_url?: string;
+  fields?: Array<{
+    title?: string;
+    value?: string;
+  }>;
+}
+declare function formatAttachments(attachments: SlackAttachment[] | undefined): string;
 interface ThreadContextOptions {
   includeLastMessage?: boolean;
   resolveUserNames?: boolean;
@@ -128,6 +146,7 @@ declare function getThreadContext(slackClient: {
         user?: string;
         text?: string;
         ts?: string;
+        attachments?: SlackAttachment[];
       }>;
     }>;
   };
@@ -160,4 +179,4 @@ declare function formatChannelContext(channelInfo: {
   name?: string;
 } | null): string;
 //#endregion
-export { ProjectOption, SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatChannelContext, formatChannelLabel, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };
+export { ProjectOption, SlackAttachment, SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatAttachments, formatChannelContext, formatChannelLabel, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };

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

@@ -34,17 +34,19 @@ async function findCachedUserMapping(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 (mapping) {
 		if (userMappingCache.size >= USER_MAPPING_CACHE_MAX_SIZE) {
-			const oldestKey = userMappingCache.keys().next().value;
-			if (oldestKey) userMappingCache.delete(oldestKey);
+			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
+		});
 	}
-	userMappingCache.set(cacheKey, {
-		mapping,
-		expiresAt: Date.now() + USER_MAPPING_CACHE_TTL_MS
-	});
 	return mapping;
 }
 /**
@@ -328,6 +330,27 @@ async function checkIfBotThread(slackClient, channel, threadTs) {
 		return false;
 	}
 }
+function formatAttachments(attachments) {
+	if (!attachments || attachments.length === 0) return "";
+	const parts = [];
+	for (const att of attachments) {
+		const content = att.text || att.fallback;
+		if (!content) continue;
+		const isSharedMessage = att.is_msg_unfurl || att.is_share;
+		const meta = [];
+		if (att.author_name) meta.push(`from ${att.author_name}`);
+		if (att.channel_name) meta.push(`in #${att.channel_name}`);
+		else if (att.channel_id) meta.push(`in channel ${att.channel_id}`);
+		const label = isSharedMessage ? "Shared message" : "Attachment";
+		const metaSuffix = meta.length > 0 ? ` (${meta.join(", ")})` : "";
+		const sourceLine = att.from_url ? `\n[Source: ${att.from_url}]` : "";
+		parts.push(`[${label}${metaSuffix}]:\n\`\`\`\n${content}\n\`\`\`${sourceLine}`);
+		if (att.fields && att.fields.length > 0) {
+			for (const field of att.fields) if (field.title && field.value) parts.push(`${field.title}: ${field.value}`);
+		}
+	}
+	return parts.join("\n\n");
+}
 async function getThreadContext(slackClient, channel, threadTs, options = {}) {
 	const { includeLastMessage = false, resolveUserNames = true } = options;
 	try {
@@ -377,7 +400,9 @@ async function getThreadContext(slackClient, channel, threadTs, options = {}) {
 			else role = "Unknown";
 			const prefix = isParent ? "[Thread Start] " : "";
 			const messageText = msg.text || "";
-			return `${prefix}${role}: """${messageText}"""`;
+			const attachmentText = formatAttachments(msg.attachments);
+			const fullText = attachmentText ? `${messageText}\n${attachmentText}` : messageText;
+			return `${prefix}${role}: """${fullText}"""`;
 		}).join("\n\n")}`;
 	} catch (threadError) {
 		logger.warn({
@@ -412,4 +437,4 @@ function formatChannelContext(channelInfo) {
 }
 
 //#endregion
-export { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatChannelContext, formatChannelLabel, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };
+export { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatAttachments, formatChannelContext, formatChannelLabel, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };

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

@@ -1,16 +1,16 @@
 import { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
-import { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
+import { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
 import { checkUserIsChannelMember, getSlackChannelInfo, 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 { handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand } from "./commands/index.js";
+import { AgentOption, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, FollowUpModalMetadata, ModalMetadata, buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "./modals.js";
+import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
 import { InlineSelectorMetadata, handleAppMention } from "./events/app-mention.js";
 import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval } 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, extractApiErrorMessage, 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, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, WorkspaceInstallData, buildAgentSelectorModal, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };
+export { AgentConfigSources, AgentOption, AgentResolutionParams, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, ContextBlockParams, DefaultAgentConfig, FollowUpButtonParams, FollowUpModalMetadata, InlineSelectorMetadata, ModalMetadata, ResolvedAgentConfig, SlackCommandPayload, SlackCommandResponse, SlackErrorType, SlackWorkspaceConnection, StreamResult, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, WorkspaceInstallData, buildAgentSelectorModal, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };

package/dist/slack/services/index.js

@@ -1,7 +1,7 @@
 import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.js";
 import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
 import { getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
-import { ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
+import { ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
 import { checkUserIsChannelMember, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken } from "./client.js";
 import { buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "./modals.js";
 import { handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand } from "./commands/index.js";
@@ -13,4 +13,4 @@ import "./events/index.js";
 import { parseSlackCommandBody, parseSlackEventBody, verifySlackRequest } from "./security.js";
 import { getBotTokenForTeam, setBotTokenForTeam } from "./workspace-tokens.js";
 
-export { SlackErrorType, ToolApprovalButtonValueSchema, buildAgentSelectorModal, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };
+export { SlackErrorType, ToolApprovalButtonValueSchema, buildAgentSelectorModal, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };

package/dist/slack/services/link-prompt.d.ts

@@ -0,0 +1,27 @@
+import { SlackLinkIntent } from "@inkeep/agents-core";
+import * as slack_block_builder0 from "slack-block-builder";
+
+//#region src/slack/services/link-prompt.d.ts
+type LinkPromptResult = {
+  type: 'auto_invite';
+  url: string;
+  email: string;
+  expiresInMinutes: number;
+} | {
+  type: 'jwt_link';
+  url: string;
+  expiresInMinutes: number;
+};
+interface ResolveLinkActionParams {
+  tenantId: string;
+  teamId: string;
+  slackUserId: string;
+  botToken: string;
+  slackEnterpriseId?: string;
+  slackUsername?: string;
+  intent?: SlackLinkIntent;
+}
+declare function resolveUnlinkedUserAction(params: ResolveLinkActionParams): Promise<LinkPromptResult>;
+declare function buildLinkPromptMessage(result: LinkPromptResult): Readonly<slack_block_builder0.SlackMessageDto>;
+//#endregion
+export { LinkPromptResult, ResolveLinkActionParams, buildLinkPromptMessage, resolveUnlinkedUserAction };

package/dist/slack/services/link-prompt.js

@@ -0,0 +1,142 @@
+import { env } from "../../env.js";
+import { getLogger } from "../../logger.js";
+import runDbClient_default from "../../db/runDbClient.js";
+import { createCreateInkeepAccountMessage, createSmartLinkMessage } from "./blocks/index.js";
+import { getSlackClient } from "./client.js";
+import { createInvitationInDb, findWorkAppSlackWorkspaceByTeamId, getOrganizationMemberByEmail, getPendingInvitationsByEmail, signSlackLinkToken } from "@inkeep/agents-core";
+
+//#region src/slack/services/link-prompt.ts
+const logger = getLogger("slack-link-prompt");
+const LINK_CODE_TTL_MINUTES = 10;
+async function resolveUnlinkedUserAction(params) {
+	const { tenantId, teamId, slackUserId, botToken, slackEnterpriseId, slackUsername, intent } = params;
+	const manageUiUrl = env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000";
+	const autoInvite = await tryAutoInvite({
+		tenantId,
+		teamId,
+		slackUserId,
+		botToken
+	});
+	if (autoInvite) {
+		const linkToken$1 = await signSlackLinkToken({
+			tenantId,
+			slackTeamId: teamId,
+			slackUserId,
+			slackEnterpriseId,
+			slackUsername,
+			intent
+		});
+		const authMethod = autoInvite.authMethod;
+		const linkReturnUrl = `/link?token=${encodeURIComponent(linkToken$1)}`;
+		const acceptUrl = authMethod === "email-password" ? `${manageUiUrl}/accept-invitation/${autoInvite.invitationId}?email=${encodeURIComponent(autoInvite.email)}&returnUrl=${encodeURIComponent(linkReturnUrl)}` : `${manageUiUrl}/login?invitation=${encodeURIComponent(autoInvite.invitationId)}&returnUrl=${encodeURIComponent(linkReturnUrl)}&email=${encodeURIComponent(autoInvite.email)}&authMethod=${encodeURIComponent(authMethod)}`;
+		logger.info({
+			invitationId: autoInvite.invitationId,
+			email: autoInvite.email,
+			hasIntent: !!intent
+		}, "Directing unlinked user to accept-invitation page");
+		return {
+			type: "auto_invite",
+			url: acceptUrl,
+			email: autoInvite.email,
+			expiresInMinutes: LINK_CODE_TTL_MINUTES
+		};
+	}
+	const linkToken = await signSlackLinkToken({
+		tenantId,
+		slackTeamId: teamId,
+		slackUserId,
+		slackEnterpriseId,
+		slackUsername,
+		intent
+	});
+	const linkUrl = `${manageUiUrl}/link?token=${encodeURIComponent(linkToken)}`;
+	logger.info({
+		slackUserId,
+		tenantId,
+		hasIntent: !!intent
+	}, "Generated JWT link token for unlinked user");
+	return {
+		type: "jwt_link",
+		url: linkUrl,
+		expiresInMinutes: LINK_CODE_TTL_MINUTES
+	};
+}
+function buildLinkPromptMessage(result) {
+	if (result.type === "auto_invite") return createCreateInkeepAccountMessage(result.url, result.expiresInMinutes);
+	return createSmartLinkMessage(result.url);
+}
+async function tryAutoInvite(params) {
+	const { tenantId, teamId, slackUserId, botToken } = params;
+	if (!botToken) return null;
+	try {
+		if (!(await findWorkAppSlackWorkspaceByTeamId(runDbClient_default)(tenantId, teamId))?.shouldAllowJoinFromWorkspace) {
+			logger.warn({
+				userId: slackUserId,
+				tenantId,
+				teamId
+			}, "Workspace should not allow join from workspace");
+			return null;
+		}
+		const slackClient = getSlackClient(botToken);
+		let userEmail;
+		try {
+			userEmail = (await slackClient.users.info({ user: slackUserId })).user?.profile?.email;
+		} catch (error) {
+			logger.warn({
+				error,
+				userId: slackUserId
+			}, "Failed to get user info from Slack");
+			return null;
+		}
+		if (!userEmail) {
+			logger.warn({ userId: slackUserId }, "No email found in Slack user profile");
+			return null;
+		}
+		if (await getOrganizationMemberByEmail(runDbClient_default)(tenantId, userEmail)) {
+			logger.debug({
+				userId: slackUserId,
+				email: userEmail
+			}, "User already has Inkeep account, skipping auto-invite");
+			return null;
+		}
+		const existingInvitation = (await getPendingInvitationsByEmail(runDbClient_default)(userEmail)).find((inv) => inv.organizationId === tenantId);
+		if (existingInvitation) {
+			logger.info({
+				userId: slackUserId,
+				tenantId,
+				invitationId: existingInvitation.id,
+				email: userEmail
+			}, "Reusing existing pending invitation for Slack user");
+			return {
+				invitationId: existingInvitation.id,
+				email: userEmail,
+				authMethod: existingInvitation.authMethod ?? "email-password"
+			};
+		}
+		const invitation = await createInvitationInDb(runDbClient_default)({
+			organizationId: tenantId,
+			email: userEmail
+		});
+		logger.info({
+			userId: slackUserId,
+			tenantId,
+			invitationId: invitation.id,
+			email: userEmail
+		}, "Invitation created for Slack user without Inkeep account");
+		return {
+			invitationId: invitation.id,
+			email: userEmail,
+			authMethod: invitation.authMethod
+		};
+	} catch (error) {
+		logger.warn({
+			error,
+			userId: slackUserId,
+			tenantId
+		}, "Auto-invite attempt failed");
+		return null;
+	}
+}
+
+//#endregion
+export { buildLinkPromptMessage, resolveUnlinkedUserAction };

package/dist/slack/services/resume-intent.d.ts

@@ -0,0 +1,15 @@
+import { SlackLinkIntent } from "@inkeep/agents-core";
+
+//#region src/slack/services/resume-intent.d.ts
+interface ResumeSmartLinkIntentParams {
+  intent: SlackLinkIntent;
+  teamId: string;
+  slackUserId: string;
+  inkeepUserId: string;
+  tenantId: string;
+  slackEnterpriseId?: string;
+  slackUsername?: string;
+}
+declare function resumeSmartLinkIntent(params: ResumeSmartLinkIntentParams): Promise<void>;
+//#endregion
+export { ResumeSmartLinkIntentParams, resumeSmartLinkIntent };