@inkeep/agents-work-apps 0.52.0 → 0.53.1

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

@@ -17,6 +17,7 @@ declare function createContextBlock(params: ContextBlockParams): {
 interface FollowUpButtonParams {
   conversationId: string;
   agentId: string;
+  agentName?: string;
   projectId: string;
   tenantId: string;
   teamId: string;
@@ -52,18 +53,25 @@ interface AgentConfigSources {
   channelConfig: {
     agentName?: string;
     agentId: string;
+    projectId: string;
+    projectName?: string;
   } | null;
   workspaceConfig: {
     agentName?: string;
     agentId: string;
+    projectId: string;
+    projectName?: string;
   } | null;
   effective: {
     agentName?: string;
     agentId: string;
+    projectId: string;
+    projectName?: string;
     source: string;
   } | 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;
@@ -142,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

@@ -44,10 +44,7 @@ function buildConversationResponseBlocks(params) {
 		}
 	}];
 	if (!isError) {
-		const contextBlock = createContextBlock({
-			agentName,
-			isPrivate: true
-		});
+		const contextBlock = createContextBlock({ agentName });
 		blocks.push(contextBlock);
 		blocks.push({
 			type: "actions",
@@ -70,10 +67,32 @@ function createNotLinkedMessage() {
 }
 function createStatusMessage(email, linkedAt, dashboardUrl, agentConfigs) {
 	const { effective } = agentConfigs;
+	const baseUrl = dashboardUrl.replace(/\/work-apps\/slack$/, "");
 	let agentLine;
-	if (effective) agentLine = `${Md.bold("Agent:")} ${effective.agentName || effective.agentId}`;
-	else agentLine = `${Md.bold("Agent:")} None configured\n${Md.italic("Ask your admin to set up an agent in the dashboard.")}`;
-	return Message().blocks(Blocks.Section().text(Md.bold("Connected to Inkeep") + `\n\n${Md.bold("Account:")} ${email}\n${Md.bold("Linked:")} ${new Date(linkedAt).toLocaleDateString()}\n` + agentLine), Blocks.Actions().elements(Elements.Button().text(SlackStrings.buttons.openDashboard).url(dashboardUrl).actionId("open_dashboard"))).buildToObject();
+	let projectLine;
+	if (effective) {
+		const agentDisplayName = effective.agentName || effective.agentId;
+		const agentUrl = `${baseUrl}/projects/${effective.projectId}/agents/${effective.agentId}`;
+		agentLine = `${Md.bold("Agent:")} <${agentUrl}|${agentDisplayName}>`;
+		const projectDisplayName = effective.projectName || effective.projectId;
+		const projectUrl = `${baseUrl}/projects/${effective.projectId}/agents`;
+		projectLine = `${Md.bold("Project:")} <${projectUrl}|${projectDisplayName}>`;
+	} else {
+		agentLine = `${Md.bold("Agent:")} None configured\n${Md.italic("Ask your admin to set up an agent in the dashboard.")}`;
+		projectLine = "";
+	}
+	const lines = [
+		Md.bold("Connected to Inkeep"),
+		"",
+		`${Md.bold("Account:")} ${email}`,
+		`${Md.bold("Linked:")} ${new Date(linkedAt).toLocaleDateString()}`,
+		agentLine
+	];
+	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(),
@@ -300,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

@@ -2,134 +2,35 @@ import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
 import runDbClient_default from "../../../db/runDbClient.js";
 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 { extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, getChannelAgentConfig, sendResponseUrlMessage } from "../events/utils.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,
@@ -412,7 +322,7 @@ async function executeAgentInBackground(payload, existingLink, targetAgent, ques
 			}, "Agent execution completed via Slack");
 			const contextBlock = createContextBlock({ agentName: targetAgent.name || targetAgent.id });
 			await sendResponseUrlMessage(payload.responseUrl, {
-				response_type: "ephemeral",
+				response_type: "in_channel",
 				text: assistantMessage,
 				blocks: [{
 					type: "section",
@@ -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.d.ts

@@ -1,18 +1,7 @@
+import { SlackAttachment } from "./utils.js";
+
 //#region src/slack/services/events/app-mention.d.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
- */
+
 /**
  * Metadata passed to the agent selector modal via button value
  */
@@ -32,6 +21,7 @@ declare function handleAppMention(params: {
   slackUserId: string;
   channel: string;
   text: string;
+  attachments?: SlackAttachment[];
   threadTs: string;
   messageTs: string;
   teamId: string;

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, 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 { checkIfBotThread, classifyError, findCachedUserMapping, formatChannelContext, generateSlackConversationId, getThreadContext, getUserFriendlyErrorMessage, timedOp } from "./utils.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/block-actions.js

@@ -1,10 +1,10 @@
 import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
 import { findWorkspaceConnectionByTeamId } from "../nango.js";
+import { fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, getChannelAgentConfig, sendResponseUrlMessage } from "./utils.js";
 import { SlackStrings } from "../../i18n/strings.js";
 import { ToolApprovalButtonValueSchema, buildToolApprovalDoneBlocks } from "../blocks/index.js";
 import { getSlackClient } from "../client.js";
-import { fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, getChannelAgentConfig, sendResponseUrlMessage } from "./utils.js";
 import { buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "../modals.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
 import { getInProcessFetch, signSlackUserToken } from "@inkeep/agents-core";

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/modal-submission.js

@@ -1,10 +1,10 @@
 import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
 import { findWorkspaceConnectionByTeamId } from "../nango.js";
+import { classifyError, extractApiErrorMessage, findCachedUserMapping, generateSlackConversationId, getThreadContext, getUserFriendlyErrorMessage, markdownToMrkdwn, sendResponseUrlMessage } from "./utils.js";
 import { SlackStrings } from "../../i18n/strings.js";
 import { buildConversationResponseBlocks } from "../blocks/index.js";
 import { getSlackClient } from "../client.js";
-import { classifyError, extractApiErrorMessage, findCachedUserMapping, generateSlackConversationId, getThreadContext, getUserFriendlyErrorMessage, markdownToMrkdwn, sendResponseUrlMessage } from "./utils.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
 import { getInProcessFetch, signSlackUserToken } from "@inkeep/agents-core";
 
@@ -36,13 +36,16 @@ async function handleModalSubmission(view) {
 			const includeContext = includeContextValue?.selected_options?.some((o) => o.value === "include_context") ?? true;
 			let agentId = metadata.selectedAgentId;
 			let projectId = metadata.selectedProjectId;
+			let agentName = null;
 			if (agentSelectValue?.selected_option?.value) try {
 				const parsed = JSON.parse(agentSelectValue.selected_option.value);
 				agentId = parsed.agentId;
 				projectId = parsed.projectId;
+				agentName = parsed.agentName || null;
 			} catch {
 				logger.warn({ value: agentSelectValue.selected_option.value }, "Failed to parse agent select value");
 			}
+			const agentDisplayName = agentName || agentId || "Agent";
 			if (!agentId || !projectId) {
 				logger.error({ metadata }, "Missing agent or project ID in modal submission");
 				if (metadata.buttonResponseUrl) await sendResponseUrlMessage(metadata.buttonResponseUrl, {
@@ -112,7 +115,7 @@ async function handleModalSubmission(view) {
 			});
 			span.setAttribute(SLACK_SPAN_KEYS.CONVERSATION_ID, conversationId);
 			const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
-			const thinkingText = SlackStrings.status.thinking(agentId);
+			const thinkingText = SlackStrings.status.thinking(agentDisplayName);
 			if (metadata.buttonResponseUrl) await sendResponseUrlMessage(metadata.buttonResponseUrl, {
 				text: thinkingText,
 				response_type: "ephemeral",
@@ -139,6 +142,7 @@ async function handleModalSubmission(view) {
 				slackClient,
 				metadata,
 				agentId,
+				agentDisplayName,
 				projectId,
 				tenantId,
 				conversationId,
@@ -194,7 +198,8 @@ async function handleFollowUpSubmission(view) {
 				span.end();
 				return;
 			}
-			const { conversationId, agentId, projectId, tenantId, teamId, slackUserId, channel } = metadata;
+			const { conversationId, agentId, agentName, projectId, tenantId, teamId, slackUserId, channel } = metadata;
+			const agentDisplayName = agentName || agentId || "Agent";
 			span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
 			span.setAttribute(SLACK_SPAN_KEYS.CHANNEL_ID, channel);
 			span.setAttribute(SLACK_SPAN_KEYS.USER_ID, slackUserId);
@@ -234,7 +239,7 @@ async function handleFollowUpSubmission(view) {
 			await slackClient.chat.postEphemeral({
 				channel,
 				user: slackUserId,
-				text: SlackStrings.status.thinking(agentId)
+				text: SlackStrings.status.thinking(agentDisplayName)
 			});
 			const responseText = await callAgentApi({
 				apiBaseUrl,
@@ -247,11 +252,12 @@ async function handleFollowUpSubmission(view) {
 			const responseBlocks = buildConversationResponseBlocks({
 				userMessage: question,
 				responseText: responseText.text,
-				agentName: agentId,
+				agentName: agentDisplayName,
 				isError: responseText.isError,
 				followUpParams: {
 					conversationId,
 					agentId,
+					agentName: agentDisplayName,
 					projectId,
 					tenantId,
 					teamId,
@@ -370,15 +376,16 @@ async function callAgentApi(params) {
 	});
 }
 async function postPrivateResponse(params) {
-	const { slackClient, metadata, agentId, projectId, tenantId, conversationId, userMessage, responseText, isError } = params;
+	const { slackClient, metadata, agentId, agentDisplayName, projectId, tenantId, conversationId, userMessage, responseText, isError } = params;
 	const responseBlocks = buildConversationResponseBlocks({
 		userMessage,
 		responseText,
-		agentName: agentId,
+		agentName: agentDisplayName,
 		isError,
 		followUpParams: {
 			conversationId,
 			agentId,
+			agentName: agentDisplayName,
 			projectId,
 			tenantId,
 			teamId: metadata.teamId,

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

@@ -1,7 +1,7 @@
 import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
-import { buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createContextBlock } from "../blocks/index.js";
 import { SlackErrorType, classifyError, extractApiErrorMessage, getUserFriendlyErrorMessage } from "./utils.js";
+import { buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createContextBlock } from "../blocks/index.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
 import { getInProcessFetch, retryWithBackoff } from "@inkeep/agents-core";
 
@@ -193,6 +193,7 @@ async function streamAgentResponse(params) {
 		});
 		const pendingApprovalMessages = [];
 		const toolCallIdToName = /* @__PURE__ */ new Map();
+		const toolCallIdToInput = /* @__PURE__ */ new Map();
 		const toolErrors = [];
 		const citations = [];
 		const summaryLabels = [];
@@ -221,9 +222,9 @@ async function streamAgentResponse(params) {
 							continue;
 						}
 						if (data.type === "tool-approval-request" && conversationId) {
-							const toolName = data.toolName || "Tool";
 							const toolCallId = data.toolCallId;
-							const input = data.input;
+							const toolName = toolCallIdToName.get(toolCallId) || "Tool";
+							const input = toolCallIdToInput.get(toolCallId);
 							const buttonValue = {
 								toolCallId,
 								conversationId,
@@ -260,6 +261,7 @@ async function streamAgentResponse(params) {
 						}
 						if (data.type === "tool-input-available" && data.toolCallId && data.toolName) {
 							toolCallIdToName.set(String(data.toolCallId), String(data.toolName));
+							if (data.input && typeof data.input === "object") toolCallIdToInput.set(String(data.toolCallId), data.input);
 							continue;
 						}
 						if (data.type === "tool-output-denied" && data.toolCallId) {
@@ -383,6 +385,10 @@ async function streamAgentResponse(params) {
 			const stopBlocks = [];
 			for (const { toolName, errorText } of toolErrors) stopBlocks.push(buildToolOutputErrorBlock(toolName, errorText));
 			if (summaryLabels.length > 0) stopBlocks.push(buildSummaryBreadcrumbBlock(summaryLabels));
+			if (citations.length > 0) {
+				const citationBlocks = buildCitationsBlock(citations);
+				stopBlocks.push(...citationBlocks);
+			}
 			stopBlocks.push(createContextBlock({ agentName }));
 			try {
 				await withTimeout(streamer.stop({ blocks: stopBlocks.slice(0, 50) }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.stop");
@@ -395,15 +401,6 @@ async function streamAgentResponse(params) {
 					responseLength: fullText.length
 				}, "Failed to finalize chatStream — content was already delivered");
 			}
-			if (citations.length > 0) {
-				const citationBlocks = buildCitationsBlock(citations);
-				if (citationBlocks.length > 0) await slackClient.chat.postMessage({
-					channel,
-					thread_ts: threadTs,
-					text: "📚 Sources",
-					blocks: citationBlocks
-				}).catch((e) => logger.warn({ error: e }, "Failed to post citations"));
-			}
 			if (thinkingMessageTs) try {
 				await slackClient.chat.delete({
 					channel,