@inkeep/agents-work-apps 0.53.1 → 0.53.3

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

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

@@ -0,0 +1,46 @@
+import { getLogger } from "../../../logger.js";
+import { SlackStrings } from "../../i18n/strings.js";
+import { streamAgentResponse } from "./streaming.js";
+
+//#region src/slack/services/events/execution.ts
+const logger = getLogger("slack-execution");
+async function executeAgentPublicly(params) {
+	const { slackClient, channel, threadTs, agentName } = params;
+	let thinkingMessageTs = "";
+	try {
+		thinkingMessageTs = (await slackClient.chat.postMessage({
+			channel,
+			...threadTs ? { thread_ts: threadTs } : {},
+			text: SlackStrings.status.thinking(agentName)
+		})).ts || "";
+	} catch (error) {
+		logger.warn({
+			error,
+			channel
+		}, "Failed to post thinking acknowledgment - proceeding anyway");
+	}
+	const effectiveThreadTs = threadTs || thinkingMessageTs || void 0;
+	logger.info({
+		channel,
+		threadTs: effectiveThreadTs,
+		agentId: params.agentId,
+		conversationId: params.conversationId
+	}, "Starting stream");
+	return streamAgentResponse({
+		slackClient: params.slackClient,
+		channel,
+		threadTs: effectiveThreadTs,
+		thinkingMessageTs,
+		slackUserId: params.slackUserId,
+		teamId: params.teamId,
+		jwtToken: params.jwtToken,
+		projectId: params.projectId,
+		agentId: params.agentId,
+		question: params.question,
+		agentName,
+		conversationId: params.conversationId
+	});
+}
+
+//#endregion
+export { executeAgentPublicly };

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

@@ -1,6 +1,8 @@
 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 { handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval } from "./block-actions.js";
+import { handleDirectMessage } from "./direct-message.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 };
+import { PublicExecutionParams, executeAgentPublicly } from "./execution.js";
+import { handleModalSubmission } from "./modal-submission.js";
+export { type InlineSelectorMetadata, type PublicExecutionParams, SlackErrorType, type StreamResult, checkIfBotThread, classifyError, executeAgentPublicly, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, handleAppMention, handleDirectMessage, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleToolApproval, markdownToMrkdwn, sendResponseUrlMessage, streamAgentResponse };

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

@@ -1,7 +1,9 @@
 import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./utils.js";
 import { streamAgentResponse } from "./streaming.js";
+import { executeAgentPublicly } from "./execution.js";
 import { handleAppMention } from "./app-mention.js";
-import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval } from "./block-actions.js";
-import { handleFollowUpSubmission, handleModalSubmission } from "./modal-submission.js";
+import { handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval } from "./block-actions.js";
+import { handleDirectMessage } from "./direct-message.js";
+import { handleModalSubmission } from "./modal-submission.js";
 
-export { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, handleAppMention, handleFollowUpSubmission, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval, markdownToMrkdwn, sendResponseUrlMessage, streamAgentResponse };
+export { SlackErrorType, checkIfBotThread, classifyError, executeAgentPublicly, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, handleAppMention, handleDirectMessage, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleToolApproval, markdownToMrkdwn, sendResponseUrlMessage, streamAgentResponse };

package/dist/slack/services/events/modal-submission.d.ts

@@ -1,14 +1,4 @@
 //#region src/slack/services/events/modal-submission.d.ts
-/**
- * Handler for Slack modal submission events
- *
- * Handles both initial agent selector modal and follow-up modal submissions.
- * All responses are private (ephemeral) with a Follow Up button for multi-turn conversations.
- */
-/**
- * Handle initial agent selector modal submission.
- * Always posts ephemeral (private) responses with a Follow Up button.
- */
 declare function handleModalSubmission(view: {
   private_metadata?: string;
   callback_id?: string;
@@ -16,15 +6,5 @@ declare function handleModalSubmission(view: {
     values?: Record<string, Record<string, unknown>>;
   };
 }): Promise<void>;
-/**
- * Handle follow-up modal submission.
- * Reuses the existing conversationId so the agent has full conversation history.
- */
-declare function handleFollowUpSubmission(view: {
-  private_metadata?: string;
-  state?: {
-    values?: Record<string, Record<string, unknown>>;
-  };
-}): Promise<void>;
 //#endregion
-export { handleFollowUpSubmission, handleModalSubmission };
+export { handleModalSubmission };