@inkeep/agents-work-apps 0.58.2 → 0.58.4

package/dist/env.d.ts

@@ -28,6 +28,7 @@ declare const envSchema: z.ZodObject<{
   GITHUB_STATE_SIGNING_SECRET: z.ZodOptional<z.ZodString>;
   GITHUB_APP_NAME: z.ZodOptional<z.ZodString>;
   GITHUB_MCP_API_KEY: z.ZodOptional<z.ZodString>;
+  SLACK_MCP_API_KEY: z.ZodOptional<z.ZodString>;
   SLACK_CLIENT_ID: z.ZodOptional<z.ZodString>;
   SLACK_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
   SLACK_SIGNING_SECRET: z.ZodOptional<z.ZodString>;
@@ -53,6 +54,7 @@ declare const env: {
   GITHUB_STATE_SIGNING_SECRET?: string | undefined;
   GITHUB_APP_NAME?: string | undefined;
   GITHUB_MCP_API_KEY?: string | undefined;
+  SLACK_MCP_API_KEY?: string | undefined;
   SLACK_CLIENT_ID?: string | undefined;
   SLACK_CLIENT_SECRET?: string | undefined;
   SLACK_SIGNING_SECRET?: string | undefined;

package/dist/env.js

@@ -30,6 +30,7 @@ const envSchema = z.object({
 	GITHUB_STATE_SIGNING_SECRET: z.string().min(32, "GITHUB_STATE_SIGNING_SECRET must be at least 32 characters").optional().describe("Secret for signing GitHub OAuth state (minimum 32 characters)"),
 	GITHUB_APP_NAME: z.string().optional().describe("Name of the GitHub App"),
 	GITHUB_MCP_API_KEY: z.string().optional().describe("API key for the GitHub MCP"),
+	SLACK_MCP_API_KEY: z.string().optional().describe("API key for the Slack MCP"),
 	SLACK_CLIENT_ID: z.string().optional().describe("Slack App Client ID"),
 	SLACK_CLIENT_SECRET: z.string().optional().describe("Slack App Client Secret"),
 	SLACK_SIGNING_SECRET: z.string().optional().describe("Slack App Signing Secret"),

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_types5 from "hono/types";
+import * as hono_types1 from "hono/types";
 
 //#region src/github/index.d.ts
-declare function createGithubRoutes(): Hono<hono_types5.BlankEnv, hono_types5.BlankSchema, "/">;
-declare const githubRoutes: Hono<hono_types5.BlankEnv, hono_types5.BlankSchema, "/">;
+declare function createGithubRoutes(): Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
+declare const githubRoutes: Hono<hono_types1.BlankEnv, hono_types1.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

@@ -4,6 +4,8 @@ import * as hono0 from "hono";
 declare const githubMcpAuth: () => hono0.MiddlewareHandler<{
   Variables: {
     toolId: string;
+    tenantId: string;
+    projectId: string;
   };
 }, string, {}, Response>;
 //#endregion

package/dist/github/mcp/auth.js

@@ -13,6 +13,24 @@ const githubMcpAuth = () => createMiddleware(async (c, next) => {
 			name: "x-inkeep-tool-id"
 		} }
 	});
+	const tenantId = c.req.header("x-inkeep-tenant-id");
+	if (!tenantId) throw createApiError({
+		code: "unauthorized",
+		message: "Missing required header: x-inkeep-tenant-id",
+		extensions: { parameter: {
+			in: "header",
+			name: "x-inkeep-tenant-id"
+		} }
+	});
+	const projectId = c.req.header("x-inkeep-project-id");
+	if (!projectId) throw createApiError({
+		code: "unauthorized",
+		message: "Missing required header: x-inkeep-project-id",
+		extensions: { parameter: {
+			in: "header",
+			name: "x-inkeep-project-id"
+		} }
+	});
 	const authHeader = c.req.header("Authorization");
 	if (!authHeader) throw createApiError({
 		code: "unauthorized",
@@ -36,6 +54,8 @@ const githubMcpAuth = () => createMiddleware(async (c, next) => {
 		message: "Invalid API key"
 	});
 	c.set("toolId", toolId);
+	c.set("tenantId", tenantId);
+	c.set("projectId", projectId);
 	await next();
 });
 

package/dist/github/mcp/index.d.ts

@@ -1,11 +1,13 @@
 import { Hono } from "hono";
-import * as hono_types9 from "hono/types";
+import * as hono_types0 from "hono/types";
 
 //#region src/github/mcp/index.d.ts
 declare const app: Hono<{
   Variables: {
     toolId: string;
+    tenantId: string;
+    projectId: string;
   };
-}, hono_types9.BlankSchema, "/">;
+}, hono_types0.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/github/mcp/index.js

@@ -27,11 +27,8 @@ const getAvailableRepositoryString = (repositoryAccess) => {
 	if (repositoryAccess.length === 0) return "No repositories available";
 	return `Available repositories: ${repositoryAccess.map((r) => `"${r.repositoryFullName}"`).join(", ")}`;
 };
-/**
-* Creates and configures an MCP server for the given context
-*/
-const getServer = async (toolId) => {
-	const repositoryAccess = await getMcpToolRepositoryAccessWithDetails(runDbClient_default)(toolId);
+const getServer = async (scope) => {
+	const repositoryAccess = await getMcpToolRepositoryAccessWithDetails(runDbClient_default)(scope);
 	const installationIdMap = /* @__PURE__ */ new Map();
 	for (const repo of repositoryAccess) installationIdMap.set(repo.repositoryFullName, repo.installationId);
 	if (repositoryAccess.length === 0) throw new Error("No repository access found for tool");
@@ -985,8 +982,14 @@ app.use("/", githubMcpAuth());
 app.post("/", async (c) => {
 	if (!process.env.GITHUB_APP_ID || !process.env.GITHUB_APP_PRIVATE_KEY) return c.json({ error: "GITHUB_APP_ID and GITHUB_APP_PRIVATE_KEY must be set" }, 500);
 	const toolId = c.get("toolId");
+	const tenantId = c.get("tenantId");
+	const projectId = c.get("projectId");
 	const body = await c.req.json();
-	const server = await getServer(toolId);
+	const server = await getServer({
+		tenantId,
+		projectId,
+		toolId
+	});
 	const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
 	await server.connect(transport);
 	const { req, res } = toReqRes(c.req.raw);

package/dist/github/mcp/schemas.d.ts

@@ -76,8 +76,8 @@ declare const ChangedFileSchema: z.ZodObject<{
   path: z.ZodString;
   status: z.ZodEnum<{
     added: "added";
-    removed: "removed";
     modified: "modified";
+    removed: "removed";
     renamed: "renamed";
     copied: "copied";
     changed: "changed";

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

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

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

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

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

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

package/dist/slack/index.d.ts

@@ -1,5 +1,7 @@
 import { DispatchOptions, SlackEventDispatchResult, dispatchSlackEvent } from "./dispatcher.js";
 import { ManageAppVariables, WorkAppsVariables } from "./types.js";
+import { resolveWorkspaceToken } from "./mcp/utils.js";
+import { getSlackClient, validateBotChannelMembership } from "./services/client.js";
 import { DefaultAgentConfig, SlackWorkspaceConnection, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./services/nango.js";
 import { getChannelAgentConfig } from "./services/events/utils.js";
 import "./services/events/index.js";
@@ -9,7 +11,6 @@ import { startSocketMode } from "./socket-mode.js";
 import { OpenAPIHono } from "@hono/zod-openapi";
 
 //#region src/slack/index.d.ts
-
 declare function createSlackRoutes(): OpenAPIHono<{
   Variables: WorkAppsVariables;
 }, {}, "/">;
@@ -17,4 +18,4 @@ declare const slackRoutes: OpenAPIHono<{
   Variables: WorkAppsVariables;
 }, {}, "/">;
 //#endregion
-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 };
+export { DefaultAgentConfig, type DispatchOptions, ManageAppVariables, type SlackEventDispatchResult, SlackWorkspaceConnection, WorkAppsVariables, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, createSlackRoutes, deleteWorkspaceInstallation, dispatchSlackEvent, findWorkspaceConnectionByTeamId, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackClient, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, resolveWorkspaceToken, setBotTokenForTeam, setWorkspaceDefaultAgent, slackRoutes, startSocketMode, storeWorkspaceInstallation, updateConnectionMetadata, validateBotChannelMembership };

package/dist/slack/index.js

@@ -1,8 +1,11 @@
 import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./services/nango.js";
 import { getChannelAgentConfig } from "./services/events/utils.js";
+import { getSlackClient, validateBotChannelMembership } from "./services/client.js";
 import "./services/events/index.js";
 import { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.js";
 import { dispatchSlackEvent } from "./dispatcher.js";
+import { resolveWorkspaceToken } from "./mcp/utils.js";
+import mcp_default from "./mcp/index.js";
 import "./routes/oauth.js";
 import routes_default from "./routes/index.js";
 import { startSocketMode } from "./socket-mode.js";
@@ -22,9 +25,10 @@ import { OpenAPIHono } from "@hono/zod-openapi";
 function createSlackRoutes() {
 	const app = new OpenAPIHono();
 	app.route("/", routes_default);
+	app.route("/mcp", mcp_default);
 	return app;
 }
 const slackRoutes = createSlackRoutes();
 
 //#endregion
-export { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, createSlackRoutes, deleteWorkspaceInstallation, dispatchSlackEvent, findWorkspaceConnectionByTeamId, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setBotTokenForTeam, setWorkspaceDefaultAgent, slackRoutes, startSocketMode, storeWorkspaceInstallation, updateConnectionMetadata };
+export { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, createSlackRoutes, deleteWorkspaceInstallation, dispatchSlackEvent, findWorkspaceConnectionByTeamId, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackClient, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, resolveWorkspaceToken, setBotTokenForTeam, setWorkspaceDefaultAgent, slackRoutes, startSocketMode, storeWorkspaceInstallation, updateConnectionMetadata, validateBotChannelMembership };

package/dist/slack/mcp/auth.d.ts

@@ -0,0 +1,12 @@
+import * as hono2 from "hono";
+
+//#region src/slack/mcp/auth.d.ts
+declare const slackMcpAuth: () => hono2.MiddlewareHandler<{
+  Variables: {
+    toolId: string;
+    tenantId: string;
+    projectId: string;
+  };
+}, string, {}, Response>;
+//#endregion
+export { slackMcpAuth };

package/dist/slack/mcp/auth.js

@@ -0,0 +1,70 @@
+import { env } from "../../env.js";
+import { createApiError } from "@inkeep/agents-core";
+import { createMiddleware } from "hono/factory";
+import { timingSafeEqual } from "node:crypto";
+
+//#region src/slack/mcp/auth.ts
+const slackMcpAuth = () => createMiddleware(async (c, next) => {
+	const toolId = c.req.header("x-inkeep-tool-id");
+	if (!toolId) throw createApiError({
+		code: "unauthorized",
+		message: "Missing required header: x-inkeep-tool-id",
+		extensions: { parameter: {
+			in: "header",
+			name: "x-inkeep-tool-id"
+		} }
+	});
+	const tenantId = c.req.header("x-inkeep-tenant-id");
+	if (!tenantId) throw createApiError({
+		code: "unauthorized",
+		message: "Missing required header: x-inkeep-tenant-id",
+		extensions: { parameter: {
+			in: "header",
+			name: "x-inkeep-tenant-id"
+		} }
+	});
+	const projectId = c.req.header("x-inkeep-project-id");
+	if (!projectId) throw createApiError({
+		code: "unauthorized",
+		message: "Missing required header: x-inkeep-project-id",
+		extensions: { parameter: {
+			in: "header",
+			name: "x-inkeep-project-id"
+		} }
+	});
+	const authHeader = c.req.header("Authorization");
+	if (!authHeader) throw createApiError({
+		code: "unauthorized",
+		message: "Missing required header: Authorization",
+		extensions: { parameter: {
+			in: "header",
+			name: "Authorization"
+		} }
+	});
+	const apiKey = authHeader.startsWith("Bearer ") ? authHeader.substring(7) : void 0;
+	if (!apiKey) throw createApiError({
+		code: "unauthorized",
+		message: "Invalid Authorization header format. Expected: Bearer <token>",
+		extensions: { parameter: {
+			in: "header",
+			name: "Authorization"
+		} }
+	});
+	if (!env.SLACK_MCP_API_KEY) throw createApiError({
+		code: "internal_server_error",
+		message: "Slack MCP API key not configured"
+	});
+	const expectedKey = Buffer.from(env.SLACK_MCP_API_KEY);
+	const providedKey = Buffer.from(apiKey);
+	if (expectedKey.length !== providedKey.length || !timingSafeEqual(expectedKey, providedKey)) throw createApiError({
+		code: "unauthorized",
+		message: "Invalid API key"
+	});
+	c.set("toolId", toolId);
+	c.set("tenantId", tenantId);
+	c.set("projectId", projectId);
+	await next();
+});
+
+//#endregion
+export { slackMcpAuth };

package/dist/slack/mcp/index.d.ts

@@ -0,0 +1,23 @@
+import { Hono } from "hono";
+import * as hono_types0 from "hono/types";
+
+//#region src/slack/mcp/index.d.ts
+interface ChannelInfo {
+  id: string;
+  name: string;
+}
+type ToolScope = {
+  tenantId: string;
+  projectId: string;
+  toolId: string;
+};
+declare function pruneStaleChannelIds(scope: ToolScope, availableChannels: ChannelInfo[], currentChannelIds: string[]): string[];
+declare const app: Hono<{
+  Variables: {
+    toolId: string;
+    tenantId: string;
+    projectId: string;
+  };
+}, hono_types0.BlankSchema, "/">;
+//#endregion
+export { ChannelInfo, app as default, pruneStaleChannelIds };

package/dist/slack/mcp/index.js

@@ -0,0 +1,294 @@
+import { getLogger } from "../../logger.js";
+import runDbClient_default from "../../db/runDbClient.js";
+import { getBotMemberChannels, getSlackClient, getSlackUserByEmail, getSlackUserInfo, getSlackUsers, openDmConversation, postMessage, postMessageInThread } from "../services/client.js";
+import { slackMcpAuth } from "./auth.js";
+import { resolveChannelId, resolveWorkspaceToken, searchUsersByName, validateChannelAccess } from "./utils.js";
+import { z } from "@hono/zod-openapi";
+import { getSlackMcpToolAccessConfig, updateSlackMcpToolAccessChannelIds } from "@inkeep/agents-core";
+import { Hono } from "hono";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { toFetchResponse, toReqRes } from "fetch-to-node";
+
+//#region src/slack/mcp/index.ts
+const logger = getLogger("slack-mcp");
+async function getAvailableChannels(client, config) {
+	try {
+		const botChannels = await getBotMemberChannels(client);
+		if (config.channelAccessMode === "all") return botChannels.filter((ch) => !!ch.id && !!ch.name).map((ch) => ({
+			id: ch.id,
+			name: ch.name
+		}));
+		const allowedIds = new Set(config.channelIds);
+		return botChannels.filter((ch) => !!ch.id && !!ch.name && allowedIds.has(ch.id)).map((ch) => ({
+			id: ch.id,
+			name: ch.name
+		}));
+	} catch (error) {
+		logger.warn({ error }, "Failed to fetch available channels for tool description");
+		return [];
+	}
+}
+function getAvailableChannelsString(channels) {
+	if (channels.length === 0) return "No channels available";
+	return `Available channels: ${channels.map((ch) => `#${ch.name} (${ch.id})`).join(", ")}`;
+}
+function pruneStaleChannelIds(scope, availableChannels, currentChannelIds) {
+	const availableIds = new Set(availableChannels.map((ch) => ch.id));
+	const staleIds = currentChannelIds.filter((id) => !availableIds.has(id));
+	if (staleIds.length > 0) {
+		const prunedIds = currentChannelIds.filter((id) => availableIds.has(id));
+		logger.info({
+			toolId: scope.toolId,
+			staleIds,
+			prunedIds
+		}, "Pruning stale channel IDs from MCP access config");
+		updateSlackMcpToolAccessChannelIds(runDbClient_default)(scope, prunedIds).catch((error) => {
+			logger.warn({
+				error,
+				toolId: scope.toolId
+			}, "Failed to prune stale channel IDs");
+		});
+	}
+	return currentChannelIds;
+}
+const getServer = async (scope) => {
+	const botToken = await resolveWorkspaceToken(scope.tenantId);
+	const config = await getSlackMcpToolAccessConfig(runDbClient_default)(scope);
+	const client = getSlackClient(botToken);
+	const availableChannels = await getAvailableChannels(client, config);
+	if (config.channelAccessMode === "selected") pruneStaleChannelIds(scope, availableChannels, config.channelIds);
+	const server = new McpServer({
+		name: "inkeep-slack-mcp-server",
+		version: "1.0.0",
+		description: "A Slack MCP server for posting messages to channels" + (config.dmEnabled ? " and sending direct messages to users" : "") + ".\n" + availableChannels.map((ch) => `• #${ch.name} (${ch.id})`).join("\n")
+	}, { capabilities: { logging: {} } });
+	server.tool("post-channel-message", `Post a message to a Slack channel. Supports mrkdwn formatting and thread replies. ${getAvailableChannelsString(availableChannels)}`, {
+		channel: z.string().describe("Channel ID (e.g., C1234567890) or channel name prefixed with # (e.g., #general)."),
+		text: z.string().describe("Message text. Supports Slack mrkdwn formatting."),
+		thread_ts: z.string().optional().describe("Thread timestamp to reply in a thread. If omitted, posts as a new message.")
+	}, async ({ channel, text, thread_ts }) => {
+		try {
+			const channelId = await resolveChannelId(client, channel);
+			const accessCheck = validateChannelAccess(channelId, config);
+			if (!accessCheck.allowed) return {
+				content: [{
+					type: "text",
+					text: `Error: ${accessCheck.reason}`
+				}],
+				isError: true
+			};
+			const result = thread_ts ? await postMessageInThread(client, channelId, thread_ts, text) : await postMessage(client, channelId, text);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					ok: result.ok,
+					ts: result.ts,
+					channel: result.channel
+				})
+			}] };
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			logger.error({
+				error,
+				toolId: scope.toolId,
+				channel
+			}, "Failed to post Slack message via MCP");
+			return {
+				content: [{
+					type: "text",
+					text: `Error posting message: ${message}`
+				}],
+				isError: true
+			};
+		}
+	});
+	if (config.dmEnabled) server.tool("post-direct-message", "Send a direct message to a Slack user. Opens or continues an existing DM conversation with the user.", {
+		user_id: z.string().describe("The Slack user ID to DM (e.g., U1234567890)."),
+		text: z.string().describe("Message text. Supports Slack mrkdwn formatting."),
+		thread_ts: z.string().optional().describe("Thread timestamp to reply in a thread. If omitted, posts as a new message.")
+	}, async ({ user_id, text, thread_ts }) => {
+		try {
+			const dmChannelId = await openDmConversation(client, user_id);
+			const result = thread_ts ? await postMessageInThread(client, dmChannelId, thread_ts, text) : await postMessage(client, dmChannelId, text);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					ok: result.ok,
+					ts: result.ts,
+					channel: result.channel,
+					user_id
+				})
+			}] };
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			logger.error({
+				error,
+				toolId: scope.toolId,
+				user_id
+			}, "Failed to send Slack DM via MCP");
+			return {
+				content: [{
+					type: "text",
+					text: `Error sending DM: ${message}`
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("get-slack-user", "Look up a Slack user by their user ID, email address, or name. Provide exactly one parameter. User ID and email return an exact match; name returns up to 5 ranked matches. If necessary, please clarify with the user when you receive multiple results.", {
+		user_id: z.string().optional().describe("Slack user ID (e.g., U1234567890). Returns an exact match."),
+		email: z.string().optional().describe("Email address (e.g., jane@company.com). Returns an exact match."),
+		name: z.string().optional().describe("Display name, real name, or username to search for (e.g., \"Jane Smith\"). Returns up to 5 ranked matches.")
+	}, async ({ user_id, email, name }) => {
+		try {
+			const providedCount = [
+				user_id,
+				email,
+				name
+			].filter(Boolean).length;
+			if (providedCount === 0) return {
+				content: [{
+					type: "text",
+					text: "Error: Provide at least one of user_id, email, or name."
+				}],
+				isError: true
+			};
+			if (providedCount > 1) return {
+				content: [{
+					type: "text",
+					text: "Error: Provide exactly one of user_id, email, or name."
+				}],
+				isError: true
+			};
+			if (user_id) {
+				const user = await getSlackUserInfo(client, user_id);
+				if (!user) return { content: [{
+					type: "text",
+					text: `No user found with ID: ${user_id}`
+				}] };
+				return { content: [{
+					type: "text",
+					text: JSON.stringify(user)
+				}] };
+			}
+			if (email) {
+				const user = await getSlackUserByEmail(client, email);
+				if (!user) return { content: [{
+					type: "text",
+					text: `No user found with email: ${email}`
+				}] };
+				return { content: [{
+					type: "text",
+					text: JSON.stringify(user)
+				}] };
+			}
+			const scored = searchUsersByName(await getSlackUsers(client), name ?? "");
+			if (scored.length === 0) return { content: [{
+				type: "text",
+				text: `No users found matching name: "${name}"`
+			}] };
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(scored)
+			}] };
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			logger.error({
+				error,
+				toolId: scope.toolId,
+				user_id,
+				email,
+				name
+			}, "Failed to look up Slack user via MCP");
+			return {
+				content: [{
+					type: "text",
+					text: `Error looking up user: ${message}`
+				}],
+				isError: true
+			};
+		}
+	});
+	return server;
+};
+const app = new Hono();
+app.onError((err, c) => {
+	const message = err.message || "Internal server error";
+	logger.error({ error: err }, "Slack MCP error");
+	return c.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32603,
+			message
+		},
+		id: null
+	}, 500);
+});
+app.use("/", slackMcpAuth());
+app.post("/", async (c) => {
+	const toolId = c.get("toolId");
+	const tenantId = c.get("tenantId");
+	const projectId = c.get("projectId");
+	let server;
+	try {
+		const body = await c.req.json();
+		server = await getServer({
+			tenantId,
+			projectId,
+			toolId
+		});
+		const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+		await server.connect(transport);
+		const { req, res } = toReqRes(c.req.raw);
+		await transport.handleRequest(req, res, body);
+		return toFetchResponse(res);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		logger.error({
+			error,
+			toolId
+		}, "MCP request failed");
+		return c.json({
+			jsonrpc: "2.0",
+			error: {
+				code: -32603,
+				message
+			},
+			id: null
+		}, 500);
+	} finally {
+		if (server) await server.close().catch((e) => logger.warn({ error: e }, "Failed to close MCP server"));
+	}
+});
+app.delete("/", async (c) => {
+	return c.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32001,
+			message: "Method Not Allowed"
+		},
+		id: null
+	}, { status: 405 });
+});
+app.get("/", async (c) => {
+	return c.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32e3,
+			message: "Method not allowed."
+		},
+		id: null
+	}, { status: 405 });
+});
+app.get("/health", async (c) => {
+	return c.json({
+		status: "healthy",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		service: "Slack MCP Server"
+	});
+});
+var mcp_default = app;
+
+//#endregion
+export { mcp_default as default, pruneStaleChannelIds };

