@inkeep/agents-work-apps 0.53.2 → 0.53.4

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

@@ -77,6 +77,26 @@ declare function getSlackChannels(client: WebClient, limit?: number): Promise<{
   isPrivate: boolean;
   isShared: boolean;
 }[]>;
+/**
+ * Fetch only channels where the bot is a member using the `users.conversations` API.
+ *
+ * Compared to `getSlackChannels()` (which uses `conversations.list` and returns ALL visible channels),
+ * this function returns only channels the bot has been added to. It uses Tier 3 rate limits (50+ req/min)
+ * and supports up to 999 items per page, making it significantly more efficient for large workspaces.
+ *
+ * Use this for the Channel Defaults UI. Keep `getSlackChannels()` for other purposes (e.g., health checks).
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param limit - Maximum number of channels to return. Fetches in pages of up to 999 until the limit is reached or all channels are returned.
+ * @returns Array of channel objects with id, name, member count, and privacy status
+ */
+declare function getBotMemberChannels(client: WebClient, limit?: number): Promise<{
+  id: string | undefined;
+  name: string | undefined;
+  memberCount: number | undefined;
+  isPrivate: boolean;
+  isShared: boolean;
+}[]>;
 /**
  * Post a message to a Slack channel.
  *
@@ -121,4 +141,4 @@ declare function checkUserIsChannelMember(client: WebClient, channelId: string,
  */
 declare function revokeSlackToken(token: string): Promise<boolean>;
 //#endregion
-export { checkUserIsChannelMember, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };
+export { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };

package/dist/slack/services/client.js

@@ -146,6 +146,48 @@ async function getSlackChannels(client, limit = 200) {
 		limit
 	});
 }
