@inkeep/agents-work-apps 0.50.0 → 0.50.3

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,335 @@
+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 values = view.state?.values || {};
+			const agentSelectEntry = Object.entries(values).find(([, block]) => block.agent_select);
+			const agentSelectBlockId = agentSelectEntry?.[0];
+			const agentSelect = agentSelectEntry ? agentSelectEntry[1].agent_select : void 0;
+			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: { [agentSelectBlockId || "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/i18n/strings.d.ts

@@ -11,7 +11,7 @@ declare const SlackStrings: {
     readonly send: "Send";
     readonly followUp: "Follow Up";
     readonly cancel: "Cancel";
-    readonly openDashboard: "⚙️ Open Dashboard";
+    readonly openDashboard: "Open Dashboard";
   };
   readonly modals: {
     readonly triggerAgent: "Trigger Agent";
@@ -46,18 +46,18 @@ declare const SlackStrings: {
   readonly status: {
     readonly thinking: (agentName: string) => string;
     readonly noAgentsAvailable: "No agents available";
-    readonly noProjectsConfigured: "⚙️ No projects configured. Please set up projects in the dashboard.";
+    readonly noProjectsConfigured: "No projects configured. Set up projects in the dashboard.";
   };
   readonly errors: {
-    readonly generic: "Sorry, something went wrong. Please try again.";
-    readonly failedToOpenSelector: "❌ Failed to open agent selector. Please try again.";
+    readonly generic: "Something went wrong. Please try again.";
+    readonly failedToOpenSelector: "Failed to open agent selector. Please try again.";
   };
   readonly help: {
     readonly title: "Inkeep — How to Use";
     readonly publicSection: string;
     readonly privateSection: string;
     readonly otherCommands: string;
-    readonly docsLink: "📖 <https://docs.inkeep.com/talk-to-your-agents/slack/overview|Learn more>";
+    readonly docsLink: "<https://docs.inkeep.com/talk-to-your-agents/slack/overview|Learn more>";
   };
   readonly messageContext: {
     readonly label: "Message:";

package/dist/slack/i18n/strings.js

@@ -11,7 +11,7 @@ const SlackStrings = {
 		send: "Send",
 		followUp: "Follow Up",
 		cancel: "Cancel",
-		openDashboard: "⚙️ Open Dashboard"
+		openDashboard: "Open Dashboard"
 	},
 	modals: {
 		triggerAgent: "Trigger Agent",
@@ -38,22 +38,22 @@ const SlackStrings = {
 		poweredBy: (agentName) => `Powered by *${agentName}* via Inkeep`,
 		privateResponse: "_Private response_"
 	},
-	usage: { mentionEmpty: "*To use your Inkeep agent, include a message:*\n\n• `@Inkeep <message>` — Send a message to the default agent for the channel (reply appears in a thread)\n• `@Inkeep <message>` in a thread — Includes the thread as context for your agent\n• `@Inkeep` in a thread — Triggers your agent using the full thread as context\n\n💡 Use `/inkeep help` for all available commands." },
+	usage: { mentionEmpty: "*Include a message to use your Inkeep agent:*\n\n• `@Inkeep <message>` — Message the default agent (reply appears in a thread)\n• `@Inkeep <message>` in a thread — Includes thread as context\n• `@Inkeep` in a thread — Uses the full thread as context\n\nUse `/inkeep help` for all available commands." },
 	status: {
 		thinking: (agentName) => `_${agentName} is thinking..._`,
 		noAgentsAvailable: "No agents available",
-		noProjectsConfigured: "⚙️ No projects configured. Please set up projects in the dashboard."
+		noProjectsConfigured: "No projects configured. Set up projects in the dashboard."
 	},
 	errors: {
-		generic: "Sorry, something went wrong. Please try again.",
-		failedToOpenSelector: "❌ Failed to open agent selector. Please try again."
+		generic: "Something went wrong. Please try again.",
+		failedToOpenSelector: "Failed to open agent selector. Please try again."
 	},
 	help: {
 		title: "Inkeep — How to Use",
-		publicSection: "🔊 *Public* — everyone in the channel can see the response\n\n• `@Inkeep <message>` — message the default agent in this channel\n• `@Inkeep <message>` in a thread — Includes thread as context\n• `@Inkeep` in a thread — Uses the full thread as context",
-		privateSection: "🔒 *Private* — only you can see the response\n\n• `/inkeep <message>` — message the default agent in this channel\n• `/inkeep` — Open the agent picker to choose an agent and write a prompt",
-		otherCommands: "⚙️ *Other Commands*\n\n• `/inkeep status` — Check your connection and agent config\n• `/inkeep link` / `/inkeep unlink` — Manage account connection\n• `/inkeep help` — Show this message",
-		docsLink: "📖 <https://docs.inkeep.com/talk-to-your-agents/slack/overview|Learn more>"
+		publicSection: "*Public* — visible to everyone in the channel\n\n• `@Inkeep <message>` — Message the default agent in this channel\n• `@Inkeep <message>` in a thread — Includes thread as context\n• `@Inkeep` in a thread — Uses the full thread as context",
+		privateSection: "*Private* — only visible to you\n\n• `/inkeep <message>` — Message the default agent in this channel\n• `/inkeep` — Open the agent picker to choose an agent and write a prompt",
+		otherCommands: "*Other Commands*\n\n• `/inkeep status` — Check your connection and agent config\n• `/inkeep link` / `/inkeep unlink` — Manage account connection\n• `/inkeep help` — Show this message",
+		docsLink: "<https://docs.inkeep.com/talk-to-your-agents/slack/overview|Learn more>"
 	},
 	messageContext: { label: "Message:" }
 };

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

@@ -1,9 +1,11 @@
 import { 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 { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.js";
 import "./services/events/index.js";
+import { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.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 };