package/dist/slack/mcp/utils.d.ts

@@ -0,0 +1,18 @@
+import { SlackMcpToolAccessConfig } from "@inkeep/agents-core";
+import { WebClient } from "@slack/web-api";
+
+//#region src/slack/mcp/utils.d.ts
+declare function resolveChannelId(client: WebClient, channelInput: string): Promise<string>;
+declare function resolveWorkspaceToken(tenantId: string): Promise<string>;
+interface UserWithNameFields {
+  realName?: string;
+  displayName?: string;
+  name?: string;
+}
+declare function searchUsersByName<T extends UserWithNameFields>(users: T[], query: string, maxResults?: number): T[];
+declare function validateChannelAccess(channelId: string, config: SlackMcpToolAccessConfig): {
+  allowed: boolean;
+  reason?: string;
+};
+//#endregion
+export { resolveChannelId, resolveWorkspaceToken, searchUsersByName, validateChannelAccess };

package/dist/slack/mcp/utils.js

@@ -0,0 +1,83 @@
+import runDbClient_default from "../../db/runDbClient.js";
+import { isSlackDevMode, loadSlackDevConfig } from "../services/dev-config.js";
+import { getConnectionAccessToken } from "../services/nango.js";
+import { listWorkAppSlackWorkspacesByTenant } from "@inkeep/agents-core";
+
+//#region src/slack/mcp/utils.ts
+const MAX_PAGES = 10;
+async function resolveChannelId(client, channelInput) {
+	if (!channelInput.startsWith("#")) return channelInput;
+	const channelName = channelInput.slice(1);
+	let cursor;
+	let pageCount = 0;
+	do {
+		if (pageCount >= MAX_PAGES) throw new Error(`Channel not found within first ${MAX_PAGES * 200} channels: ${channelInput}`);
+		const result = await client.conversations.list({
+			types: "public_channel,private_channel",
+			exclude_archived: true,
+			limit: 200,
+			cursor
+		});
+		const match = result.channels?.find((ch) => ch.name === channelName);
+		if (match?.id) return match.id;
+		cursor = result.response_metadata?.next_cursor || void 0;
+		pageCount++;
+	} while (cursor);
+	throw new Error(`Channel not found: ${channelInput}`);
+}
+async function resolveWorkspaceToken(tenantId) {
+	if (isSlackDevMode()) {
+		const devConfig = loadSlackDevConfig();
+		if (devConfig?.botToken) return devConfig.botToken;
+		throw new Error("Slack dev mode enabled but no botToken found in .slack-dev.json");
+	}
+	const workspaces = await listWorkAppSlackWorkspacesByTenant(runDbClient_default)(tenantId);
+	if (workspaces.length === 0) throw new Error(`No Slack workspace installed for tenant ${tenantId}`);
+	const workspace = workspaces[0];
+	const botToken = await getConnectionAccessToken(workspace.nangoConnectionId);
+	if (!botToken) throw new Error(`Failed to retrieve bot token for workspace ${workspace.slackTeamId}`);
+	return botToken;
+}
+function searchUsersByName(users, query, maxResults = 5) {
+	const needle = query.trim().toLowerCase();
+	if (!needle) return [];
+	return users.map((user) => {
+		const fields = [
+			user.realName,
+			user.displayName,
+			user.name
+		].filter(Boolean);
+		let bestScore = 0;
+		for (const field of fields) {
+			const lower = field.toLowerCase();
+			if (lower === needle) {
+				bestScore = 3;
+				break;
+			}
+			if (lower.startsWith(needle)) bestScore = Math.max(bestScore, 2);
+			else if (lower.includes(needle)) bestScore = Math.max(bestScore, 1);
+		}
+		return {
+			user,
+			score: bestScore
+		};
+	}).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score).slice(0, maxResults).map((entry) => entry.user);
+}
+function validateChannelAccess(channelId, config) {
+	if (channelId.startsWith("D")) {
+		if (!config.dmEnabled) return {
+			allowed: false,
+			reason: "DM access is not enabled for this tool"
+		};
+		return { allowed: true };
+	}
+	if (config.channelAccessMode === "all") return { allowed: true };
+	if (config.channelIds.includes(channelId)) return { allowed: true };
+	return {
+		allowed: false,
+		reason: "Channel not in allowed list"
+	};
+}
+
+//#endregion
+export { resolveChannelId, resolveWorkspaceToken, searchUsersByName, validateChannelAccess };