+function safeNumMembers(ch) {
+	const record = ch;
+	return typeof record.num_members === "number" ? record.num_members : void 0;
+}
+/**
+* Fetch only channels where the bot is a member using the `users.conversations` API.
+*
+* Compared to `getSlackChannels()` (which uses `conversations.list` and returns ALL visible channels),
+* this function returns only channels the bot has been added to. It uses Tier 3 rate limits (50+ req/min)
+* and supports up to 999 items per page, making it significantly more efficient for large workspaces.
+*
+* Use this for the Channel Defaults UI. Keep `getSlackChannels()` for other purposes (e.g., health checks).
+*
+* @param client - Authenticated Slack WebClient
+* @param limit - Maximum number of channels to return. Fetches in pages of up to 999 until the limit is reached or all channels are returned.
+* @returns Array of channel objects with id, name, member count, and privacy status
+*/
+async function getBotMemberChannels(client, limit = 999) {
+	return paginateSlack({
+		fetchPage: (cursor) => client.users.conversations({
+			types: "public_channel,private_channel",
+			exclude_archived: true,
+			limit: Math.min(limit, 999),
+			cursor
+		}),
+		extractItems: (result) => {
+			if (!result.ok) {
+				logger.warn({ error: result.error }, "Slack API returned ok: false during bot member channel pagination");
+				return [];
+			}
+			return result.channels ? result.channels.map((ch) => ({
+				id: ch.id,
+				name: ch.name,
+				memberCount: safeNumMembers(ch),
+				isPrivate: ch.is_private ?? false,
+				isShared: ch.is_shared ?? ch.is_ext_shared ?? false
+			})) : [];
+		},
+		getNextCursor: (result) => result.response_metadata?.next_cursor || void 0,
+		limit
+	});
+}
 /**
 * Post a message to a Slack channel.
 *
@@ -257,4 +299,4 @@ async function revokeSlackToken(token) {
 }
 
 //#endregion
-export { checkUserIsChannelMember, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };
+export { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };

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

@@ -2,14 +2,15 @@ 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 { fetchAgentsForProject, fetchProjectsForTenant, generateSlackConversationId, getChannelAgentConfig } from "../events/utils.js";
 import { resolveEffectiveAgent } from "../agent-resolution.js";
 import { SlackStrings } from "../../i18n/strings.js";
-import { createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "../blocks/index.js";
+import { createAlreadyLinkedMessage, createErrorMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "../blocks/index.js";
 import { getSlackClient } from "../client.js";
+import { executeAgentPublicly } from "../events/execution.js";
 import { buildLinkPromptMessage, resolveUnlinkedUserAction } from "../link-prompt.js";
 import { buildAgentSelectorModal } from "../modals.js";
-import { deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingBySlackUser, flushTraces, getInProcessFetch, getWaitUntil, signSlackUserToken } from "@inkeep/agents-core";
+import { deleteWorkAppSlackUserMapping, findWorkAppSlackUserMapping, findWorkAppSlackUserMappingBySlackUser, flushTraces, getWaitUntil, signSlackUserToken } from "@inkeep/agents-core";
 
 //#region src/slack/services/commands/index.ts
 const DEFAULT_CLIENT_ID = "work-apps-slack";
@@ -232,117 +233,54 @@ async function handleQuestionCommand(payload, question, _dashboardUrl, tenantId,
 		response_type: "ephemeral",
 		...createErrorMessage("No default agent configured. Ask your admin to set a workspace default in the dashboard.")
 	};
-	const questionWork = executeAgentInBackground(payload, existingLink, {
-		id: resolvedAgent.agentId,
-		name: resolvedAgent.agentName || null,
-		projectId: resolvedAgent.projectId
-	}, question, userTenantId, {
+	const slackClient = getSlackClient(botToken);
+	const slackUserToken = await signSlackUserToken({
+		inkeepUserId: existingLink.inkeepUserId,
+		tenantId: userTenantId,
+		slackTeamId: payload.teamId,
+		slackUserId: payload.userId,
+		slackEnterpriseId: payload.enterpriseId,
 		slackAuthorized: resolvedAgent.grantAccessToMembers,
 		slackAuthSource: resolvedAgent.source === "none" ? void 0 : resolvedAgent.source,
 		slackChannelId: payload.channelId,
 		slackAuthorizedProjectId: resolvedAgent.projectId
-	}).catch((error) => {
+	});
+	const now = Date.now();
+	const messageTs = `${Math.floor(now / 1e3)}.${String(now % 1e3).padStart(3, "0")}000`;
+	const conversationId = generateSlackConversationId({
+		teamId: payload.teamId,
+		messageTs,
+		agentId: resolvedAgent.agentId
+	});
+	const questionWork = executeAgentPublicly({
+		slackClient,
+		channel: payload.channelId,
+		slackUserId: payload.userId,
+		teamId: payload.teamId,
+		jwtToken: slackUserToken,
+		projectId: resolvedAgent.projectId,
+		agentId: resolvedAgent.agentId,
+		agentName: resolvedAgent.agentName || resolvedAgent.agentId,
+		question,
+		conversationId
+	}).catch(async (error) => {
 		logger.error({ error }, "Background execution promise rejected");
-	}).finally(() => flushTraces());
-	const waitUntil = await getWaitUntil();
-	if (waitUntil) waitUntil(questionWork);
-	return {};
-}
-async function executeAgentInBackground(payload, existingLink, targetAgent, question, tenantId, channelAuth) {
-	try {
-		const slackUserToken = await signSlackUserToken({
-			inkeepUserId: existingLink.inkeepUserId,
-			tenantId,
-			slackTeamId: payload.teamId,
-			slackUserId: payload.userId,
-			slackEnterpriseId: payload.enterpriseId,
-			...channelAuth
-		});
-		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 getInProcessFetch()(`${apiBaseUrl}/run/api/chat`, {
+		if (payload.responseUrl) try {
+			await fetch(payload.responseUrl, {
 				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${slackUserToken}`,
-					"x-inkeep-project-id": targetAgent.projectId,
-					"x-inkeep-agent-id": targetAgent.id
-				},
+				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify({
-					messages: [{
-						role: "user",
-						content: question
-					}],
-					stream: false
-				}),
-				signal: controller.signal
-			});
-		} catch (error) {
-			clearTimeout(timeout);
-			if (error.name === "AbortError") {
-				logger.warn({
-					teamId: payload.teamId,
-					timeoutMs: 3e4
-				}, "Background agent execution timed out");
-				await sendResponseUrlMessage(payload.responseUrl, {
 					response_type: "ephemeral",
-					text: "Request timed out. Please try again."
-				});
-				return;
-			}
-			throw error;
-		} finally {
-			clearTimeout(timeout);
-		}
-		if (!response.ok) {
-			const errorText = await response.text();
-			logger.error({
-				status: response.status,
-				error: errorText,
-				agentId: targetAgent.id,
-				projectId: targetAgent.projectId
-			}, "Run API call failed");
-			const apiMessage = extractApiErrorMessage(errorText);
-			const errorMessage = apiMessage ? `*Error.* ${apiMessage}` : `Failed to run agent: ${response.status} ${response.statusText}`;
-			await sendResponseUrlMessage(payload.responseUrl, {
-				response_type: "ephemeral",
-				text: errorMessage
-			});
-		} else {
-			const result = await response.json();
-			const assistantMessage = result.choices?.[0]?.message?.content || result.message?.content || "No response received";
-			logger.info({
-				slackUserId: payload.userId,
-				agentId: targetAgent.id,
-				projectId: targetAgent.projectId,
-				tenantId
-			}, "Agent execution completed via Slack");
-			const contextBlock = createContextBlock({ agentName: targetAgent.name || targetAgent.id });
-			await sendResponseUrlMessage(payload.responseUrl, {
-				response_type: "in_channel",
-				text: assistantMessage,
-				blocks: [{
-					type: "section",
-					text: {
-						type: "mrkdwn",
-						text: assistantMessage
-					}
-				}, contextBlock]
+					text: SlackStrings.errors.generic
+				})
 			});
+		} catch (e) {
+			logger.warn({ e }, "Failed to send error via response_url");
 		}
-	} catch (error) {
-		logger.error({
-			error,
-			slackUserId: payload.userId
-		}, "Background agent execution failed");
-		await sendResponseUrlMessage(payload.responseUrl, {
-			response_type: "ephemeral",
-			text: "An error occurred while running the agent. Please try again."
-		});
-	}
+	}).finally(() => flushTraces());
+	const waitUntil = await getWaitUntil();
+	if (waitUntil) waitUntil(questionWork);
+	return {};
 }
 async function handleCommand(payload) {
 	const text = payload.text.trim();

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

@@ -5,9 +5,9 @@ import { checkIfBotThread, classifyError, findCachedUserMapping, formatAttachmen
 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 { executeAgentPublicly } from "./execution.js";
+import { buildLinkPromptMessage, resolveUnlinkedUserAction } from "../link-prompt.js";
 import { signSlackUserToken } from "@inkeep/agents-core";
 
 //#region src/slack/services/events/app-mention.ts
@@ -72,7 +72,6 @@ async function handleAppMention(params) {
 		const replyThreadTs = threadTs || messageTs;
 		const isInThread = Boolean(threadTs && threadTs !== messageTs);
 		const hasQuery = Boolean(text && text.trim().length > 0);
-		let thinkingMessageTs;
 		try {
 			const { result: [agentConfig, existingLink] } = await timedOp(Promise.all([resolveEffectiveAgent({
 				tenantId,
@@ -205,16 +204,9 @@ async function handleAppMention(params) {
 					slackChannelId: channel,
 					slackAuthorizedProjectId: agentConfig?.projectId
 				});
-				thinkingMessageTs = (await slackClient.chat.postMessage({
-					channel,
-					thread_ts: threadTs,
-					text: SlackStrings.status.readingThread(agentDisplayName)
-				})).ts || void 0;
 				const conversationId$1 = generateSlackConversationId({
 					teamId,
-					threadTs,
-					channel,
-					isDM: false,
+					messageTs,
 					agentId: agentConfig.agentId
 				});
 				span.setAttribute(SLACK_SPAN_KEYS.CONVERSATION_ID, conversationId$1);
@@ -235,18 +227,17 @@ Respond naturally as if you're joining the conversation to help.`;
 					agentId: agentConfig.agentId,
 					conversationId: conversationId$1
 				}, "Auto-executing agent with thread context");
-				await streamAgentResponse({
+				await executeAgentPublicly({
 					slackClient,
 					channel,
 					threadTs,
-					thinkingMessageTs: thinkingMessageTs || "",
 					slackUserId,
 					teamId,
 					jwtToken: slackUserToken$1,
 					projectId: agentConfig.projectId,
 					agentId: agentConfig.agentId,
-					question: threadQuery,
 					agentName: agentDisplayName,
+					question: threadQuery,
 					conversationId: conversationId$1
 				});
 				span.end();
@@ -292,16 +283,9 @@ Respond naturally as if you're joining the conversation to help.`;
 				slackChannelId: channel,
 				slackAuthorizedProjectId: agentConfig?.projectId
 			});
-			thinkingMessageTs = (await slackClient.chat.postMessage({
-				channel,
-				thread_ts: replyThreadTs,
-				text: SlackStrings.status.thinking(agentDisplayName)
-			})).ts || void 0;
 			const conversationId = generateSlackConversationId({
 				teamId,
-				threadTs: replyThreadTs,
-				channel,
-				isDM: false,
+				messageTs,
 				agentId: agentConfig.agentId
 			});
 			span.setAttribute(SLACK_SPAN_KEYS.CONVERSATION_ID, conversationId);
@@ -313,18 +297,17 @@ Respond naturally as if you're joining the conversation to help.`;
 				totalPreExecMs,
 				dispatchDelayMs
 			}, "Executing agent");
-			await streamAgentResponse({
+			await executeAgentPublicly({
 				slackClient,
 				channel,
 				threadTs: replyThreadTs,
-				thinkingMessageTs: thinkingMessageTs || "",
 				slackUserId,
 				teamId,
 				jwtToken: slackUserToken,
 				projectId: agentConfig.projectId,
 				agentId: agentConfig.agentId,
-				question: queryText,
 				agentName: agentDisplayName,
+				question: queryText,
 				conversationId
 			});
 			span.end();
@@ -336,12 +319,6 @@ Respond naturally as if you're joining the conversation to help.`;
 				teamId
 			}, "Failed in app mention handler");
 			if (error instanceof Error) setSpanWithError(span, error);
-			if (thinkingMessageTs) try {
-				await slackClient.chat.delete({
-					channel,
-					ts: thinkingMessageTs
-				});
-			} catch {}
 			const userMessage = getUserFriendlyErrorMessage(classifyError(error));
 			try {
 				await slackClient.chat.postEphemeral({

package/dist/slack/services/events/block-actions.d.ts

@@ -23,16 +23,6 @@ declare function handleOpenAgentSelectorModal(params: {
   teamId: string;
   responseUrl: string;
 }): Promise<void>;
-/**
- * Handle "Follow Up" button click.
- * Opens a prompt-only modal that carries the conversationId for multi-turn context.
- */
-declare function handleOpenFollowUpModal(params: {
-  triggerId: string;
-  actionValue: string;
-  teamId: string;
-  responseUrl?: string;
-}): Promise<void>;
 /**
  * Handle message shortcut (context menu action on a message)
  * Opens a modal with the message content pre-filled as context
@@ -48,4 +38,4 @@ declare function handleMessageShortcut(params: {
   responseUrl?: string;
 }): Promise<void>;
 //#endregion
-export { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval };
+export { handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval };

package/dist/slack/services/events/block-actions.js

@@ -5,8 +5,8 @@ import { fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, g
 import { SlackStrings } from "../../i18n/strings.js";
 import { ToolApprovalButtonValueSchema, buildToolApprovalDoneBlocks } from "../blocks/index.js";
 import { getSlackClient } from "../client.js";
-import { buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "../modals.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
+import { buildAgentSelectorModal, buildMessageShortcutModal } from "../modals.js";
 import { getInProcessFetch, signSlackUserToken } from "@inkeep/agents-core";
 
 //#region src/slack/services/events/block-actions.ts
@@ -36,11 +36,12 @@ async function handleToolApproval(params) {
 			}
 			const tenantId = workspaceConnection.tenantId;
 			const slackClient = getSlackClient(workspaceConnection.botToken);
+			const approvalThreadParam = buttonValue.threadTs ? { thread_ts: buttonValue.threadTs } : {};
 			if (slackUserId !== buttonValue.slackUserId) {
 				await slackClient.chat.postEphemeral({
 					channel: buttonValue.channel,
 					user: slackUserId,
-					thread_ts: buttonValue.threadTs,
+					...approvalThreadParam,
 					text: "Only the user who started this conversation can approve or deny this action."
 				}).catch((e) => logger.warn({ error: e }, "Failed to send ownership error notification"));
 				span.end();
@@ -51,7 +52,7 @@ async function handleToolApproval(params) {
 				await slackClient.chat.postEphemeral({
 					channel: buttonValue.channel,
 					user: slackUserId,
-					thread_ts: buttonValue.threadTs,
+					...approvalThreadParam,
 					text: "You need to link your Inkeep account first. Use `/inkeep link`."
 				}).catch((e) => logger.warn({ error: e }, "Failed to send not-linked notification"));
 				span.end();
@@ -99,7 +100,7 @@ async function handleToolApproval(params) {
 				await slackClient.chat.postEphemeral({
 					channel: buttonValue.channel,
 					user: slackUserId,
-					thread_ts: buttonValue.threadTs,
+					...approvalThreadParam,
 					text: `Failed to ${approved ? "approve" : "deny"} \`${toolName}\`. Please try again.`
 				}).catch((e) => logger.warn({ error: e }, "Failed to send approval error notification"));
 				span.end();
@@ -238,50 +239,6 @@ async function handleOpenAgentSelectorModal(params) {
 	});
 }
 /**
-* Handle "Follow Up" button click.
-* Opens a prompt-only modal that carries the conversationId for multi-turn context.
-*/
-async function handleOpenFollowUpModal(params) {
-	return tracer.startActiveSpan(SLACK_SPAN_NAMES.OPEN_FOLLOW_UP_MODAL, async (span) => {
-		const { triggerId, actionValue, teamId, responseUrl } = params;
-		span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
-		try {
-			const metadata = JSON.parse(actionValue);
-			span.setAttribute(SLACK_SPAN_KEYS.CONVERSATION_ID, metadata.conversationId || "");
-			span.setAttribute(SLACK_SPAN_KEYS.AGENT_ID, metadata.agentId || "");
-			const workspaceConnection = await findWorkspaceConnectionByTeamId(teamId);
-			if (!workspaceConnection?.botToken) {
-				logger.error({ teamId }, "No bot token for follow-up modal");
-				span.end();
-				return;
-			}
-			const slackClient = getSlackClient(workspaceConnection.botToken);
-			const modal = buildFollowUpModal(metadata);
-			await slackClient.views.open({
-				trigger_id: triggerId,
-				view: modal
-			});
-			logger.info({
-				teamId,
-				conversationId: metadata.conversationId,
-				agentId: metadata.agentId
-			}, "Opened follow-up modal");
-			span.end();
-		} catch (error) {
-			if (error instanceof Error) setSpanWithError(span, error);
-			logger.error({
-				error,
-				teamId
-			}, "Failed to open follow-up modal");
-			if (responseUrl) await sendResponseUrlMessage(responseUrl, {
-				text: "Failed to open follow-up dialog. Please try again.",
-				response_type: "ephemeral"
-			}).catch((e) => logger.warn({ error: e }, "Failed to send follow-up error notification"));
-			span.end();
-		}
-	});
-}
-/**
 * Handle message shortcut (context menu action on a message)
 * Opens a modal with the message content pre-filled as context
 */
