@inkeep/agents-work-apps 0.0.0-dev-20260224193013 → 0.0.0-dev-20260224195557

package/dist/github/index.d.ts

@@ -4,10 +4,10 @@ import "./routes/setup.js";
 import "./routes/tokenExchange.js";
 import { WebhookVerificationResult, verifyWebhookSignature } from "./routes/webhooks.js";
 import { Hono } from "hono";
-import * as hono_types2 from "hono/types";
+import * as hono_types0 from "hono/types";
 
 //#region src/github/index.d.ts
-declare function createGithubRoutes(): Hono<hono_types2.BlankEnv, hono_types2.BlankSchema, "/">;
-declare const githubRoutes: Hono<hono_types2.BlankEnv, hono_types2.BlankSchema, "/">;
+declare function createGithubRoutes(): Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
+declare const githubRoutes: Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
 //#endregion
 export { GenerateInstallationAccessTokenResult, GenerateTokenError, GenerateTokenResult, GitHubAppConfig, InstallationAccessToken, InstallationInfo, LookupInstallationError, LookupInstallationForRepoResult, LookupInstallationResult, WebhookVerificationResult, clearConfigCache, createAppJwt, createGithubRoutes, determineStatus, fetchInstallationDetails, fetchInstallationRepositories, generateInstallationAccessToken, getGitHubAppConfig, getGitHubAppName, getStateSigningSecret, getWebhookSecret, githubRoutes, isGitHubAppConfigured, isGitHubAppNameConfigured, isStateSigningConfigured, isWebhookConfigured, lookupInstallationForRepo, validateGitHubAppConfigOnStartup, validateGitHubInstallFlowConfigOnStartup, validateGitHubWebhookConfigOnStartup, verifyWebhookSignature };

package/dist/github/mcp/auth.d.ts

@@ -1,7 +1,7 @@
-import * as hono0 from "hono";
+import * as hono1 from "hono";
 
 //#region src/github/mcp/auth.d.ts