package/dist/slack/routes/oauth.js

@@ -104,7 +104,10 @@ app.openapi(createProtectedRoute({
 		"im:write",
 		"team:read",
 		"users:read",
-		"users:read.email"
+		"users:read.email",
+		"search:read.public",
+		"search:read.files",
+		"search:read.users"
 	].join(",");
 	const state = createOAuthState(tenantId);
 	const slackAuthUrl = new URL("https://slack.com/oauth/v2/authorize");

package/dist/slack/routes/workspaces.js

@@ -6,7 +6,7 @@ import { getBotMemberChannels, getSlackChannels, getSlackClient, revokeSlackToke
 import "../services/index.js";
 import { requireChannelMemberOrAdmin, requireWorkspaceAdmin } from "../middleware/permissions.js";
 import { OpenAPIHono, z } from "@hono/zod-openapi";
-import { WorkAppSlackAgentConfigRequestSchema, deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackChannelAgentConfig, deleteWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackChannelAgentConfig, findWorkAppSlackWorkspaceByTeamId, listWorkAppSlackChannelAgentConfigsByTeam, listWorkAppSlackUserMappingsByTeam, updateWorkAppSlackWorkspace, upsertWorkAppSlackChannelAgentConfig } from "@inkeep/agents-core";
+import { WorkAppSlackAgentConfigRequestSchema, deleteAllSlackMcpToolAccessConfigsByTenant, deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackChannelAgentConfig, deleteWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackChannelAgentConfig, findWorkAppSlackWorkspaceByTeamId, listWorkAppSlackChannelAgentConfigsByTeam, listWorkAppSlackUserMappingsByTeam, updateWorkAppSlackWorkspace, upsertWorkAppSlackChannelAgentConfig } from "@inkeep/agents-core";
 import { createProtectedRoute, inheritedWorkAppsAuth } from "@inkeep/agents-core/middleware";
 
 //#region src/slack/routes/workspaces.ts
@@ -376,6 +376,11 @@ app.openapi(createProtectedRoute({
 			teamId,
 			deletedMappings
 		}, "Deleted user mappings for uninstalled workspace");
+		const deletedMcpConfigs = await deleteAllSlackMcpToolAccessConfigsByTenant(runDbClient_default)(tenantId);
+		if (deletedMcpConfigs > 0) logger.info({
+			teamId,
+			deletedMcpConfigs
+		}, "Deleted MCP tool access configs for uninstalled workspace");
 		if (await deleteWorkAppSlackWorkspaceByNangoConnectionId(runDbClient_default)(connectionId)) logger.info({ connectionId }, "Deleted workspace from database");
 		if (!await deleteWorkspaceInstallation(connectionId)) logger.error({ connectionId }, "deleteWorkspaceInstallation returned false (DB already cleaned up)");
 		clearWorkspaceConnectionCache(teamId);

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

@@ -32,6 +32,53 @@ declare function getSlackUserInfo(client: WebClient, userId: string): Promise<{
   tz: string | undefined;
   tzOffset: number | undefined;
 } | null>;
+/**
+ * Look up a Slack user by email address.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param email - Email address to look up
+ * @returns User profile object, or null if not found
+ */
+declare function getSlackUserByEmail(client: WebClient, email: string): Promise<{
+  id: string | undefined;
+  name: string | undefined;
+  realName: string | undefined;
+  displayName: string | undefined;
+  email: string | undefined;
+  isAdmin: boolean | undefined;
+  isOwner: boolean | undefined;
+  avatar: string | undefined;
+  tz: string | undefined;
+  tzOffset: number | undefined;
+} | null>;
+/**
+ * List all members of a Slack workspace.
+ *
+ * Automatically paginates through results. Excludes deleted users and bots by default.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param options - Optional filters
+ * @param options.includeDeleted - Include deactivated users (default: false)
+ * @param options.includeBots - Include bot users (default: false)
+ * @param options.limit - Maximum number of users to return
+ * @returns Array of user profile objects
+ */
+declare function getSlackUsers(client: WebClient, options?: {
+  includeDeleted?: boolean;
+  includeBots?: boolean;
+  limit?: number;
+}): Promise<{
+  id: string | undefined;
+  name: string | undefined;
+  realName: string | undefined;
+  displayName: string | undefined;
+  email: string | undefined;
+  isAdmin: boolean | undefined;
+  isOwner: boolean | undefined;
+  avatar: string | undefined;
+  tz: string | undefined;
+  tzOffset: number | undefined;
+}[]>;
 /**
  * Fetch workspace (team) information from Slack.
  *
@@ -132,6 +179,25 @@ declare function postMessageInThread(client: WebClient, channel: string, threadT
  * @returns true if user is a member, false otherwise
  */
 declare function checkUserIsChannelMember(client: WebClient, channelId: string, userId: string): Promise<boolean>;
+/**
+ * Open (or resume) a direct message conversation with a Slack user.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param userId - Slack user ID to DM (e.g., U0ABC123)
+ * @returns The DM channel ID
+ */
+declare function openDmConversation(client: WebClient, userId: string): Promise<string>;
+/**
+ * Validate that the bot is a member of the given channels.
+ *
+ * @param client - Authenticated Slack WebClient
+ * @param channelIds - Channel IDs to validate
+ * @returns Object with valid and invalid channel ID arrays
+ */
+declare function validateBotChannelMembership(client: WebClient, channelIds: string[]): Promise<{
+  valid: string[];
+  invalid: string[];
+}>;
 /**
  * Revoke a Slack bot token.
  *
@@ -143,4 +209,4 @@ declare function checkUserIsChannelMember(client: WebClient, channelId: string,
  */
 declare function revokeSlackToken(token: string): Promise<boolean>;
 //#endregion
-export { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };
+export { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserByEmail, getSlackUserInfo, getSlackUsers, openDmConversation, postMessage, postMessageInThread, revokeSlackToken, validateBotChannelMembership };

package/dist/slack/services/client.js

@@ -63,6 +63,71 @@ async function getSlackUserInfo(client, userId) {
 	}
 }
 /**
+* Look up a Slack user by email address.
+*
+* @param client - Authenticated Slack WebClient
+* @param email - Email address to look up
+* @returns User profile object, or null if not found
+*/
+async function getSlackUserByEmail(client, email) {
+	const result = await client.users.lookupByEmail({ email });
+	if (result.ok && result.user) return {
+		id: result.user.id,
+		name: result.user.name,
+		realName: result.user.real_name,
+		displayName: result.user.profile?.display_name,
+		email: result.user.profile?.email,
+		isAdmin: result.user.is_admin,
+		isOwner: result.user.is_owner,
+		avatar: result.user.profile?.image_72,
+		tz: result.user.tz,
+		tzOffset: result.user.tz_offset
+	};
+	return null;
+}
+/**
+* List all members of a Slack workspace.
+*
+* Automatically paginates through results. Excludes deleted users and bots by default.
+*
+* @param client - Authenticated Slack WebClient
+* @param options - Optional filters
+* @param options.includeDeleted - Include deactivated users (default: false)
+* @param options.includeBots - Include bot users (default: false)
+* @param options.limit - Maximum number of users to return
+* @returns Array of user profile objects
+*/
+async function getSlackUsers(client, options = {}) {
+	const { includeDeleted = false, includeBots = false, limit } = options;
+	return (await paginateSlack({
+		fetchPage: (cursor) => client.users.list({
+			limit: 200,
+			cursor
+		}),
+		extractItems: (result) => {
+			if (!result.ok) throw new Error(`Slack API error during user listing: ${result.error}`);
+			return result.members ?? [];
+		},
+		getNextCursor: (result) => result.response_metadata?.next_cursor || void 0,
+		limit
+	})).filter((user) => {
+		if (!includeDeleted && user.deleted) return false;
+		if (!includeBots && (user.is_bot || user.id === "USLACKBOT")) return false;
+		return true;
+	}).map((user) => ({
+		id: user.id,
+		name: user.name,
+		realName: user.real_name,
+		displayName: user.profile?.display_name,
+		email: user.profile?.email,
+		isAdmin: user.is_admin,
+		isOwner: user.is_owner,
+		avatar: user.profile?.image_72,
+		tz: user.tz,
+		tzOffset: user.tz_offset
+	}));
+}
+/**
 * Fetch workspace (team) information from Slack.
 *
 * @param client - Authenticated Slack WebClient
@@ -272,6 +337,37 @@ async function checkUserIsChannelMember(client, channelId, userId) {
 	})).includes(userId);
 }
 /**
+* Open (or resume) a direct message conversation with a Slack user.
+*
+* @param client - Authenticated Slack WebClient
+* @param userId - Slack user ID to DM (e.g., U0ABC123)
+* @returns The DM channel ID
+*/
+async function openDmConversation(client, userId) {
+	const channelId = (await client.conversations.open({ users: userId })).channel?.id;
+	if (!channelId) throw new Error(`Failed to open DM conversation with user ${userId}`);
+	return channelId;
+}
+/**
+* Validate that the bot is a member of the given channels.
+*
+* @param client - Authenticated Slack WebClient
+* @param channelIds - Channel IDs to validate
+* @returns Object with valid and invalid channel ID arrays
+*/
+async function validateBotChannelMembership(client, channelIds) {
+	const botChannels = await getBotMemberChannels(client);
+	const memberChannelIds = new Set(botChannels.filter((ch) => !!ch.id).map((ch) => ch.id));
+	const valid = [];
+	const invalid = [];
+	for (const id of channelIds) if (memberChannelIds.has(id)) valid.push(id);
+	else invalid.push(id);
+	return {
+		valid,
+		invalid
+	};
+}
+/**
 * Revoke a Slack bot token.
 *
 * This should be called when uninstalling a workspace to ensure
@@ -301,4 +397,4 @@ async function revokeSlackToken(token) {
 }
 
 //#endregion
-export { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken };
+export { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserByEmail, getSlackUserInfo, getSlackUsers, openDmConversation, postMessage, postMessageInThread, revokeSlackToken, validateBotChannelMembership };

package/dist/slack/services/dev-config.js

@@ -74,7 +74,7 @@ function saveSlackDevConfig(config) {
 	const configPath = getDevConfigPath();
 	if (!configPath) return false;
 	try {
-		writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+		writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
 		cachedConfig = config;
 		cacheExpiresAt = Date.now() + CACHE_TTL_MS;
 		return true;

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

@@ -1,6 +1,6 @@
 import { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, lookupAgentName, lookupProjectName, resolveEffectiveAgent } from "./agent-resolution.js";
 import { AgentConfigSources, ContextBlockParams, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createContextBlockFromText, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
-import { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken } from "./client.js";
+import { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserByEmail, getSlackUserInfo, getSlackUsers, openDmConversation, postMessage, postMessageInThread, revokeSlackToken, validateBotChannelMembership } from "./client.js";
 import { DefaultAgentConfig, SlackWorkspaceConnection, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.js";
 import { SlackCommandPayload, SlackCommandResponse } from "./types.js";
 import { handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand } from "./commands/index.js";
@@ -15,4 +15,4 @@ import { handleModalSubmission } from "./events/modal-submission.js";
 import "./events/index.js";
 import { parseSlackCommandBody, parseSlackEventBody, verifySlackRequest } from "./security.js";
 import { getBotTokenForTeam, setBotTokenForTeam } from "./workspace-tokens.js";
-export { AgentConfigSources, AgentOption, AgentResolutionParams, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, ContextBlockParams, DefaultAgentConfig, InlineSelectorMetadata, ModalMetadata, PublicExecutionParams, ResolvedAgentConfig, SlackCommandPayload, SlackCommandResponse, SlackErrorType, SlackWorkspaceConnection, StreamResult, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, WorkspaceInstallData, buildAgentSelectorModal, buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createContextBlockFromText, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, executeAgentPublicly, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotMemberChannels, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleDirectMessage, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, lookupAgentName, lookupProjectName, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };
+export { AgentConfigSources, AgentOption, AgentResolutionParams, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, ContextBlockParams, DefaultAgentConfig, InlineSelectorMetadata, ModalMetadata, PublicExecutionParams, ResolvedAgentConfig, SlackCommandPayload, SlackCommandResponse, SlackErrorType, SlackWorkspaceConnection, StreamResult, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, WorkspaceInstallData, buildAgentSelectorModal, buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createContextBlockFromText, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, executeAgentPublicly, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotMemberChannels, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserByEmail, getSlackUserInfo, getSlackUsers, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleDirectMessage, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, lookupAgentName, lookupProjectName, markdownToMrkdwn, openDmConversation, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, validateBotChannelMembership, verifySlackRequest };

package/dist/slack/services/index.js

@@ -2,7 +2,7 @@ import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConn
 import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
 import { getAgentConfigSources, lookupAgentName, lookupProjectName, resolveEffectiveAgent } from "./agent-resolution.js";
 import { ToolApprovalButtonValueSchema, buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createContextBlockFromText, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
-import { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken } from "./client.js";
+import { checkUserIsChannelMember, getBotMemberChannels, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserByEmail, getSlackUserInfo, getSlackUsers, openDmConversation, postMessage, postMessageInThread, revokeSlackToken, validateBotChannelMembership } from "./client.js";
 import { streamAgentResponse } from "./events/streaming.js";
 import { executeAgentPublicly } from "./events/execution.js";
 import { buildAgentSelectorModal, buildMessageShortcutModal } from "./modals.js";
@@ -15,4 +15,4 @@ import "./events/index.js";
 import { parseSlackCommandBody, parseSlackEventBody, verifySlackRequest } from "./security.js";
 import { getBotTokenForTeam, setBotTokenForTeam } from "./workspace-tokens.js";
 
-export { SlackErrorType, ToolApprovalButtonValueSchema, buildAgentSelectorModal, buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createContextBlockFromText, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, executeAgentPublicly, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotMemberChannels, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleDirectMessage, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, lookupAgentName, lookupProjectName, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };
+export { SlackErrorType, ToolApprovalButtonValueSchema, buildAgentSelectorModal, buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createContextBlockFromText, createCreateInkeepAccountMessage, createErrorMessage, createNotLinkedMessage, createSmartLinkMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, executeAgentPublicly, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotMemberChannels, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserByEmail, getSlackUserInfo, getSlackUsers, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleDirectMessage, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, lookupAgentName, lookupProjectName, markdownToMrkdwn, openDmConversation, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, validateBotChannelMembership, verifySlackRequest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-work-apps",
-  "version": "0.58.2",
+  "version": "0.58.4",
   "description": "First party integrations for Inkeep Agents",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -33,7 +33,7 @@
     "jose": "^6.1.0",
     "minimatch": "^10.2.1",
     "slack-block-builder": "^2.8.0",
-    "@inkeep/agents-core": "0.58.2"
+    "@inkeep/agents-core": "0.58.4"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",