@inkeep/agents-work-apps 0.0.0-dev-20260219045007 → 0.0.0-dev-20260219103848

package/dist/slack/dispatcher.d.ts

@@ -0,0 +1,16 @@
+import { SlackOutcome } from "./tracer.js";
+
+//#region src/slack/dispatcher.d.ts
+interface SlackEventDispatchResult {
+  outcome: SlackOutcome;
+  response?: Record<string, unknown>;
+}
+interface DispatchOptions {
+  registerBackgroundWork: (work: Promise<unknown>) => void;
+}
+declare function dispatchSlackEvent(eventType: string, payload: Record<string, unknown>, options: DispatchOptions, span: {
+  setAttribute: (key: string, value: string | boolean | number) => void;
+  updateName: (name: string) => void;
+}): Promise<SlackEventDispatchResult>;
+//#endregion
+export { DispatchOptions, SlackEventDispatchResult, dispatchSlackEvent };

package/dist/slack/dispatcher.js

@@ -0,0 +1,332 @@
+import { getLogger } from "../logger.js";
+import { findWorkspaceConnectionByTeamId } from "./services/nango.js";
+import { getSlackClient } from "./services/client.js";
+import { sendResponseUrlMessage } from "./services/events/utils.js";
+import { SLACK_SPAN_KEYS } from "./tracer.js";
+import { handleAppMention } from "./services/events/app-mention.js";
+import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal } from "./services/events/block-actions.js";
+import { handleFollowUpSubmission, handleModalSubmission } from "./services/events/modal-submission.js";
+import "./services/events/index.js";
+import "./services/index.js";
+import { flushTraces } from "@inkeep/agents-core";
+
+//#region src/slack/dispatcher.ts
+const logger = getLogger("slack-dispatcher");
+async function dispatchSlackEvent(eventType, payload, options, span) {
+	const { registerBackgroundWork } = options;
+	let outcome = "ignored_unknown_event";
+	if (eventType === "event_callback") {
+		const teamId = payload.team_id;
+		const event = payload.event;
+		const innerEventType = event?.type || "unknown";
+		span.setAttribute(SLACK_SPAN_KEYS.INNER_EVENT_TYPE, innerEventType);
+		if (teamId) span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
+		if (event?.channel) span.setAttribute(SLACK_SPAN_KEYS.CHANNEL_ID, event.channel);
+		if (event?.user) span.setAttribute(SLACK_SPAN_KEYS.USER_ID, event.user);
+		if (event?.bot_id || event?.subtype === "bot_message") {
+			outcome = "ignored_bot_message";
+			span.setAttribute(SLACK_SPAN_KEYS.IS_BOT_MESSAGE, true);
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			logger.info({
+				botId: event.bot_id,
+				subtype: event?.subtype,
+				teamId,
+				innerEventType
+			}, "Ignoring bot message");
+			return { outcome };
+		}
+		if (event?.type === "app_mention" && event.channel && event.user && teamId) {
+			outcome = "handled";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			const question = (event.text || "").replace(/<@[A-Z0-9]+>/g, "").trim();
+			span.setAttribute(SLACK_SPAN_KEYS.HAS_QUERY, question.length > 0);
+			if (event.thread_ts) span.setAttribute(SLACK_SPAN_KEYS.THREAD_TS, event.thread_ts);
+			if (event.ts) span.setAttribute(SLACK_SPAN_KEYS.MESSAGE_TS, event.ts);
+			logger.info({
+				userId: event.user,
+				channel: event.channel,
+				teamId,
+				hasQuery: question.length > 0
+			}, "Handling event: app_mention");
+			const dispatchedAt = Date.now();
+			registerBackgroundWork(handleAppMention({
+				slackUserId: event.user,
+				channel: event.channel,
+				text: question,
+				threadTs: event.thread_ts || event.ts || "",
+				messageTs: event.ts || "",
+				teamId,
+				dispatchedAt
+			}).catch((err) => {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				const errorStack = err instanceof Error ? err.stack : void 0;
+				logger.error({
+					errorMessage,
+					errorStack
+				}, "Failed to handle app mention (outer catch)");
+			}).finally(() => flushTraces()));
+			logger.info({
+				teamId,
+				channel: event.channel,
+				dispatchedAt
+			}, "app_mention work registered");
+		} else {
+			outcome = "ignored_unknown_event";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			logger.info({
+				innerEventType,
+				teamId
+			}, `Ignoring unhandled event_callback: ${innerEventType}`);
+		}
+	}
+	if (eventType === "block_actions" || eventType === "interactive_message") {
+		const actions = payload.actions;
+		const teamId = payload.team?.id;
+		const responseUrl = payload.response_url;
+		const triggerId = payload.trigger_id;
+		const actionIds = actions?.map((a) => a.action_id) || [];
+		if (teamId) span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
+		span.setAttribute(SLACK_SPAN_KEYS.ACTION_IDS, actionIds.join(","));
+		if (actions && teamId) {
+			let anyHandled = false;
+			for (const action of actions) {
+				if (action.action_id === "open_agent_selector_modal" && action.value && triggerId) {
+					anyHandled = true;
+					logger.info({
+						teamId,
+						actionId: action.action_id
+					}, "Handling block_action: open_agent_selector_modal");
+					registerBackgroundWork(handleOpenAgentSelectorModal({
+						triggerId,
+						actionValue: action.value,
+						teamId,
+						responseUrl: responseUrl || ""
+					}).catch(async (err) => {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						logger.error({
+							errorMessage,
+							actionId: action.action_id
+						}, "Failed to open agent selector modal");
+						if (responseUrl) await sendResponseUrlMessage(responseUrl, {
+							text: "Sorry, something went wrong while opening the agent selector. Please try again.",
+							response_type: "ephemeral"
+						}).catch((e) => logger.warn({ error: e }, "Failed to send error notification via response URL"));
+					}).finally(() => flushTraces()));
+				}
+				if (action.action_id === "modal_project_select") {
+					anyHandled = true;
+					const selectedProjectId = action.selected_option?.value;
+					const view = payload.view;
+					logger.info({
+						teamId,
+						actionId: action.action_id,
+						selectedProjectId
+					}, "Handling block_action: modal_project_select");
+					if (selectedProjectId && view?.id) registerBackgroundWork((async () => {
+						try {
+							const metadata = JSON.parse(view.private_metadata || "{}");
+							const tenantId = metadata.tenantId;
+							if (!tenantId) {
+								logger.warn({ teamId }, "No tenantId in modal metadata — skipping project update");
+								return;
+							}
+							const workspace = await findWorkspaceConnectionByTeamId(teamId);
+							if (!workspace?.botToken) {
+								logger.warn({ teamId }, "Workspace found but no botToken — skipping modal project update");
+								return;
+							}
+							const slackClient = getSlackClient(workspace.botToken);
+							const { fetchProjectsForTenant, fetchAgentsForProject } = await import("./services/events/utils.js");
+							const { buildAgentSelectorModal, buildMessageShortcutModal } = await import("./services/modals.js");
+							const projectList = await fetchProjectsForTenant(tenantId);
+							const agentList = await fetchAgentsForProject(tenantId, selectedProjectId);
+							const agentOptions = agentList.map((a) => ({
+								id: a.id,
+								name: a.name,
+								projectId: a.projectId,
+								projectName: a.projectName || a.projectId
+							}));
+							const modal = metadata.messageContext ? buildMessageShortcutModal({
+								projects: projectList,
+								agents: agentOptions,
+								metadata,
+								selectedProjectId,
+								messageContext: metadata.messageContext
+							}) : buildAgentSelectorModal({
+								projects: projectList,
+								agents: agentOptions,
+								metadata,
+								selectedProjectId
+							});
+							await slackClient.views.update({
+								view_id: view.id,
+								view: modal
+							});
+							logger.debug({
+								selectedProjectId,
+								agentCount: agentList.length
+							}, "Updated modal with agents for selected project");
+						} catch (err) {
+							logger.error({
+								err,
+								selectedProjectId
+							}, "Failed to update modal on project change");
+						} finally {
+							await flushTraces();
+						}
+					})());
+				}
+				if (action.action_id === "open_follow_up_modal" && action.value && triggerId) {
+					anyHandled = true;
+					logger.info({
+						teamId,
+						actionId: action.action_id
+					}, "Handling block_action: open_follow_up_modal");
+					registerBackgroundWork(handleOpenFollowUpModal({
+						triggerId,
+						actionValue: action.value,
+						teamId,
+						responseUrl: responseUrl || void 0
+					}).catch(async (err) => {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						logger.error({
+							errorMessage,
+							actionId: action.action_id
+						}, "Failed to open follow-up modal");
+						if (responseUrl) await sendResponseUrlMessage(responseUrl, {
+							text: "Sorry, something went wrong while opening the follow-up form. Please try again.",
+							response_type: "ephemeral"
+						}).catch((e) => logger.warn({ error: e }, "Failed to send error notification via response URL"));
+					}).finally(() => flushTraces()));
+				}
+			}
+			outcome = anyHandled ? "handled" : "ignored_no_action_match";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			if (!anyHandled) logger.info({
+				teamId,
+				actionIds,
+				eventType
+			}, "Ignoring block_actions: no matching action handlers");
+		} else {
+			outcome = "ignored_no_action_match";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			logger.info({
+				teamId,
+				eventType,
+				hasActions: Boolean(actions)
+			}, "Ignoring block_actions: missing actions or teamId");
+		}
+	}
+	if (eventType === "message_action") {
+		const callbackId = payload.callback_id;
+		span.setAttribute(SLACK_SPAN_KEYS.CALLBACK_ID, callbackId || "unknown");
+		if (callbackId === "ask_agent_shortcut") {
+			const triggerId = payload.trigger_id;
+			const teamId = payload.team?.id;
+			const channelId = payload.channel?.id;
+			const userId = payload.user?.id;
+			const message = payload.message;
+			const responseUrl = payload.response_url;
+			if (teamId) span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
+			if (channelId) span.setAttribute(SLACK_SPAN_KEYS.CHANNEL_ID, channelId);
+			if (userId) span.setAttribute(SLACK_SPAN_KEYS.USER_ID, userId);
+			if (triggerId && teamId && channelId && userId && message?.ts) {
+				outcome = "handled";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+				logger.info({
+					teamId,
+					channelId,
+					userId,
+					callbackId
+				}, "Handling message_action: ask_agent_shortcut");
+				registerBackgroundWork(handleMessageShortcut({
+					triggerId,
+					teamId,
+					channelId,
+					userId,
+					messageTs: message.ts,
+					messageText: message.text || "",
+					threadTs: message.thread_ts,
+					responseUrl
+				}).catch((err) => {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					logger.error({
+						errorMessage,
+						callbackId
+					}, "Failed to handle message shortcut");
+				}).finally(() => flushTraces()));
+			} else {
+				outcome = "ignored_unknown_event";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+				logger.info({
+					teamId,
+					channelId,
+					userId,
+					callbackId,
+					hasTriggerId: Boolean(triggerId)
+				}, "Ignoring message_action: missing required fields");
+			}
+		} else {
+			outcome = "ignored_unknown_event";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			logger.info({ callbackId }, `Ignoring unhandled message_action: ${callbackId}`);
+		}
+	}
+	if (eventType === "view_submission") {
+		const callbackId = payload.view?.callback_id;
+		span.setAttribute(SLACK_SPAN_KEYS.CALLBACK_ID, callbackId || "unknown");
+		if (callbackId === "agent_selector_modal") {
+			const view = payload.view;
+			const agentSelect = view.state?.values?.agent_select_block?.agent_select;
+			if (!agentSelect?.selected_option?.value || agentSelect.selected_option.value === "none") {
+				outcome = "validation_error";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+				logger.info({ callbackId }, "Rejecting view_submission: no agent selected");
+				return {
+					outcome,
+					response: {
+						response_action: "errors",
+						errors: { agent_select_block: "Please select an agent. If none are available, add agents to this project in the dashboard." }
+					}
+				};
+			}
+			outcome = "handled";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			logger.info({ callbackId }, "Handling view_submission: agent_selector_modal");
+			registerBackgroundWork(handleModalSubmission(view).catch((err) => {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				logger.error({
+					errorMessage,
+					callbackId
+				}, "Failed to handle modal submission");
+			}).finally(() => flushTraces()));
+			return { outcome };
+		}
+		if (callbackId === "follow_up_modal") {
+			const view = payload.view;
+			outcome = "handled";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			logger.info({ callbackId }, "Handling view_submission: follow_up_modal");
+			registerBackgroundWork(handleFollowUpSubmission(view).catch((err) => {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				logger.error({
+					errorMessage,
+					callbackId
+				}, "Failed to handle follow-up submission");
+			}).finally(() => flushTraces()));
+			return { outcome };
+		}
+		outcome = "ignored_unknown_event";
+		span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+		logger.info({ callbackId }, `Ignoring unhandled view_submission: ${callbackId}`);
+	}
+	if (eventType !== "event_callback" && eventType !== "block_actions" && eventType !== "interactive_message" && eventType !== "message_action" && eventType !== "view_submission") {
+		outcome = "ignored_unknown_event";
+		span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+		logger.info({ eventType }, `Ignoring unhandled Slack event type: ${eventType}`);
+	}
+	return { outcome };
+}
+
+//#endregion
+export { dispatchSlackEvent };