@@ -386,4 +343,4 @@ async function handleMessageShortcut(params) {
 }
 
 //#endregion
-export { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval };
+export { handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval };

package/dist/slack/services/events/direct-message.d.ts

@@ -0,0 +1,11 @@
+//#region src/slack/services/events/direct-message.d.ts
+declare function handleDirectMessage(params: {
+  slackUserId: string;
+  channel: string;
+  text: string;
+  threadTs?: string;
+  messageTs: string;
+  teamId: string;
+}): Promise<void>;
+//#endregion
+export { handleDirectMessage };

package/dist/slack/services/events/direct-message.js

@@ -0,0 +1,148 @@
+import { getLogger } from "../../../logger.js";
+import { findWorkspaceConnectionByTeamId } from "../nango.js";
+import { classifyError, findCachedUserMapping, generateSlackConversationId, getThreadContext, getUserFriendlyErrorMessage } from "./utils.js";
+import { SlackStrings } from "../../i18n/strings.js";
+import { getSlackClient } from "../client.js";
+import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
+import { executeAgentPublicly } from "./execution.js";
+import { buildLinkPromptMessage, resolveUnlinkedUserAction } from "../link-prompt.js";
+import { signSlackUserToken } from "@inkeep/agents-core";
+
+//#region src/slack/services/events/direct-message.ts
+const logger = getLogger("slack-direct-message");
+async function handleDirectMessage(params) {
+	return tracer.startActiveSpan(SLACK_SPAN_NAMES.DIRECT_MESSAGE, async (span) => {
+		const { slackUserId, channel, text, threadTs, messageTs, teamId } = params;
+		span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
+		span.setAttribute(SLACK_SPAN_KEYS.CHANNEL_ID, channel);
+		span.setAttribute(SLACK_SPAN_KEYS.USER_ID, slackUserId);
+		span.setAttribute(SLACK_SPAN_KEYS.MESSAGE_TS, messageTs);
+		if (threadTs) span.setAttribute(SLACK_SPAN_KEYS.THREAD_TS, threadTs);
+		logger.info({
+			slackUserId,
+			channel,
+			teamId
+		}, "Handling direct message");
+		const workspaceConnection = await findWorkspaceConnectionByTeamId(teamId);
+		if (!workspaceConnection?.botToken) {
+			logger.error({ teamId }, "No bot token available — cannot respond to DM");
+			span.end();
+			return;
+		}
+		const { botToken, tenantId } = workspaceConnection;
+		if (!tenantId) {
+			logger.error({ teamId }, "Workspace connection has no tenantId");
+			span.end();
+			return;
+		}
+		span.setAttribute(SLACK_SPAN_KEYS.TENANT_ID, tenantId);
+		const slackClient = getSlackClient(botToken);
+		const replyThreadTs = threadTs || messageTs;
+		const isInThread = Boolean(threadTs && threadTs !== messageTs);
+		try {
+			const defaultAgent = workspaceConnection.defaultAgent;
+			if (!defaultAgent?.agentId || !defaultAgent?.projectId) {
+				logger.info({ teamId }, "No default agent configured — sending hint in DM");
+				await slackClient.chat.postMessage({
+					channel,
+					thread_ts: replyThreadTs,
+					text: SlackStrings.errors.noAgentConfigured
+				});
+				span.end();
+				return;
+			}
+			span.setAttribute(SLACK_SPAN_KEYS.AGENT_ID, defaultAgent.agentId);
+			span.setAttribute(SLACK_SPAN_KEYS.PROJECT_ID, defaultAgent.projectId);
+			const agentDisplayName = defaultAgent.agentName || defaultAgent.agentId;
+			const existingLink = await findCachedUserMapping(tenantId, slackUserId, teamId);
+			if (!existingLink) {
+				logger.info({
+					slackUserId,
+					teamId
+				}, "User not linked — sending link prompt in DM");
+				const message = buildLinkPromptMessage(await resolveUnlinkedUserAction({
+					tenantId,
+					teamId,
+					slackUserId,
+					botToken,
+					intent: {
+						entryPoint: "dm",
+						question: text.slice(0, 2e3),
+						channelId: channel,
+						messageTs,
+						agentId: defaultAgent.agentId,
+						projectId: defaultAgent.projectId
+					}
+				}));
+				await slackClient.chat.postMessage({
+					channel,
+					thread_ts: replyThreadTs,
+					text: SlackStrings.linkPrompt.intro,
+					blocks: message.blocks
+				});
+				span.end();
+				return;
+			}
+			let queryText = text;
+			if (isInThread && threadTs) {
+				const contextMessages = await getThreadContext(slackClient, channel, threadTs);
+				if (contextMessages) queryText = text ? `The following is thread context from a DM conversation:\n\n<slack_thread_context>\n${contextMessages}\n</slack_thread_context>\n\nUser message: ${text}` : contextMessages;
+			}
+			const slackUserToken = await signSlackUserToken({
+				inkeepUserId: existingLink.inkeepUserId,
+				tenantId,
+				slackTeamId: teamId,
+				slackUserId,
+				slackAuthorized: false
+			});
+			const conversationId = generateSlackConversationId({
+				teamId,
+				messageTs,
+				agentId: defaultAgent.agentId,
+				isDM: true
+			});
+			span.setAttribute(SLACK_SPAN_KEYS.CONVERSATION_ID, conversationId);
+			logger.info({
+				agentId: defaultAgent.agentId,
+				projectId: defaultAgent.projectId,
+				conversationId
+			}, "Executing agent for DM");
+			await executeAgentPublicly({
+				slackClient,
+				channel,
+				threadTs: replyThreadTs,
+				slackUserId,
+				teamId,
+				jwtToken: slackUserToken,
+				projectId: defaultAgent.projectId,
+				agentId: defaultAgent.agentId,
+				agentName: agentDisplayName,
+				question: queryText,
+				conversationId
+			});
+			span.end();
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			logger.error({
+				errorMessage: errorMsg,
+				channel,
+				teamId
+			}, "Failed in DM handler");
+			if (error instanceof Error) setSpanWithError(span, error);
+			const userMessage = getUserFriendlyErrorMessage(classifyError(error));
+			try {
+				await slackClient.chat.postMessage({
+					channel,
+					thread_ts: replyThreadTs,
+					text: userMessage
+				});
+			} catch (postError) {
+				logger.error({ error: postError }, "Failed to post DM error message");
+			}
+			span.end();
+		}
+	});
+}
+
+//#endregion
+export { handleDirectMessage };

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

@@ -0,0 +1,20 @@
+import { getSlackClient } from "../client.js";
+import { StreamResult } from "./streaming.js";
+
+//#region src/slack/services/events/execution.d.ts
+interface PublicExecutionParams {
+  slackClient: ReturnType<typeof getSlackClient>;
+  channel: string;
+  threadTs?: string;
+  slackUserId: string;
+  teamId: string;
+  jwtToken: string;
+  projectId: string;
+  agentId: string;
+  agentName: string;
+  question: string;
+  conversationId: string;
+}
+declare function executeAgentPublicly(params: PublicExecutionParams): Promise<StreamResult>;
+//#endregion
+export { PublicExecutionParams, executeAgentPublicly };