@inkeep/agents-work-apps 0.0.0-dev-20260212214459 → 0.0.0-dev-20260213074206

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_types0 from "hono/types";
+import * as hono_types3 from "hono/types";
 
 //#region src/github/index.d.ts
-declare function createGithubRoutes(): Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
-declare const githubRoutes: Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
+declare function createGithubRoutes(): Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+declare const githubRoutes: Hono<hono_types3.BlankEnv, hono_types3.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_types3 from "hono/types";
+import * as hono_types7 from "hono/types";
 
 //#region src/github/mcp/index.d.ts
 declare const app: Hono<{
   Variables: {
     toolId: string;
   };
-}, hono_types3.BlankSchema, "/">;
+}, hono_types7.BlankSchema, "/">;
 //#endregion
 export { app as default };

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import * as hono_types8 from "hono/types";
+import * as hono_types1 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_types8.BlankEnv, hono_types8.BlankSchema, "/">;
+declare const app: Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
 //#endregion
 export { WebhookVerificationResult, app as default, verifyWebhookSignature };

package/dist/slack/routes/events.js

@@ -5,6 +5,7 @@ import { findWorkspaceConnectionByTeamId, getSlackIntegrationId, getSlackNango,
 import { getSlackClient, getSlackUserInfo } from "../services/client.js";
 import { sendResponseUrlMessage } from "../services/events/utils.js";
 import { handleCommand } from "../services/commands/index.js";
+import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, tracer } 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";
@@ -13,6 +14,7 @@ import { parseSlackCommandBody, parseSlackEventBody, verifySlackRequest } from "
 import "../services/index.js";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import { deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackWorkspaceByNangoConnectionId } from "@inkeep/agents-core";