package/dist/slack/index.d.ts

@@ -1,9 +1,11 @@
+import { DispatchOptions, SlackEventDispatchResult, dispatchSlackEvent } from "./dispatcher.js";
 import { ManageAppVariables, WorkAppsVariables } from "./types.js";
 import { DefaultAgentConfig, SlackWorkspaceConnection, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./services/nango.js";
 import { getChannelAgentConfig, getWorkspaceDefaultAgent } from "./services/events/utils.js";
 import "./services/events/index.js";
 import { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.js";
 import "./routes/oauth.js";
+import { startSocketMode } from "./socket-mode.js";
 import { OpenAPIHono } from "@hono/zod-openapi";
 
 //#region src/slack/index.d.ts
@@ -15,4 +17,4 @@ declare const slackRoutes: OpenAPIHono<{
   Variables: WorkAppsVariables;
 }, {}, "/">;
 //#endregion
-export { DefaultAgentConfig, ManageAppVariables, SlackWorkspaceConnection, WorkAppsVariables, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, createSlackRoutes, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setBotTokenForTeam, setWorkspaceDefaultAgent, slackRoutes, storeWorkspaceInstallation, updateConnectionMetadata };
+export { DefaultAgentConfig, type DispatchOptions, ManageAppVariables, type SlackEventDispatchResult, SlackWorkspaceConnection, WorkAppsVariables, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, createSlackRoutes, deleteWorkspaceInstallation, dispatchSlackEvent, findWorkspaceConnectionByTeamId, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setBotTokenForTeam, setWorkspaceDefaultAgent, slackRoutes, startSocketMode, storeWorkspaceInstallation, updateConnectionMetadata };

package/dist/slack/index.js

@@ -2,8 +2,10 @@ import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConn
 import { getChannelAgentConfig, getWorkspaceDefaultAgent } from "./services/events/utils.js";
 import { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.js";
 import "./services/events/index.js";
+import { dispatchSlackEvent } from "./dispatcher.js";
 import "./routes/oauth.js";
 import routes_default from "./routes/index.js";
+import { startSocketMode } from "./socket-mode.js";
 import { OpenAPIHono } from "@hono/zod-openapi";
 
 //#region src/slack/index.ts
@@ -25,4 +27,4 @@ function createSlackRoutes() {
 const slackRoutes = createSlackRoutes();
 
 //#endregion
-export { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, createSlackRoutes, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setBotTokenForTeam, setWorkspaceDefaultAgent, slackRoutes, storeWorkspaceInstallation, updateConnectionMetadata };
+export { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, createSlackRoutes, deleteWorkspaceInstallation, dispatchSlackEvent, findWorkspaceConnectionByTeamId, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setBotTokenForTeam, setWorkspaceDefaultAgent, slackRoutes, startSocketMode, storeWorkspaceInstallation, updateConnectionMetadata };