-declare const githubMcpAuth: () => hono0.MiddlewareHandler<{
+declare const githubMcpAuth: () => hono1.MiddlewareHandler<{
   Variables: {
     toolId: string;
   };

package/dist/github/mcp/index.d.ts

@@ -1,11 +1,11 @@
 import { Hono } from "hono";
-import * as hono_types1 from "hono/types";
+import * as hono_types0 from "hono/types";
 
 //#region src/github/mcp/index.d.ts
 declare const app: Hono<{
   Variables: {
     toolId: string;
   };
-}, hono_types1.BlankSchema, "/">;
+}, hono_types0.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/github/mcp/schemas.d.ts

@@ -76,8 +76,8 @@ declare const ChangedFileSchema: z.ZodObject<{
   path: z.ZodString;
   status: z.ZodEnum<{
     added: "added";
-    removed: "removed";
     modified: "modified";
+    removed: "removed";
     renamed: "renamed";
     copied: "copied";
     changed: "changed";

package/dist/github/routes/setup.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
-import * as hono_types0 from "hono/types";
+import * as hono_types6 from "hono/types";
 
 //#region src/github/routes/setup.d.ts
-declare const app: Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
+declare const app: Hono<hono_types6.BlankEnv, hono_types6.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/github/routes/tokenExchange.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
-import * as hono_types8 from "hono/types";
+import * as hono_types4 from "hono/types";
 
 //#region src/github/routes/tokenExchange.d.ts
-declare const app: Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
+declare const app: Hono<hono_types4.BlankEnv, hono_types4.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/github/routes/webhooks.d.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import * as hono_types6 from "hono/types";
+import * as hono_types8 from "hono/types";
 
 //#region src/github/routes/webhooks.d.ts
 interface WebhookVerificationResult {
@@ -7,6 +7,6 @@ interface WebhookVerificationResult {
   error?: string;
 }
 declare function verifyWebhookSignature(payload: string, signature: string | undefined, secret: string): WebhookVerificationResult;
-declare const app: Hono<hono_types6.BlankEnv, hono_types6.BlankSchema, "/">;
+declare const app: Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
 //#endregion
 export { WebhookVerificationResult, app as default, verifyWebhookSignature };

package/dist/slack/routes/users.js

@@ -2,8 +2,9 @@ import { getLogger } from "../../logger.js";
 import runDbClient_default from "../../db/runDbClient.js";
 import { createConnectSession } from "../services/nango.js";
 import "../services/index.js";
+import { resumeSmartLinkIntent } from "../services/resume-intent.js";
 import { OpenAPIHono, z } from "@hono/zod-openapi";
-import { createWorkAppSlackUserMapping, deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingByInkeepUserId, isUniqueConstraintError, verifySlackLinkToken } from "@inkeep/agents-core";
+import { createWorkAppSlackUserMapping, deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingByInkeepUserId, flushTraces, getWaitUntil, isUniqueConstraintError, verifySlackLinkToken } from "@inkeep/agents-core";
 import { createProtectedRoute, inheritedWorkAppsAuth } from "@inkeep/agents-core/middleware";
 
 //#region src/slack/routes/users.ts
@@ -105,8 +106,13 @@ app.openapi(createProtectedRoute({
 	try {
 		const verifyResult = await verifySlackLinkToken(body.token);
 		if (!verifyResult.valid || !verifyResult.payload) {
-			logger.warn({ error: verifyResult.error }, "Invalid link token");
-			return c.json({ error: verifyResult.error || "Invalid or expired link token. Please run /inkeep link in Slack to get a new one." }, 400);
+			const isExpired = verifyResult.error?.includes("\"exp\" claim timestamp check failed");
+			const errorMessage = isExpired ? "Token expired. Please run /inkeep link in Slack to get a new one." : verifyResult.error || "Invalid or expired link token. Please run /inkeep link in Slack to get a new one.";
+			logger.warn({
+				error: verifyResult.error,
+				isExpired
+			}, "Invalid link token");
+			return c.json({ error: errorMessage }, 400);
 		}
 		const { tenantId, slack } = verifyResult.payload;
 		const { teamId, userId: slackUserId, enterpriseId, username } = slack;
@@ -157,6 +163,26 @@ app.openapi(createProtectedRoute({
 			inkeepUserId: body.userId,
 			linkId: slackUserMapping.id
 		}, "Successfully linked Slack user to Inkeep account via JWT token");
+		const { intent } = verifyResult.payload;
+		if (intent) {
+			logger.info({
+				event: "smart_link_intent_resume_triggered",
+				entryPoint: intent.entryPoint,
+				questionLength: intent.question.length
+			}, "Smart link intent detected in verify-token");
+			const resumeWork = resumeSmartLinkIntent({
+				intent,
+				teamId,
+				slackUserId,
+				inkeepUserId,
+				tenantId,
+				slackEnterpriseId: enterpriseId,
+				slackUsername: username
+			}).catch((error) => logger.error({ error }, "Resume smart link intent failed")).finally(() => flushTraces());
+			const waitUntil = await getWaitUntil();
+			if (waitUntil) waitUntil(resumeWork);
+			else logger.warn({ entryPoint: intent.entryPoint }, "waitUntil not available, resume work may not complete");
+		}
 		return c.json({
 			success: true,
 			linkId: slackUserMapping.id,

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

@@ -71,6 +71,7 @@ interface AgentConfigSources {
   } | null;
 }
 declare function createStatusMessage(email: string, linkedAt: string, dashboardUrl: string, agentConfigs: AgentConfigSources): Readonly<slack_block_builder0.SlackMessageDto>;
+declare function createSmartLinkMessage(linkUrl: string): Readonly<slack_block_builder0.SlackMessageDto>;
 interface ToolApprovalButtonValue {
   toolCallId: string;
   conversationId: string;
@@ -149,7 +150,6 @@ declare function buildCitationsBlock(citations: Array<{
   title?: string;
   url?: string;
 }>): any[];
-declare function createJwtLinkMessage(linkUrl: string, expiresInMinutes: number): Readonly<slack_block_builder0.SlackMessageDto>;
 declare function createCreateInkeepAccountMessage(acceptUrl: string, expiresInMinutes: number): Readonly<slack_block_builder0.SlackMessageDto>;
 //#endregion
-export { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage };
+export { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage };

package/dist/slack/services/blocks/index.js

@@ -91,6 +91,9 @@ function createStatusMessage(email, linkedAt, dashboardUrl, agentConfigs) {
 	if (projectLine) lines.push(projectLine);
 	return Message().blocks(Blocks.Section().text(lines.join("\n")), Blocks.Actions().elements(Elements.Button().text(SlackStrings.buttons.openDashboard).url(dashboardUrl).actionId("open_dashboard"))).buildToObject();
 }
+function createSmartLinkMessage(linkUrl) {
+	return Message().blocks(Blocks.Section().text("To get started, let's connect your Inkeep account with Slack."), Blocks.Actions().elements(Elements.Button().text("Link Account").url(linkUrl).actionId("smart_link_account").primary()), Blocks.Context().elements("🕐 This only needs to happen once.")).buildToObject();
+}
 const ToolApprovalButtonValueSchema = z.object({
 	toolCallId: z.string(),
 	conversationId: z.string(),
@@ -316,12 +319,9 @@ function buildCitationsBlock(citations) {
 		}
 	}];
 }
-function createJwtLinkMessage(linkUrl, expiresInMinutes) {
-	return Message().blocks(Blocks.Section().text(`${Md.bold("Link your Inkeep account")}\n\nConnect your Slack and Inkeep accounts to use Inkeep agents.`), Blocks.Actions().elements(Elements.Button().text("Link Account").url(linkUrl).actionId("link_account").primary()), Blocks.Context().elements(`This link expires in ${expiresInMinutes} minutes.`)).buildToObject();
-}
 function createCreateInkeepAccountMessage(acceptUrl, expiresInMinutes) {
 	return Message().blocks(Blocks.Section().text(`${Md.bold("Create your Inkeep account")}\n\nYou've been invited to join Inkeep. Create an account to start using Inkeep agents in Slack.`), Blocks.Actions().elements(Elements.Button().text("Create Account").url(acceptUrl).actionId("create_account").primary()), Blocks.Context().elements(`This link expires in ${expiresInMinutes} minutes.`)).buildToObject();
 }
 
 //#endregion
-export { ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage };
+export { ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage };

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

@@ -11,7 +11,7 @@ declare function handleHelpCommand(): Promise<SlackCommandResponse>;
  * Similar to @mention behavior in channels
  */
 declare function handleAgentPickerCommand(payload: SlackCommandPayload, tenantId: string, workspaceConnection?: SlackWorkspaceConnection | null): Promise<SlackCommandResponse>;
-declare function handleQuestionCommand(payload: SlackCommandPayload, question: string, _dashboardUrl: string, tenantId: string): Promise<SlackCommandResponse>;
+declare function handleQuestionCommand(payload: SlackCommandPayload, question: string, _dashboardUrl: string, tenantId: string, botToken: string): Promise<SlackCommandResponse>;
 declare function handleCommand(payload: SlackCommandPayload): Promise<SlackCommandResponse>;
 //#endregion
 export { handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand };

package/dist/slack/services/commands/index.js

@@ -5,131 +5,32 @@ import { findWorkspaceConnectionByTeamId } from "../nango.js";
 import { extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, getChannelAgentConfig, sendResponseUrlMessage } from "../events/utils.js";
 import { resolveEffectiveAgent } from "../agent-resolution.js";
 import { SlackStrings } from "../../i18n/strings.js";
-import { createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "../blocks/index.js";
+import { createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "../blocks/index.js";
 import { getSlackClient } from "../client.js";
+import { buildLinkPromptMessage, resolveUnlinkedUserAction } from "../link-prompt.js";
 import { buildAgentSelectorModal } from "../modals.js";
-import { createInvitationInDb, deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingBySlackUser, findWorkAppSlackWorkspaceByTeamId, flushTraces, getInProcessFetch, getOrganizationMemberByEmail, getPendingInvitationsByEmail, getWaitUntil, signSlackLinkToken, signSlackUserToken } from "@inkeep/agents-core";
+import { deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingBySlackUser, flushTraces, getInProcessFetch, getWaitUntil, signSlackUserToken } from "@inkeep/agents-core";
 
 //#region src/slack/services/commands/index.ts
 const DEFAULT_CLIENT_ID = "work-apps-slack";
-const LINK_CODE_TTL_MINUTES = 10;
 const logger = getLogger("slack-commands");
-/**
-* Create an invitation for a Slack user who doesn't have an Inkeep account yet.
-* Returns the invitation ID and email so the caller can direct the user
-* to the accept-invitation page.
-*
-* Returns null if:
-* - Workspace doesn't have shouldAllowJoinFromWorkspace enabled
-* - User already has an Inkeep account (JWT link flow is sufficient)
-* - Service account is not configured
-*/
-async function tryAutoInvite(payload, tenantId, botToken) {
-	try {
-		if (!(await findWorkAppSlackWorkspaceByTeamId(runDbClient_default)(tenantId, payload.teamId))?.shouldAllowJoinFromWorkspace) return null;
-		const slackClient = getSlackClient(botToken);
-		let userEmail;
-		try {
-			userEmail = (await slackClient.users.info({ user: payload.userId })).user?.profile?.email;
-		} catch (error) {
-			logger.warn({
-				error,
-				userId: payload.userId
-			}, "Failed to get user info from Slack");
-			return null;
-		}
-		if (!userEmail) {
-			logger.warn({ userId: payload.userId }, "No email found in Slack user profile");
-			return null;
-		}
-		if (await getOrganizationMemberByEmail(runDbClient_default)(tenantId, userEmail)) {
-			logger.debug({
-				userId: payload.userId,
-				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: payload.userId,
-				tenantId,
-				invitationId: existingInvitation.id,
-				email: userEmail
-			}, "Reusing existing pending invitation for Slack user");
-			return {
-				invitationId: existingInvitation.id,
-				email: userEmail
-			};
-		}
-		const invitation = await createInvitationInDb(runDbClient_default)({
-			organizationId: tenantId,
-			email: userEmail
-		});
-		logger.info({
-			userId: payload.userId,
-			tenantId,
-			invitationId: invitation.id,
-			email: userEmail
-		}, "Invitation created for Slack user without Inkeep account");
-		return {
-			invitationId: invitation.id,
-			email: userEmail
-		};
-	} catch (error) {
-		logger.warn({
-			error,
-			userId: payload.userId,
-			tenantId
-		}, "Auto-invite attempt failed");
-		return null;
-	}
-}
 async function handleLinkCommand(payload, dashboardUrl, tenantId, botToken) {
 	const existingLink = await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, payload.userId, payload.teamId, DEFAULT_CLIENT_ID);
 	if (existingLink) return {
 		response_type: "ephemeral",
 		...createAlreadyLinkedMessage(existingLink.slackEmail || existingLink.slackUsername || "Unknown", existingLink.linkedAt, dashboardUrl)
 	};
-	if (botToken) {
-		const autoInvite = await tryAutoInvite(payload, tenantId, botToken);
-		if (autoInvite) {
-			const manageUiUrl = env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000";
-			const linkToken = await signSlackLinkToken({
+	try {
+		return {
+			response_type: "ephemeral",
+			...buildLinkPromptMessage(await resolveUnlinkedUserAction({
 				tenantId,
-				slackTeamId: payload.teamId,
+				teamId: payload.teamId,
 				slackUserId: payload.userId,
+				botToken: botToken || "",
 				slackEnterpriseId: payload.enterpriseId,
 				slackUsername: payload.userName
-			});
-			const linkReturnUrl = `/link?token=${encodeURIComponent(linkToken)}`;
-			const acceptUrl = `${manageUiUrl}/accept-invitation/${autoInvite.invitationId}?email=${encodeURIComponent(autoInvite.email)}&returnUrl=${encodeURIComponent(linkReturnUrl)}`;
-			logger.info({
-				invitationId: autoInvite.invitationId,
-				email: autoInvite.email
-			}, "Directing new user to accept-invitation page with link returnUrl");
-			return {
-				response_type: "ephemeral",
-				...createCreateInkeepAccountMessage(acceptUrl, LINK_CODE_TTL_MINUTES)
-			};
-		}
-	}
-	try {
-		const linkToken = await signSlackLinkToken({
-			tenantId,
-			slackTeamId: payload.teamId,
-			slackUserId: payload.userId,
-			slackEnterpriseId: payload.enterpriseId,
-			slackUsername: payload.userName
-		});
-		const linkUrl = `${env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000"}/link?token=${encodeURIComponent(linkToken)}`;
-		logger.info({
-			slackUserId: payload.userId,
-			tenantId
-		}, "Generated JWT link token");
-		return {
-			response_type: "ephemeral",
-			...createJwtLinkMessage(linkUrl, LINK_CODE_TTL_MINUTES)
+			}))
 		};
 	} catch (error) {
 		logger.error({
@@ -278,23 +179,27 @@ async function handleAgentPickerCommand(payload, tenantId, workspaceConnection)
 		};
 	}
 }
-async function generateLinkCodeWithIntent(payload, tenantId) {
+async function generateLinkCodeWithIntent(payload, tenantId, botToken, intent) {
 	try {
-		const linkToken = await signSlackLinkToken({
+		const linkResult = await resolveUnlinkedUserAction({
 			tenantId,
-			slackTeamId: payload.teamId,
+			teamId: payload.teamId,
 			slackUserId: payload.userId,
+			botToken,
 			slackEnterpriseId: payload.enterpriseId,
-			slackUsername: payload.userName
+			slackUsername: payload.userName,
+			intent
 		});
-		const linkUrl = `${env.INKEEP_AGENTS_MANAGE_UI_URL || "http://localhost:3000"}/link?token=${encodeURIComponent(linkToken)}`;
-		logger.info({
-			slackUserId: payload.userId,
-			tenantId
-		}, "Generated JWT link token with intent");
+		if (!!intent) logger.info({
+			event: "smart_link_intent_captured",
+			entryPoint: intent.entryPoint,
+			linkType: linkResult.type,
+			questionLength: intent.question.length,
+			channelId: payload.channelId
+		}, "Smart link intent captured");
 		return {
 			response_type: "ephemeral",
-			...createJwtLinkMessage(linkUrl, LINK_CODE_TTL_MINUTES)
+			...buildLinkPromptMessage(linkResult)
 		};
 	} catch (error) {
 		logger.error({
@@ -308,9 +213,14 @@ async function generateLinkCodeWithIntent(payload, tenantId) {
 		};
 	}
 }
-async function handleQuestionCommand(payload, question, _dashboardUrl, tenantId) {
+async function handleQuestionCommand(payload, question, _dashboardUrl, tenantId, botToken) {
 	const existingLink = await findWorkAppSlackUserMappingBySlackUser(runDbClient_default)(payload.userId, payload.teamId, DEFAULT_CLIENT_ID);
-	if (!existingLink) return generateLinkCodeWithIntent(payload, tenantId);
+	if (!existingLink) return generateLinkCodeWithIntent(payload, tenantId, botToken, {
+		entryPoint: "question_command",
+		question: question.slice(0, 2e3),
+		channelId: payload.channelId,
+		responseUrl: payload.responseUrl
+	});
 	const userTenantId = existingLink.tenantId;
 	const resolvedAgent = await resolveEffectiveAgent({
 		tenantId: userTenantId,
@@ -464,7 +374,7 @@ async function handleCommand(payload) {
 		case "disconnect": return handleUnlinkCommand(payload, tenantId);
 		case "help": return handleHelpCommand();
 		case "": return handleAgentPickerCommand(payload, tenantId, workspaceConnection);
-		default: return handleQuestionCommand(payload, text, dashboardUrl, tenantId);
+		default: return handleQuestionCommand(payload, text, dashboardUrl, tenantId, workspaceConnection.botToken);
 	}
 }
 

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

@@ -5,25 +5,12 @@ import { checkIfBotThread, classifyError, findCachedUserMapping, formatChannelCo
 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
@@ -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;

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;
 }
 /**

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

@@ -1,5 +1,5 @@
 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";
@@ -13,4 +13,4 @@ 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 };

package/dist/slack/services/resume-intent.js

@@ -0,0 +1,338 @@
+import { env } from "../../env.js";
+import { getLogger } from "../../logger.js";
+import { findWorkspaceConnectionByTeamId } from "./nango.js";
+import { generateSlackConversationId, sendResponseUrlMessage } from "./events/utils.js";
+import { resolveEffectiveAgent } from "./agent-resolution.js";
+import { createContextBlock } from "./blocks/index.js";
+import { getSlackClient } from "./client.js";
+import { streamAgentResponse } from "./events/streaming.js";
+import { signSlackUserToken } from "@inkeep/agents-core";
+
+//#region src/slack/services/resume-intent.ts
+const logger = getLogger("slack-resume-intent");
+function getChannelAuthClaims(agentConfig, channelId) {
+	return {
+		slackAuthorized: agentConfig?.grantAccessToMembers ?? false,
+		slackAuthSource: agentConfig?.source && agentConfig.source !== "none" ? agentConfig.source : void 0,
+		slackChannelId: channelId,
+		slackAuthorizedProjectId: agentConfig?.projectId
+	};
+}
+async function resumeSmartLinkIntent(params) {
+	const { intent, teamId, slackUserId, inkeepUserId, tenantId, slackEnterpriseId } = params;
+	const startTime = Date.now();
+	try {
+		const botToken = (await findWorkspaceConnectionByTeamId(teamId))?.botToken;
+		if (!botToken) {
+			logger.error({
+				teamId,
+				entryPoint: intent.entryPoint
+			}, "No bot token available for resume");
+			return;
+		}
+		const slackClient = getSlackClient(botToken);
+		const tokenCtx = {
+			inkeepUserId,
+			tenantId,
+			slackTeamId: teamId,
+			slackUserId,
+			slackEnterpriseId
+		};
+		let resolvedAgentId;
+		let deliveryMethod;
+		switch (intent.entryPoint) {
+			case "mention":
+				resolvedAgentId = intent.agentId;
+				deliveryMethod = "streaming";
+				await resumeMention(intent, slackClient, tokenCtx, teamId, tenantId);
+				break;
+			case "question_command":
+				deliveryMethod = intent.responseUrl ? "response_url" : "bot_token";
+				await resumeCommand(intent, slackClient, tokenCtx, teamId, tenantId);
+				break;
+			case "run_command":
+				deliveryMethod = intent.responseUrl ? "response_url" : "bot_token";
+				await resumeRunCommand(intent, slackClient, tokenCtx, teamId, tenantId);
+				break;
+		}
+		const durationMs = Date.now() - startTime;
+		logger.info({
+			event: "smart_link_intent_resumed",
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId,
+			agentId: resolvedAgentId || intent.agentId,
+			deliveryMethod,
+			durationMs
+		}, "Smart link intent resumed");
+	} catch (error) {
+		logger.error({
+			event: "smart_link_intent_failed",
+			entryPoint: intent.entryPoint,
+			error: error instanceof Error ? error.message : String(error)
+		}, "Smart link intent resume failed");
+	}
+}
+async function resumeMention(intent, slackClient, tokenCtx, teamId, tenantId) {
+	const { slackUserId } = tokenCtx;
+	if (!intent.agentId || !intent.projectId) {
+		logger.error({
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId,
+			hasAgentId: !!intent.agentId,
+			hasProjectId: !!intent.projectId
+		}, "Mention intent missing agentId or projectId");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, intent.threadTs);
+		return;
+	}
+	const replyThreadTs = intent.threadTs || intent.messageTs;
+	if (!replyThreadTs) {
+		logger.error({
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId
+		}, "Mention intent missing threadTs and messageTs");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, "We couldn't resume your question due to a technical issue. Please try mentioning @Inkeep again.");
+		return;
+	}
+	const agentConfig = await resolveEffectiveAgent({
+		tenantId,
+		teamId,
+		channelId: intent.channelId
+	});
+	const slackUserToken = await signSlackUserToken({
+		...tokenCtx,
+		...getChannelAuthClaims(agentConfig, intent.channelId)
+	});
+	const ackMessage = await slackClient.chat.postMessage({
+		channel: intent.channelId,
+		thread_ts: replyThreadTs,
+		text: "_Answering your question..._"
+	});
+	const conversationId = generateSlackConversationId({
+		teamId,
+		threadTs: replyThreadTs,
+		channel: intent.channelId,
+		isDM: false,
+		agentId: intent.agentId
+	});
+	await streamAgentResponse({
+		slackClient,
+		channel: intent.channelId,
+		threadTs: replyThreadTs,
+		thinkingMessageTs: ackMessage.ts || "",
+		slackUserId,
+		teamId,
+		jwtToken: slackUserToken,
+		projectId: intent.projectId,
+		agentId: intent.agentId,
+		question: intent.question,
+		agentName: intent.agentId,
+		conversationId
+	});
+}
+async function resumeCommand(intent, slackClient, tokenCtx, teamId, tenantId) {
+	const { slackUserId } = tokenCtx;
+	const resolvedAgent = await resolveEffectiveAgent({
+		tenantId,
+		teamId,
+		channelId: intent.channelId,
+		userId: slackUserId
+	});
+	if (!resolvedAgent) {
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, "The agent couldn't be found. Try asking your question again.");
+		return;
+	}
+	await executeAndDeliver({
+		intent,
+		slackClient,
+		slackUserToken: await signSlackUserToken({
+			...tokenCtx,
+			...getChannelAuthClaims(resolvedAgent, intent.channelId)
+		}),
+		slackUserId,
+		teamId,
+		agentId: resolvedAgent.agentId,
+		agentName: resolvedAgent.agentName || resolvedAgent.agentId,
+		projectId: resolvedAgent.projectId
+	});
+}
+async function resumeRunCommand(intent, slackClient, tokenCtx, teamId, tenantId) {
+	const { slackUserId } = tokenCtx;
+	if (!intent.agentIdentifier) {
+		logger.error({
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId
+		}, "Run command intent missing agentIdentifier");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId);
+		return;
+	}
+	const agentConfig = await resolveEffectiveAgent({
+		tenantId,
+		teamId,
+		channelId: intent.channelId
+	});
+	const slackUserToken = await signSlackUserToken({
+		...tokenCtx,
+		...getChannelAuthClaims(agentConfig, intent.channelId)
+	});
+	const agentInfo = await findAgentByIdentifierViaApi(tenantId, intent.agentIdentifier, slackUserToken);
+	if (!agentInfo) {
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, `Agent "${intent.agentIdentifier}" couldn't be found. Try asking your question again.`);
+		return;
+	}
+	await executeAndDeliver({
+		intent,
+		slackClient,
+		slackUserToken,
+		slackUserId,
+		teamId,
+		agentId: agentInfo.id,
+		agentName: agentInfo.name || agentInfo.id,
+		projectId: agentInfo.projectId
+	});
+}
+async function findAgentByIdentifierViaApi(tenantId, identifier, authToken) {
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), 1e4);
+	try {
+		const projectsResponse = await fetch(`${apiBaseUrl}/manage/tenants/${tenantId}/projects`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${authToken}`
+			},
+			signal: controller.signal
+		});
+		if (!projectsResponse.ok) return null;
+		const projectsData = await projectsResponse.json();
+		const projects = projectsData.data || projectsData || [];
+		return (await Promise.all(projects.map(async (project) => {
+			try {
+				const agentsResponse = await fetch(`${apiBaseUrl}/manage/tenants/${tenantId}/projects/${project.id}/agents`, {
+					method: "GET",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${authToken}`
+					},
+					signal: controller.signal
+				});
+				if (!agentsResponse.ok) return [];
+				const agentsData = await agentsResponse.json();
+				return (agentsData.data || agentsData || []).map((agent) => ({
+					id: agent.id,
+					name: agent.name,
+					projectId: project.id
+				}));
+			} catch (error) {
+				logger.warn({
+					error: error instanceof Error ? error.message : String(error),
+					projectId: project.id
+				}, "Failed to fetch agents for project during identifier lookup");
+				return [];
+			}
+		}))).flat().find((a) => a.id === identifier || a.name?.toLowerCase() === identifier.toLowerCase()) || null;
+	} catch (error) {
+		const isTimeout = error instanceof Error && error.name === "AbortError";
+		logger.warn({
+			error: error instanceof Error ? error.message : String(error),
+			tenantId,
+			identifier,
+			isTimeout
+		}, "Failed to find agent by identifier");
+		return null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function executeAndDeliver(params) {
+	const { intent, slackClient, slackUserToken, slackUserId, teamId, agentId, agentName, projectId } = params;
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), 3e4);
+	let response;
+	try {
+		response = await fetch(`${apiBaseUrl}/run/api/chat`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${slackUserToken}`,
+				"x-inkeep-project-id": projectId,
+				"x-inkeep-agent-id": agentId
+			},
+			body: JSON.stringify({
+				messages: [{
+					role: "user",
+					content: intent.question
+				}],
+				stream: false
+			}),
+			signal: controller.signal
+		});
+	} catch (error) {
+		clearTimeout(timeout);
+		if (error.name === "AbortError") logger.warn({
+			teamId,
+			timeoutMs: 3e4
+		}, "Resume agent execution timed out");
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+	if (!response.ok) {
+		logger.error({
+			status: response.status,
+			agentId,
+			projectId
+		}, "Resume run API call failed");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, "Something went wrong while answering your question. Please try again.");
+		return;
+	}
+	const result = await response.json();
+	const assistantMessage = result.choices?.[0]?.message?.content || result.message?.content || "No response received";
+	const contextBlock = createContextBlock({ agentName });
+	if (intent.responseUrl) try {
+		await sendResponseUrlMessage(intent.responseUrl, {
+			response_type: "ephemeral",
+			text: assistantMessage,
+			blocks: [{
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: assistantMessage
+				}
+			}, contextBlock]
+		});
+		return;
+	} catch {
+		logger.warn({ channelId: intent.channelId }, "response_url delivery failed, falling back to bot channel post");
+	}
+	await slackClient.chat.postMessage({
+		channel: intent.channelId,
+		text: assistantMessage,
+		blocks: [{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: assistantMessage
+			}
+		}, contextBlock]
+	});
+}
+async function postErrorToChannel(slackClient, channelId, slackUserId, threadTs, message = "The agent couldn't be found. Try asking your question again.") {
+	try {
+		await slackClient.chat.postEphemeral({
+			channel: channelId,
+			user: slackUserId,
+			thread_ts: threadTs,
+			text: message
+		});
+	} catch (error) {
+		logger.warn({
+			error,
+			channelId
+		}, "Failed to post error message to Slack");
+	}
+}
+
+//#endregion
+export { resumeSmartLinkIntent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-work-apps",
-  "version": "0.0.0-dev-20260224193013",
+  "version": "0.0.0-dev-20260224195557",
   "description": "First party integrations for Inkeep Agents",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -33,7 +33,7 @@
     "jose": "^6.1.0",
     "minimatch": "^10.1.1",
     "slack-block-builder": "^2.8.0",
-    "@inkeep/agents-core": "0.0.0-dev-20260224193013"
+    "@inkeep/agents-core": "0.0.0-dev-20260224195557"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",