+import { SpanStatusCode } from "@opentelemetry/api";
 
 //#region src/slack/routes/events.ts
 /**
@@ -61,217 +63,364 @@ app.post("/commands", async (c) => {
 	return c.json(response);
 });
 app.post("/events", async (c) => {
-	const contentType = c.req.header("content-type") || "";
-	const body = await c.req.text();
-	const timestamp = c.req.header("x-slack-request-timestamp") || "";
-	const signature = c.req.header("x-slack-signature") || "";
-	let eventBody;
-	try {
-		eventBody = parseSlackEventBody(body, contentType);
-	} catch (error) {
-		logger.error({
-			error,
-			contentType,
-			bodyPreview: body.slice(0, 200)
-		}, "Failed to parse Slack event body");
-		return c.json({ error: "Invalid payload" }, 400);
-	}
-	logger.debug({ eventType: eventBody.type }, "Slack event received");
-	const eventType = eventBody.type;
-	if (!env.SLACK_SIGNING_SECRET) {
-		logger.error({}, "SLACK_SIGNING_SECRET not configured - rejecting request");
-		return c.json({ error: "Server configuration error" }, 500);
-	}
-	if (!verifySlackRequest(env.SLACK_SIGNING_SECRET, body, timestamp, signature)) {
-		logger.error({}, "Invalid Slack request signature");
-		return c.json({ error: "Invalid request signature" }, 401);
-	}
-	if (eventType === "url_verification") {
-		logger.info({}, "Responding to Slack URL verification challenge");
-		return c.text(String(eventBody.challenge));
-	}
-	if (eventType === "event_callback") {
-		const teamId = eventBody.team_id;
-		const event = eventBody.event;
-		if (event?.bot_id || event?.subtype === "bot_message") {
-			logger.debug({ botId: event.bot_id }, "Ignoring bot message");
-			return c.json({ ok: true });
-		}
-		logger.debug({
-			eventType: event?.type,
-			teamId
-		}, "Slack event callback");
-		if (event?.type === "app_mention" && event.channel && event.user && teamId) {
-			const question = (event.text || "").replace(/<@[A-Z0-9]+>/g, "").trim();
-			logger.info({
-				userId: event.user,
-				channel: event.channel,
-				teamId
-			}, "Bot was mentioned");
-			handleAppMention({
-				slackUserId: event.user,
-				channel: event.channel,
-				text: question,
-				threadTs: event.thread_ts || event.ts || "",
-				messageTs: event.ts || "",
-				teamId
-			}).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)");
-			});
-		}
-	}
-	if (eventType === "block_actions" || eventType === "interactive_message") {
-		logger.debug({ eventType }, "Slack interactive event received");
-		const actions = eventBody.actions;
-		const teamId = eventBody.team?.id;
-		const responseUrl = eventBody.response_url;
-		const triggerId = eventBody.trigger_id;
-		if (actions && teamId) for (const action of actions) {
-			if (action.action_id === "open_agent_selector_modal" && action.value && triggerId) handleOpenAgentSelectorModal({
-				triggerId,
-				actionValue: action.value,
-				teamId,
-				responseUrl: responseUrl || ""
-			}).catch(async (err) => {
-				const errorMessage = err instanceof Error ? err.message : String(err);
+	return tracer.startActiveSpan(SLACK_SPAN_NAMES.WEBHOOK, async (span) => {
+		let outcome = "ignored_unknown_event";
+		try {
+			const contentType = c.req.header("content-type") || "";
+			const body = await c.req.text();
+			const timestamp = c.req.header("x-slack-request-timestamp") || "";
+			const signature = c.req.header("x-slack-signature") || "";
+			let eventBody;
+			try {
+				eventBody = parseSlackEventBody(body, contentType);
+			} catch (error) {
+				outcome = "validation_error";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
 				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"));
-			});
-			if (action.action_id === "modal_project_select") {
-				const selectedProjectId = action.selected_option?.value;
-				const view = eventBody.view;
-				if (selectedProjectId && view?.id) (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;
+					error,
+					contentType,
+					bodyPreview: body.slice(0, 200)
+				}, "Failed to parse Slack event body");
+				span.end();
+				return c.json({ error: "Invalid payload" }, 400);
+			}
+			const eventType = eventBody.type;
+			span.setAttribute(SLACK_SPAN_KEYS.EVENT_TYPE, eventType || "unknown");
+			span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} ${eventType || "unknown"}`);
+			if (!env.SLACK_SIGNING_SECRET) {
+				outcome = "error";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+				logger.error({}, "SLACK_SIGNING_SECRET not configured - rejecting request");
+				span.end();
+				return c.json({ error: "Server configuration error" }, 500);
+			}
+			if (!verifySlackRequest(env.SLACK_SIGNING_SECRET, body, timestamp, signature)) {
+				outcome = "signature_invalid";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+				logger.error({ eventType }, "Invalid Slack request signature");
+				span.end();
+				return c.json({ error: "Invalid request signature" }, 401);
+			}
+			if (eventType === "url_verification") {
+				outcome = "url_verification";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+				logger.info({}, "Responding to Slack URL verification challenge");
+				span.end();
+				return c.text(String(eventBody.challenge));
+			}
+			if (eventType === "event_callback") {
+				const teamId = eventBody.team_id;
+				const event = eventBody.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);
+				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} event_callback.${innerEventType}`);
+				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");
+					span.end();
+					return c.json({ ok: true });
+				}
+				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");
+					handleAppMention({
+						slackUserId: event.user,
+						channel: event.channel,
+						text: question,
+						threadTs: event.thread_ts || event.ts || "",
+						messageTs: event.ts || "",
+						teamId
+					}).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)");
+					});
+				} 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 = eventBody.actions;
+				const teamId = eventBody.team?.id;
+				const responseUrl = eventBody.response_url;
+				const triggerId = eventBody.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(","));
+				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} ${eventType} [${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");
+							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"));
+							});
 						}
-						const workspace = await findWorkspaceConnectionByTeamId(teamId);
-						if (!workspace?.botToken) 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
+						if (action.action_id === "modal_project_select") {
+							anyHandled = true;
+							const selectedProjectId = action.selected_option?.value;
+							const view = eventBody.view;
+							logger.info({
+								teamId,
+								actionId: action.action_id,
+								selectedProjectId
+							}, "Handling block_action: modal_project_select");
+							if (selectedProjectId && view?.id) (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) 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");
+								}
+							})();
+						}
+						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");
+							handleOpenFollowUpModal({
+								triggerId,
+								actionValue: action.value,
+								teamId,
+								responseUrl: responseUrl || void 0
+							}).catch((err) => {
+								const errorMessage = err instanceof Error ? err.message : String(err);
+								logger.error({
+									errorMessage,
+									actionId: action.action_id
+								}, "Failed to open follow-up modal");
+							});
+						}
+					}
+					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 = eventBody.callback_id;
+				span.setAttribute(SLACK_SPAN_KEYS.CALLBACK_ID, callbackId || "unknown");
+				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} message_action.${callbackId || "unknown"}`);
+				if (callbackId === "ask_agent_shortcut") {
+					const triggerId = eventBody.trigger_id;
+					const teamId = eventBody.team?.id;
+					const channelId = eventBody.channel?.id;
+					const userId = eventBody.user?.id;
+					const message = eventBody.message;
+					const responseUrl = eventBody.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");
+						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");
 						});
-						await slackClient.views.update({
-							view_id: view.id,
-							view: modal
+					} 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 = eventBody.view?.callback_id;
+				span.setAttribute(SLACK_SPAN_KEYS.CALLBACK_ID, callbackId || "unknown");
+				span.updateName(`${SLACK_SPAN_NAMES.WEBHOOK} view_submission.${callbackId || "unknown"}`);
+				if (callbackId === "agent_selector_modal") {
+					const view = eventBody.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");
+						span.end();
+						return c.json({
+							response_action: "errors",
+							errors: { agent_select_block: "Please select an agent. If none are available, add agents to this project in the dashboard." }
 						});
-						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");
 					}
-				})();
+					outcome = "handled";
+					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+					logger.info({ callbackId }, "Handling view_submission: agent_selector_modal");
+					handleModalSubmission(view).catch((err) => {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						logger.error({
+							errorMessage,
+							callbackId
+						}, "Failed to handle modal submission");
+					});
+					span.end();
+					return new Response(null, { status: 200 });
+				}
+				if (callbackId === "follow_up_modal") {
+					const view = eventBody.view;
+					outcome = "handled";
+					span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+					logger.info({ callbackId }, "Handling view_submission: follow_up_modal");
+					handleFollowUpSubmission(view).catch((err) => {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						logger.error({
+							errorMessage,
+							callbackId
+						}, "Failed to handle follow-up submission");
+					});
+					span.end();
+					return new Response(null, { status: 200 });
+				}
+				outcome = "ignored_unknown_event";
+				span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+				logger.info({ callbackId }, `Ignoring unhandled view_submission: ${callbackId}`);
 			}
-			if (action.action_id === "open_follow_up_modal" && action.value && triggerId) handleOpenFollowUpModal({
-				triggerId,
-				actionValue: action.value,
-				teamId,
-				responseUrl: responseUrl || void 0
-			}).catch((err) => {
-				const errorMessage = err instanceof Error ? err.message : String(err);
-				logger.error({
-					errorMessage,
-					actionId: action.action_id
-				}, "Failed to open follow-up modal");
-			});
-		}
-	}
-	if (eventType === "message_action") {
-		const callbackId = eventBody.callback_id;
-		if (callbackId === "ask_agent_shortcut") {
-			const triggerId = eventBody.trigger_id;
-			const teamId = eventBody.team?.id;
-			const channelId = eventBody.channel?.id;
-			const userId = eventBody.user?.id;
-			const message = eventBody.message;
-			const responseUrl = eventBody.response_url;
-			if (triggerId && teamId && channelId && userId && message?.ts) 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");
-			});
-		}
-	}
-	if (eventType === "view_submission") {
-		const callbackId = eventBody.view?.callback_id;
-		if (callbackId === "agent_selector_modal") {
-			const view = eventBody.view;
-			const agentSelect = view.state?.values?.agent_select_block?.agent_select;
-			if (!agentSelect?.selected_option?.value || agentSelect.selected_option.value === "none") return c.json({
-				response_action: "errors",
-				errors: { agent_select_block: "Please select an agent. If none are available, add agents to this project in the dashboard." }
-			});
-			handleModalSubmission(view).catch((err) => {
-				const errorMessage = err instanceof Error ? err.message : String(err);
-				logger.error({
-					errorMessage,
-					callbackId
-				}, "Failed to handle modal submission");
-			});
-			return new Response(null, { status: 200 });
-		}
-		if (callbackId === "follow_up_modal") {
-			const view = eventBody.view;
-			handleFollowUpSubmission(view).catch((err) => {
-				const errorMessage = err instanceof Error ? err.message : String(err);
-				logger.error({
-					errorMessage,
-					callbackId
-				}, "Failed to handle follow-up submission");
+			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}`);
+			}
+			span.end();
+			return c.json({ ok: true });
+		} catch (error) {
+			outcome = "error";
+			span.setAttribute(SLACK_SPAN_KEYS.OUTCOME, outcome);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
 			});
-			return new Response(null, { status: 200 });
+			if (error instanceof Error) span.recordException(error);
+			span.end();
+			throw error;
 		}
-	}
-	return c.json({ ok: true });
+	});
 });
 app.post("/nango-webhook", async (c) => {
 	const body = await c.req.text();