@inkeep/agents-work-apps 0.53.13 → 0.55.0

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

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

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

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

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

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

package/dist/slack/index.d.ts

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

package/dist/slack/index.js

@@ -1,5 +1,5 @@
-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 { 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";
 import { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.js";
 import { dispatchSlackEvent } from "./dispatcher.js";

package/dist/slack/routes/workspaces.js

@@ -1,11 +1,12 @@
 import { getLogger } from "../../logger.js";
 import runDbClient_default from "../../db/runDbClient.js";
-import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent } from "../services/nango.js";
+import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, listWorkspaceInstallations, setWorkspaceDefaultAgent } from "../services/nango.js";
+import { lookupAgentName } from "../services/agent-resolution.js";
 import { getBotMemberChannels, getSlackChannels, getSlackClient, revokeSlackToken } from "../services/client.js";
 import "../services/index.js";
 import { requireChannelMemberOrAdmin, requireWorkspaceAdmin } from "../middleware/permissions.js";
 import { OpenAPIHono, z } from "@hono/zod-openapi";
-import { deleteAllWorkAppSlackChannelAgentConfigsByTeam, deleteAllWorkAppSlackUserMappingsByTeam, deleteWorkAppSlackChannelAgentConfig, deleteWorkAppSlackWorkspaceByNangoConnectionId, findWorkAppSlackChannelAgentConfig, findWorkAppSlackWorkspaceByTeamId, listWorkAppSlackChannelAgentConfigsByTeam, listWorkAppSlackUserMappingsByTeam, updateWorkAppSlackWorkspace, upsertWorkAppSlackChannelAgentConfig } from "@inkeep/agents-core";
+import { WorkAppSlackAgentConfigRequestSchema, 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
@@ -40,14 +41,8 @@ function verifyTenantOwnership(c, workspaceTenantId) {
 	return sessionTenantId === workspaceTenantId;
 }
 const app = new OpenAPIHono();
-const ChannelAgentConfigSchema = z.object({
-	projectId: z.string(),
-	agentId: z.string(),
-	agentName: z.string().optional(),
-	projectName: z.string().optional(),
-	grantAccessToMembers: z.boolean().optional()
-});
-const WorkspaceSettingsSchema = z.object({ defaultAgent: ChannelAgentConfigSchema.optional() });
+const WorkspaceSettingsResponseSchema = z.object({ defaultAgent: WorkAppSlackAgentConfigRequestSchema.optional() });
+const WorkspaceSettingsRequestSchema = z.object({ defaultAgent: WorkAppSlackAgentConfigRequestSchema.optional() });
 const JoinFromWorkspaceSettingsSchema = z.object({ shouldAllowJoinFromWorkspace: z.boolean() });
 app.openapi(createProtectedRoute({
 	method: "get",
@@ -75,27 +70,38 @@ app.openapi(createProtectedRoute({
 	} }
 }), async (c) => {
 	try {
-		const allWorkspaces = await listWorkspaceInstallations();
 		const sessionTenantId = c.get("tenantId");
 		if (!sessionTenantId) {
 			logger.warn({}, "No tenantId in session context — cannot list workspaces");
 			return c.json({ workspaces: [] });
 		}
-		const workspaces = allWorkspaces.filter((w) => w.tenantId === sessionTenantId);
+		const workspaces = await listWorkspaceInstallations(sessionTenantId);
 		logger.info({
 			count: workspaces.length,
-			totalCount: allWorkspaces.length,
 			tenantId: sessionTenantId
 		}, "Listed workspace installations");
-		return c.json({ workspaces: workspaces.map((w) => ({
-			connectionId: w.connectionId,
-			teamId: w.teamId,
-			teamName: w.teamName,
-			teamDomain: w.teamDomain,
-			tenantId: w.tenantId,
-			hasDefaultAgent: !!w.defaultAgent,
-			defaultAgentName: w.defaultAgent?.agentName
-		})) });
+		const workspacesWithNames = await Promise.all(workspaces.map(async (w) => {
+			let defaultAgentName;
+			if (w.defaultAgent?.agentId && w.defaultAgent.projectId) try {
+				defaultAgentName = await lookupAgentName(w.tenantId, w.defaultAgent.projectId, w.defaultAgent.agentId, { skipCache: true });
+			} catch {
+				logger.warn({
+					tenantId: w.tenantId,
+					teamId: w.teamId,
+					projectId: w.defaultAgent.projectId,
+					agentId: w.defaultAgent.agentId
+				}, "Failed to resolve default agent name for workspace listing");
+			}
+			return {
+				connectionId: w.connectionId,
+				teamId: w.teamId,
+				teamName: w.teamName,
+				tenantId: w.tenantId,
+				hasDefaultAgent: !!w.defaultAgent,
+				defaultAgentName: defaultAgentName || w.defaultAgent?.agentId
+			};
+		}));
+		return c.json({ workspaces: workspacesWithNames });
 	} catch (error) {
 		logger.error({ error }, "Failed to list workspaces");
 		return c.json({ workspaces: [] });
@@ -122,7 +128,7 @@ app.openapi(createProtectedRoute({
 				teamName: z.string().optional(),
 				tenantId: z.string(),
 				connectionId: z.string(),
-				defaultAgent: ChannelAgentConfigSchema.optional()
+				defaultAgent: WorkAppSlackAgentConfigRequestSchema.optional()
 			}) } }
 		},
 		404: { description: "Workspace not found" }
@@ -131,19 +137,16 @@ app.openapi(createProtectedRoute({
 	const { teamId } = c.req.valid("param");
 	const workspace = await findWorkspaceConnectionByTeamId(teamId);
 	if (!workspace || !verifyTenantOwnership(c, workspace.tenantId)) return c.json({ error: "Workspace not found" }, 404);
-	let defaultAgent;
-	const nangoDefault = await getWorkspaceDefaultAgentFromNango(teamId);
-	if (nangoDefault) defaultAgent = {
-		projectId: nangoDefault.projectId,
-		agentId: nangoDefault.agentId,
-		agentName: nangoDefault.agentName
-	};
 	return c.json({
 		teamId: workspace.teamId,
 		teamName: workspace.teamName,
 		tenantId: workspace.tenantId,
 		connectionId: workspace.connectionId,
-		defaultAgent
+		defaultAgent: workspace.defaultAgent ? {
+			projectId: workspace.defaultAgent.projectId,
+			agentId: workspace.defaultAgent.agentId,
+			grantAccessToMembers: workspace.defaultAgent.grantAccessToMembers
+		} : void 0
 	});
 });
 app.openapi(createProtectedRoute({
@@ -161,7 +164,7 @@ app.openapi(createProtectedRoute({
 	request: { params: z.object({ teamId: z.string() }) },
 	responses: { 200: {
 		description: "Workspace settings",
-		content: { "application/json": { schema: WorkspaceSettingsSchema } }
+		content: { "application/json": { schema: WorkspaceSettingsResponseSchema } }
 	} }
 }), async (c) => {
 	const { teamId } = c.req.valid("param");
@@ -170,15 +173,11 @@ app.openapi(createProtectedRoute({
 		logger.warn({ teamId }, "Workspace not found or tenant mismatch");
 		return c.json({ defaultAgent: void 0 });
 	}
-	let defaultAgent;
-	const nangoDefault = await getWorkspaceDefaultAgentFromNango(teamId);
-	if (nangoDefault) defaultAgent = {
-		projectId: nangoDefault.projectId,
-		agentId: nangoDefault.agentId,
-		agentName: nangoDefault.agentName,
-		projectName: nangoDefault.projectName
-	};
-	return c.json({ defaultAgent });
+	return c.json({ defaultAgent: workspace.defaultAgent ? {
+		projectId: workspace.defaultAgent.projectId,
+		agentId: workspace.defaultAgent.agentId,
+		grantAccessToMembers: workspace.defaultAgent.grantAccessToMembers
+	} : void 0 });
 });
 app.openapi(createProtectedRoute({
 	method: "put",
@@ -194,31 +193,46 @@ app.openapi(createProtectedRoute({
 	permission: requireWorkspaceAdmin(),
 	request: {
 		params: z.object({ teamId: z.string() }),
-		body: { content: { "application/json": { schema: WorkspaceSettingsSchema } } }
+		body: { content: { "application/json": { schema: WorkspaceSettingsRequestSchema } } }
 	},
 	responses: {
 		200: {
 			description: "Settings updated",
 			content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
 		},
-		500: {
-			description: "Failed to update settings",
-			content: { "application/json": { schema: z.object({ success: z.boolean() }) } }
-		}
+		400: { description: "Agent not found" },
+		500: { description: "Failed to update settings" }
 	}
 }), async (c) => {
 	const { teamId } = c.req.valid("param");
 	const body = c.req.valid("json");
 	if (body.defaultAgent) {
+		const workspace = await findWorkspaceConnectionByTeamId(teamId);
+		if (!workspace) return c.json({ success: false }, 500);
+		let agentName;
+		try {
+			agentName = await lookupAgentName(workspace.tenantId, body.defaultAgent.projectId, body.defaultAgent.agentId, {
+				skipCache: true,
+				throwOnError: true
+			});
+		} catch (error) {
+			logger.error({
+				error,
+				teamId,
+				projectId: body.defaultAgent.projectId,
+				agentId: body.defaultAgent.agentId
+			}, "Agent lookup failed during workspace default validation");
+			return c.json({ error: "Unable to validate agent — please try again" }, 503);
+		}
+		if (!agentName) return c.json({ error: `Agent '${body.defaultAgent.agentId}' not found in project '${body.defaultAgent.projectId}'` }, 400);
 		if (!await setWorkspaceDefaultAgent(teamId, body.defaultAgent)) {
-			logger.warn({ teamId }, "Failed to persist workspace settings to Nango");
+			logger.warn({ teamId }, "Failed to persist workspace settings");
 			return c.json({ success: false }, 500);
 		}
 		logger.info({
 			teamId,
-			agentId: body.defaultAgent.agentId,
-			agentName: body.defaultAgent.agentName
-		}, "Saved workspace default agent to Nango");
+			agentId: body.defaultAgent.agentId
+		}, "Saved workspace default agent");
 	} else {
 		await setWorkspaceDefaultAgent(teamId, null);
 		logger.info({ teamId }, "Cleared workspace default agent");
@@ -409,7 +423,7 @@ app.openapi(createProtectedRoute({
 					isShared: z.boolean(),
 					memberCount: z.number().optional(),
 					hasAgentConfig: z.boolean(),
-					agentConfig: ChannelAgentConfigSchema.optional()
+					agentConfig: WorkAppSlackAgentConfigRequestSchema.optional()
 				})),
 				nextCursor: z.string().optional()
 			}) } }
@@ -447,7 +461,6 @@ app.openapi(createProtectedRoute({
 				agentConfig: config ? {
 					projectId: config.projectId,
 					agentId: config.agentId,
-					agentName: config.agentName || void 0,
 					grantAccessToMembers: config.grantAccessToMembers
 				} : void 0
 			};
@@ -484,7 +497,7 @@ app.openapi(createProtectedRoute({
 		description: "Channel settings",
 		content: { "application/json": { schema: z.object({
 			channelId: z.string(),
-			agentConfig: ChannelAgentConfigSchema.optional()
+			agentConfig: WorkAppSlackAgentConfigRequestSchema.optional()
 		}) } }
 	} }
 }), async (c) => {
@@ -504,7 +517,6 @@ app.openapi(createProtectedRoute({
 		agentConfig: config ? {
 			projectId: config.projectId,
 			agentId: config.agentId,
-			agentName: config.agentName || void 0,
 			grantAccessToMembers: config.grantAccessToMembers
 		} : void 0
 	});
@@ -527,18 +539,21 @@ app.openapi(createProtectedRoute({
 			channelId: z.string()
 		}),
 		body: { content: { "application/json": { schema: z.object({
-			agentConfig: ChannelAgentConfigSchema,
+			agentConfig: WorkAppSlackAgentConfigRequestSchema,
 			channelName: z.string().optional(),
 			channelType: z.string().optional()
 		}) } } }
 	},
-	responses: { 200: {
-		description: "Channel settings updated",
-		content: { "application/json": { schema: z.object({
-			success: z.boolean(),
-			configId: z.string()
-		}) } }
-	} }
+	responses: {
+		200: {
+			description: "Channel settings updated",
+			content: { "application/json": { schema: z.object({
+				success: z.boolean(),
+				configId: z.string()
+			}) } }
+		},
+		400: { description: "Agent not found" }
+	}
 }), async (c) => {
 	const { teamId, channelId } = c.req.valid("param");
 	const body = c.req.valid("json");
@@ -551,6 +566,23 @@ app.openapi(createProtectedRoute({
 		});
 	}
 	const tenantId = workspace.tenantId;
+	let agentName;
+	try {
+		agentName = await lookupAgentName(tenantId, body.agentConfig.projectId, body.agentConfig.agentId, {
+			skipCache: true,
+			throwOnError: true
+		});
+	} catch (error) {
+		logger.error({
+			error,
+			teamId,
+			tenantId,
+			projectId: body.agentConfig.projectId,
+			agentId: body.agentConfig.agentId
+		}, "Agent lookup failed during channel config validation");
+		return c.json({ error: "Unable to validate agent — please try again" }, 503);
+	}
+	if (!agentName) return c.json({ error: `Agent '${body.agentConfig.agentId}' not found in project '${body.agentConfig.projectId}'` }, 400);
 	const config = await upsertWorkAppSlackChannelAgentConfig(runDbClient_default)({
 		tenantId,
 		slackTeamId: teamId,
@@ -559,7 +591,6 @@ app.openapi(createProtectedRoute({
 		slackChannelType: body.channelType,
 		projectId: body.agentConfig.projectId,
 		agentId: body.agentConfig.agentId,
-		agentName: body.agentConfig.agentName,
 		grantAccessToMembers: body.agentConfig.grantAccessToMembers ?? true,
 		enabled: true
 	});
@@ -589,7 +620,7 @@ app.openapi(createProtectedRoute({
 		params: z.object({ teamId: z.string() }),
 		body: { content: { "application/json": { schema: z.object({
 			channelIds: z.array(z.string()).min(1),
-			agentConfig: ChannelAgentConfigSchema
+			agentConfig: WorkAppSlackAgentConfigRequestSchema
 		}) } } }
 	},
 	responses: {
@@ -614,6 +645,23 @@ app.openapi(createProtectedRoute({
 	const workspace = await findWorkspaceConnectionByTeamId(teamId);
 	if (!workspace?.botToken || !verifyTenantOwnership(c, workspace.tenantId)) return c.json({ error: "Workspace not found or no bot token" }, 404);
 	const tenantId = workspace.tenantId;
+	let agentName;
+	try {
+		agentName = await lookupAgentName(tenantId, body.agentConfig.projectId, body.agentConfig.agentId, {
+			skipCache: true,
+			throwOnError: true
+		});
+	} catch (error) {
+		logger.error({
+			error,
+			teamId,
+			tenantId,
+			projectId: body.agentConfig.projectId,
+			agentId: body.agentConfig.agentId
+		}, "Agent lookup failed during bulk channel config validation");
+		return c.json({ error: "Unable to validate agent — please try again" }, 503);
+	}
+	if (!agentName) return c.json({ error: `Agent '${body.agentConfig.agentId}' not found in project '${body.agentConfig.projectId}'` }, 400);
 	const slackClient = getSlackClient(workspace.botToken);
 	let channels = [];
 	try {
@@ -646,7 +694,6 @@ app.openapi(createProtectedRoute({
 				slackChannelType: "public",
 				projectId: body.agentConfig.projectId,
 				agentId: body.agentConfig.agentId,
-				agentName: body.agentConfig.agentName,
 				grantAccessToMembers: body.agentConfig.grantAccessToMembers ?? true,
 				enabled: true
 			});

package/dist/slack/services/agent-resolution.d.ts

@@ -1,16 +1,18 @@
+import { WorkAppSlackAgentConfigRequest } from "@inkeep/agents-core";
+
 //#region src/slack/services/agent-resolution.d.ts
-/**
- * Slack Agent Resolution Service
- *
- * Determines which agent to use for a given Slack interaction.
- * Priority: Channel default > Workspace default (all admin-controlled)
- */
-/** Configuration for a resolved agent */
-interface ResolvedAgentConfig {
-  projectId: string;
-  projectName?: string;
-  agentId: string;
+
+declare function lookupAgentName(tenantId: string, projectId: string, agentId: string, options?: {
+  skipCache?: boolean;
+  throwOnError?: boolean;
+}): Promise<string | undefined>;
+declare function lookupProjectName(tenantId: string, projectId: string, options?: {
+  skipCache?: boolean;
+}): Promise<string | undefined>;
+/** Configuration for a resolved agent — extends the canonical config with resolution metadata */
+interface ResolvedAgentConfig extends WorkAppSlackAgentConfigRequest {
   agentName?: string;
+  projectName?: string;
   source: 'channel' | 'workspace' | 'none';
   grantAccessToMembers: boolean;
 }
@@ -40,4 +42,4 @@ declare function getAgentConfigSources(params: AgentResolutionParams): Promise<{
   effective: ResolvedAgentConfig | null;
 }>;
 //#endregion
-export { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, resolveEffectiveAgent };
+export { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, lookupAgentName, lookupProjectName, resolveEffectiveAgent };

package/dist/slack/services/agent-resolution.js

@@ -1,6 +1,6 @@
 import { getLogger } from "../../logger.js";
 import runDbClient_default from "../../db/runDbClient.js";
-import { getWorkspaceDefaultAgentFromNango } from "./nango.js";
+import { getWorkspaceDefaultAgent } from "./nango.js";
 import { fetchAgentsForProject, fetchProjectsForTenant } from "./events/utils.js";
 import { findWorkAppSlackChannelAgentConfig } from "@inkeep/agents-core";
 
@@ -15,11 +15,13 @@ const logger = getLogger("slack-agent-resolution");
 const AGENT_NAME_CACHE_TTL_MS = 300 * 1e3;
 const AGENT_NAME_CACHE_MAX_SIZE = 500;
 const agentNameCache = /* @__PURE__ */ new Map();
-async function lookupAgentName(tenantId, projectId, agentId) {
+async function lookupAgentName(tenantId, projectId, agentId, options) {
 	const cacheKey = `${tenantId}:${projectId}:${agentId}`;
-	const cached = agentNameCache.get(cacheKey);
-	if (cached && cached.expiresAt > Date.now()) return cached.name || void 0;
-	const agents = await fetchAgentsForProject(tenantId, projectId);
+	if (!options?.skipCache) {
+		const cached = agentNameCache.get(cacheKey);
+		if (cached && cached.expiresAt > Date.now()) return cached.name || void 0;
+	}
+	const agents = await fetchAgentsForProject(tenantId, projectId, { throwOnError: options?.throwOnError });
 	for (const agent of agents) {
 		const key = `${tenantId}:${projectId}:${agent.id}`;
 		agentNameCache.set(key, {
@@ -44,10 +46,12 @@ async function lookupAgentName(tenantId, projectId, agentId) {
 const PROJECT_NAME_CACHE_TTL_MS = 300 * 1e3;
 const PROJECT_NAME_CACHE_MAX_SIZE = 200;
 const projectNameCache = /* @__PURE__ */ new Map();
-async function lookupProjectName(tenantId, projectId) {
+async function lookupProjectName(tenantId, projectId, options) {
 	const cacheKey = `${tenantId}:${projectId}`;
-	const cached = projectNameCache.get(cacheKey);
-	if (cached && cached.expiresAt > Date.now()) return cached.name || void 0;
+	if (!options?.skipCache) {
+		const cached = projectNameCache.get(cacheKey);
+		if (cached && cached.expiresAt > Date.now()) return cached.name || void 0;
+	}
 	const projects = await fetchProjectsForTenant(tenantId);
 	for (const project of projects) {
 		const key = `${tenantId}:${project.id}`;
@@ -96,14 +100,13 @@ async function resolveEffectiveAgent(params) {
 			result = {
 				projectId: channelConfig.projectId,
 				agentId: channelConfig.agentId,
-				agentName: channelConfig.agentName || void 0,
 				source: "channel",
 				grantAccessToMembers: channelConfig.grantAccessToMembers
 			};
 		}
 	}
 	if (!result) {
-		const workspaceConfig = await getWorkspaceDefaultAgentFromNango(teamId);
+		const workspaceConfig = await getWorkspaceDefaultAgent(teamId);
 		if (workspaceConfig?.agentId && workspaceConfig.projectId) {
 			logger.info({
 				teamId,
@@ -112,25 +115,17 @@ async function resolveEffectiveAgent(params) {
 			}, "Resolved agent from workspace config");
 			result = {
 				projectId: workspaceConfig.projectId,
-				projectName: workspaceConfig.projectName,
 				agentId: workspaceConfig.agentId,
-				agentName: workspaceConfig.agentName,
 				source: "workspace",
 				grantAccessToMembers: workspaceConfig.grantAccessToMembers ?? true
 			};
 		}
 	}
-	if (result && (!result.agentName || result.agentName === result.agentId)) {
+	if (result) {
 		const name = await lookupAgentName(tenantId, result.projectId, result.agentId);
-		if (name) {
-			result.agentName = name;
-			logger.debug({
-				agentId: result.agentId,
-				agentName: name
-			}, "Enriched agent config with name from manage API");
-		}
+		if (name) result.agentName = name;
 	}
-	if (result && !result.projectName) {
+	if (result) {
 		const projectName = await lookupProjectName(tenantId, result.projectId);
 		if (projectName) result.projectName = projectName;
 	}
@@ -156,35 +151,29 @@ async function getAgentConfigSources(params) {
 		if (config?.enabled) channelConfig = {
 			projectId: config.projectId,
 			agentId: config.agentId,
-			agentName: config.agentName || void 0,
 			source: "channel",
 			grantAccessToMembers: config.grantAccessToMembers
 		};
 	}
-	const wsConfig = await getWorkspaceDefaultAgentFromNango(teamId);
+	const wsConfig = await getWorkspaceDefaultAgent(teamId);
 	if (wsConfig?.agentId && wsConfig.projectId) workspaceConfig = {
 		projectId: wsConfig.projectId,
-		projectName: wsConfig.projectName,
 		agentId: wsConfig.agentId,
-		agentName: wsConfig.agentName,
 		source: "workspace",
 		grantAccessToMembers: wsConfig.grantAccessToMembers ?? true
 	};
-	const effective = channelConfig || workspaceConfig;
-	if (effective && (!effective.agentName || effective.agentName === effective.agentId)) {
-		const name = await lookupAgentName(tenantId, effective.projectId, effective.agentId);
-		if (name) effective.agentName = name;
-	}
-	if (effective && !effective.projectName) {
-		const projectName = await lookupProjectName(tenantId, effective.projectId);
-		if (projectName) effective.projectName = projectName;
-	}
+	const configsToEnrich = [channelConfig, workspaceConfig].filter((c) => c !== null);
+	await Promise.all(configsToEnrich.map(async (config) => {
+		const [agentName, projectName] = await Promise.all([lookupAgentName(tenantId, config.projectId, config.agentId), lookupProjectName(tenantId, config.projectId)]);
+		if (agentName) config.agentName = agentName;
+		if (projectName) config.projectName = projectName;
+	}));
 	return {
 		channelConfig,
 		workspaceConfig,
-		effective
+		effective: channelConfig || workspaceConfig
 	};
 }
 
 //#endregion
-export { getAgentConfigSources, resolveEffectiveAgent };
+export { getAgentConfigSources, lookupAgentName, lookupProjectName, resolveEffectiveAgent };

package/dist/slack/services/events/direct-message.js

@@ -1,6 +1,7 @@
 import { getLogger } from "../../../logger.js";
 import { findWorkspaceConnectionByTeamId } from "../nango.js";
 import { classifyError, findCachedUserMapping, formatSlackQuery, generateSlackConversationId, getThreadContext, getUserFriendlyErrorMessage } from "./utils.js";
+import { lookupAgentName } from "../agent-resolution.js";
 import { SlackStrings } from "../../i18n/strings.js";
 import { getSlackClient, getSlackUserInfo } from "../client.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
@@ -53,7 +54,7 @@ async function handleDirectMessage(params) {
 			}
 			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 agentDisplayName = await lookupAgentName(tenantId, defaultAgent.projectId, defaultAgent.agentId) || defaultAgent.agentId;
 			const [existingLink, userInfo] = await Promise.all([findCachedUserMapping(tenantId, slackUserId, teamId), getSlackUserInfo(slackClient, slackUserId)]);
 			if (!existingLink) {
 				logger.info({

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

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

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

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

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

@@ -1,4 +1,5 @@
-import { DefaultAgentConfig, SlackWorkspaceConnection } from "../nango.js";
+import { ResolvedAgentConfig } from "../agent-resolution.js";
+import { SlackWorkspaceConnection } from "../nango.js";
 import { AgentOption } from "../modals.js";
 
 //#region src/slack/services/events/utils.d.ts
@@ -8,12 +9,12 @@ import { AgentOption } from "../modals.js";
  * Called on every @mention and /inkeep command — caching avoids redundant DB queries.
  */
 declare function findCachedUserMapping(tenantId: string, slackUserId: string, teamId: string, clientId?: string): Promise<{
-  id: string;
+  slackUserId: string;
   createdAt: string;
   updatedAt: string;
+  id: string;
   tenantId: string;
   clientId: string;
-  slackUserId: string;
   slackTeamId: string;
   slackEnterpriseId: string | null;
   inkeepUserId: string;
@@ -69,14 +70,16 @@ type ProjectOption = {
   name: string;
 };
 declare function fetchProjectsForTenant(tenantId: string): Promise<ProjectOption[]>;
-declare function fetchAgentsForProject(tenantId: string, projectId: string): Promise<AgentOption[]>;
-declare function getWorkspaceDefaultAgent(teamId: string): Promise<DefaultAgentConfig | null>;
-declare function getChannelAgentConfig(teamId: string, channelId: string): Promise<DefaultAgentConfig | null>;
+declare function fetchAgentsForProject(tenantId: string, projectId: string, options?: {
+  throwOnError?: boolean;
+}): Promise<AgentOption[]>;
+declare function getChannelAgentConfig(teamId: string, channelId: string): Promise<ResolvedAgentConfig | null>;
 /**
  * Resolve channel agent config using a pre-resolved workspace connection.
  * Avoids redundant workspace lookups when the connection is already available.
+ * Returns a ResolvedAgentConfig with enriched agent/project names and source metadata.
  */
-declare function resolveChannelAgentConfig(teamId: string, channelId: string, workspace: SlackWorkspaceConnection | null): Promise<DefaultAgentConfig | null>;
+declare function resolveChannelAgentConfig(teamId: string, channelId: string, workspace: SlackWorkspaceConnection | null): Promise<ResolvedAgentConfig | null>;
 declare function sendResponseUrlMessage(responseUrl: string, message: {
   text: string;
   response_type?: 'ephemeral' | 'in_channel';
@@ -191,4 +194,4 @@ interface FormatSlackQueryOptions {
 }
 declare function formatSlackQuery(options: FormatSlackQueryOptions): string;
 //#endregion
-export { FormatSlackQueryOptions, ProjectOption, SlackAttachment, SlackErrorType, checkIfBotThread, classifyError, escapeSlackLinkText, escapeSlackMrkdwn, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatAttachments, formatChannelContext, formatChannelLabel, formatMessageTimestamp, formatSlackQuery, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };
+export { FormatSlackQueryOptions, ProjectOption, SlackAttachment, SlackErrorType, checkIfBotThread, classifyError, escapeSlackLinkText, escapeSlackMrkdwn, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatAttachments, formatChannelContext, formatChannelLabel, formatMessageTimestamp, formatSlackQuery, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };

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

@@ -2,6 +2,7 @@ import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
 import runDbClient_default from "../../../db/runDbClient.js";
 import { findWorkspaceConnectionByTeamId } from "../nango.js";
+import { lookupAgentName, lookupProjectName } from "../agent-resolution.js";
 import { InternalServices, findWorkAppSlackChannelAgentConfig, findWorkAppSlackUserMapping, generateInternalServiceToken, getInProcessFetch } from "@inkeep/agents-core";
 
 //#region src/slack/services/events/utils.ts
@@ -175,7 +176,7 @@ async function fetchProjectsForTenant(tenantId) {
 		clearTimeout(timeout);
 	}
 }
-async function fetchAgentsForProject(tenantId, projectId) {
+async function fetchAgentsForProject(tenantId, projectId, options) {
 	const apiUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
 	const token = await generateInternalServiceToken({
 		serviceId: InternalServices.INKEEP_AGENTS_MANAGE_API,
@@ -202,6 +203,7 @@ async function fetchAgentsForProject(tenantId, projectId) {
 				projectId,
 				errorBody
 			}, "Failed to fetch agents from API");
+			if (options?.throwOnError) throw new Error(`Failed to fetch agents: ${response.status}`);
 			return [];
 		}
 		const result = await response.json();
@@ -222,37 +224,47 @@ async function fetchAgentsForProject(tenantId, projectId) {
 			tenantId,
 			projectId
 		}, "Error fetching agents from API");
+		if (options?.throwOnError) throw error;
 		return [];
 	} finally {
 		clearTimeout(timeout);
 	}
 }
-async function getWorkspaceDefaultAgent(teamId) {
-	const workspace = await findWorkspaceConnectionByTeamId(teamId);
-	if (workspace?.defaultAgent) {
-		logger.debug({ teamId }, "Found workspace default agent");
-		return workspace.defaultAgent;
-	}
-	return null;
-}
 async function getChannelAgentConfig(teamId, channelId) {
 	return resolveChannelAgentConfig(teamId, channelId, await findWorkspaceConnectionByTeamId(teamId));
 }
 /**
 * Resolve channel agent config using a pre-resolved workspace connection.
 * Avoids redundant workspace lookups when the connection is already available.
+* Returns a ResolvedAgentConfig with enriched agent/project names and source metadata.
 */
 async function resolveChannelAgentConfig(teamId, channelId, workspace) {
 	const tenantId = workspace?.tenantId;
 	if (!tenantId) return null;
 	const channelConfig = await findWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
-	if (channelConfig?.enabled) return {
-		projectId: channelConfig.projectId,
-		agentId: channelConfig.agentId,
-		agentName: channelConfig.agentName || channelConfig.agentId,
-		projectName: channelConfig.projectId
-	};
-	return workspace?.defaultAgent || null;
+	if (channelConfig?.enabled) {
+		const [agentName, projectName] = await Promise.all([lookupAgentName(tenantId, channelConfig.projectId, channelConfig.agentId), lookupProjectName(tenantId, channelConfig.projectId)]);
+		return {
+			projectId: channelConfig.projectId,
+			agentId: channelConfig.agentId,
+			agentName: agentName || channelConfig.agentId,
+			projectName: projectName || channelConfig.projectId,
+			source: "channel",
+			grantAccessToMembers: channelConfig.grantAccessToMembers
+		};
+	}
+	if (workspace?.defaultAgent) {
+		const [agentName, projectName] = await Promise.all([lookupAgentName(tenantId, workspace.defaultAgent.projectId, workspace.defaultAgent.agentId), lookupProjectName(tenantId, workspace.defaultAgent.projectId)]);
+		return {
+			projectId: workspace.defaultAgent.projectId,
+			agentId: workspace.defaultAgent.agentId,
+			agentName: agentName || workspace.defaultAgent.agentId,
+			projectName: projectName || workspace.defaultAgent.projectId,
+			source: "workspace",
+			grantAccessToMembers: workspace.defaultAgent.grantAccessToMembers ?? true
+		};
+	}
+	return null;
 }
 async function sendResponseUrlMessage(responseUrl, message) {
 	try {
@@ -487,4 +499,4 @@ Respond naturally as if you're joining the conversation to help.`;
 }
 
 //#endregion
-export { SlackErrorType, checkIfBotThread, classifyError, escapeSlackLinkText, escapeSlackMrkdwn, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatAttachments, formatChannelContext, formatChannelLabel, formatMessageTimestamp, formatSlackQuery, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };
+export { SlackErrorType, checkIfBotThread, classifyError, escapeSlackLinkText, escapeSlackMrkdwn, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, formatAttachments, formatChannelContext, formatChannelLabel, formatMessageTimestamp, formatSlackQuery, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, markdownToMrkdwn, resolveChannelAgentConfig, sendResponseUrlMessage, timedOp };

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

@@ -1,11 +1,11 @@
-import { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
+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 { DefaultAgentConfig, SlackWorkspaceConnection, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.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";
 import { AgentOption, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, ModalMetadata, buildAgentSelectorModal, buildMessageShortcutModal } from "./modals.js";
-import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
+import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
 import { InlineSelectorMetadata, handleAppMention } from "./events/app-mention.js";
 import { handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval } from "./events/block-actions.js";
 import { handleDirectMessage } from "./events/direct-message.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, 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, 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 };

package/dist/slack/services/index.js

@@ -1,6 +1,6 @@
-import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.js";
-import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
-import { getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
+import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.js";
+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 { streamAgentResponse } from "./events/streaming.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, 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, 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 };

package/dist/slack/services/link-prompt.d.ts

@@ -1,5 +1,5 @@
 import { SlackLinkIntent } from "@inkeep/agents-core";
-import * as slack_block_builder7 from "slack-block-builder";
+import * as slack_block_builder0 from "slack-block-builder";
 
 //#region src/slack/services/link-prompt.d.ts
 type LinkPromptResult = {
@@ -22,6 +22,6 @@ interface ResolveLinkActionParams {
   intent?: SlackLinkIntent;
 }
 declare function resolveUnlinkedUserAction(params: ResolveLinkActionParams): Promise<LinkPromptResult>;
-declare function buildLinkPromptMessage(result: LinkPromptResult): Readonly<slack_block_builder7.SlackMessageDto>;
+declare function buildLinkPromptMessage(result: LinkPromptResult): Readonly<slack_block_builder0.SlackMessageDto>;
 //#endregion
 export { LinkPromptResult, ResolveLinkActionParams, buildLinkPromptMessage, resolveUnlinkedUserAction };

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

@@ -1,3 +1,4 @@
+import { WorkAppSlackAgentConfigRequest } from "@inkeep/agents-core";
 import { Nango } from "@nangohq/node";
 
 //#region src/slack/services/nango.d.ts
@@ -13,13 +14,7 @@ declare function createConnectSession(params: {
   sessionToken: string;
 } | null>;
 declare function getConnectionAccessToken(connectionId: string): Promise<string | null>;
-interface DefaultAgentConfig {
-  agentId: string;
-  agentName?: string;
-  projectId: string;
-  projectName?: string;
-  grantAccessToMembers?: boolean;
-}
+type DefaultAgentConfig = WorkAppSlackAgentConfigRequest;
 interface SlackWorkspaceConnection {
   connectionId: string;
   teamId: string;
@@ -42,7 +37,9 @@ declare function findWorkspaceConnectionByTeamId(teamId: string): Promise<SlackW
 declare function clearWorkspaceConnectionCache(teamId?: string): void;
 declare function updateConnectionMetadata(connectionId: string, metadata: Record<string, string>): Promise<boolean>;
 declare function setWorkspaceDefaultAgent(teamId: string, defaultAgent: DefaultAgentConfig | null): Promise<boolean>;
-declare function getWorkspaceDefaultAgentFromNango(teamId: string): Promise<DefaultAgentConfig | null>;
+declare function getWorkspaceDefaultAgent(teamId: string): Promise<DefaultAgentConfig | null>;
+/** @deprecated Use `getWorkspaceDefaultAgent` instead */
+declare const getWorkspaceDefaultAgentFromNango: typeof getWorkspaceDefaultAgent;
 /**
  * Compute a stable, deterministic connection ID for a Slack workspace.
  * Format: "T:<team_id>" or "E:<enterprise_id>:T:<team_id>" for Enterprise Grid
@@ -78,12 +75,13 @@ declare function storeWorkspaceInstallation(data: WorkspaceInstallData): Promise
   success: boolean;
 }>;
 /**
- * List all workspace installations from Nango.
+ * List all workspace installations for a tenant.
+ * Reads workspace metadata from PostgreSQL and retrieves bot tokens from Nango.
  */
-declare function listWorkspaceInstallations(): Promise<SlackWorkspaceConnection[]>;
+declare function listWorkspaceInstallations(tenantId: string): Promise<SlackWorkspaceConnection[]>;
 /**
  * Delete a workspace installation from Nango.
  */
 declare function deleteWorkspaceInstallation(connectionId: string): Promise<boolean>;
 //#endregion
-export { DefaultAgentConfig, SlackWorkspaceConnection, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata };
+export { DefaultAgentConfig, SlackWorkspaceConnection, WorkspaceInstallData, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata };

package/dist/slack/services/nango.js

@@ -2,7 +2,7 @@ import { env } from "../../env.js";
 import { getLogger } from "../../logger.js";
 import runDbClient_default from "../../db/runDbClient.js";
 import { getDevDefaultAgent, isSlackDevMode, loadSlackDevConfig, saveSlackDevConfig } from "./dev-config.js";
-import { findWorkAppSlackWorkspaceBySlackTeamId, retryWithBackoff } from "@inkeep/agents-core";
+import { findWorkAppSlackWorkspaceBySlackTeamId, listWorkAppSlackWorkspacesByTenant, retryWithBackoff, updateWorkAppSlackWorkspace } from "@inkeep/agents-core";
 import { Nango } from "@nangohq/node";
 
 //#region src/slack/services/nango.ts
@@ -17,7 +17,6 @@ import { Nango } from "@nangohq/node";
 * Nango is used ONLY for:
 * - OAuth token storage and refresh (bot tokens for workspaces)
 * - OAuth flow management (createConnectSession)
-* - Workspace default agent config (stored in connection metadata)
 *
 * PERFORMANCE: Workspace lookups use PostgreSQL first (O(1)), with Nango
 * fallback only when needed for bot token retrieval.
@@ -146,16 +145,19 @@ async function findWorkspaceConnectionByTeamId(teamId) {
 		if (dbWorkspace?.nangoConnectionId) {
 			const botToken = await getConnectionAccessToken(dbWorkspace.nangoConnectionId);
 			if (botToken) {
+				const defaultAgent = dbWorkspace.defaultAgentId && dbWorkspace.defaultProjectId ? {
+					agentId: dbWorkspace.defaultAgentId,
+					projectId: dbWorkspace.defaultProjectId,
+					grantAccessToMembers: dbWorkspace.defaultGrantAccessToMembers ?? true
+				} : void 0;
 				const connection = {
 					connectionId: dbWorkspace.nangoConnectionId,
 					teamId,
 					teamName: dbWorkspace.slackTeamName || void 0,
 					botToken,
 					tenantId: dbWorkspace.tenantId,
-					defaultAgent: void 0
+					defaultAgent
 				};
-				const defaultAgentConfig = await getWorkspaceDefaultAgentFromNangoByConnectionId(dbWorkspace.nangoConnectionId);
-				if (defaultAgentConfig) connection.defaultAgent = defaultAgentConfig;
 				evictWorkspaceCache();
 				workspaceConnectionCache.set(teamId, {
 					connection,
@@ -175,23 +177,6 @@ async function findWorkspaceConnectionByTeamId(teamId) {
 		return findWorkspaceConnectionByTeamIdFromNango(teamId);
 	}
 }
-async function getWorkspaceDefaultAgentFromNangoByConnectionId(connectionId) {
-	if (isSlackDevMode()) return getDevDefaultAgent(loadSlackDevConfig());
-	try {
-		const nango = getSlackNango();
-		const integrationId = getSlackIntegrationId();
-		const metadata = (await nango.getConnection(integrationId, connectionId)).metadata;
-		if (metadata?.default_agent) try {
-			return JSON.parse(metadata.default_agent);
-		} catch {
-			return null;
-		}
-		return null;
-	} catch (error) {
-		logger.warn({ error }, "Failed to get workspace default agent from Nango");
-		return null;
-	}
-}
 /**
 * Legacy fallback: Find workspace by iterating all Nango connections.
 * Only used when PostgreSQL lookup fails.
@@ -207,17 +192,13 @@ async function findWorkspaceConnectionByTeamIdFromNango(teamId) {
 			const metadata = fullConn.metadata;
 			const credentials = fullConn;
 			if ((connectionConfig?.["team.id"] || metadata?.slack_team_id) === teamId && credentials.credentials?.access_token) {
-				let defaultAgent;
-				if (metadata?.default_agent) try {
-					defaultAgent = JSON.parse(metadata.default_agent);
-				} catch {}
 				const connection = {
 					connectionId: conn.connection_id,
 					teamId,
 					teamName: metadata?.slack_team_name,
 					botToken: credentials.credentials.access_token,
 					tenantId: metadata?.tenant_id || metadata?.inkeep_tenant_id || "",
-					defaultAgent
+					defaultAgent: void 0
 				};
 				evictWorkspaceCache();
 				workspaceConnectionCache.set(teamId, {
@@ -276,23 +257,32 @@ async function setWorkspaceDefaultAgent(teamId, defaultAgent) {
 	if (isSlackDevMode()) {
 		const devConfig = loadSlackDevConfig();
 		if (!devConfig) return false;
+		const persistedDevAgent = defaultAgent ? {
+			agentId: defaultAgent.agentId,
+			projectId: defaultAgent.projectId,
+			grantAccessToMembers: defaultAgent.grantAccessToMembers
+		} : null;
 		devConfig.metadata = {
 			...devConfig.metadata,
-			default_agent: defaultAgent ? JSON.stringify(defaultAgent) : ""
+			default_agent: persistedDevAgent ? JSON.stringify(persistedDevAgent) : ""
 		};
 		const saved = saveSlackDevConfig(devConfig);
 		if (saved) clearWorkspaceConnectionCache(teamId);
 		return saved;
 	}
 	try {
-		const workspace = await findWorkspaceConnectionByTeamId(teamId);
-		if (!workspace) {
-			logger.warn({ teamId }, "No workspace connection found to set default agent");
+		const dbWorkspace = await findWorkAppSlackWorkspaceBySlackTeamId(runDbClient_default)(teamId);
+		if (!dbWorkspace) {
+			logger.warn({ teamId }, "No workspace found in DB to set default agent");
 			return false;
 		}
-		const success = await updateConnectionMetadata(workspace.connectionId, { default_agent: defaultAgent ? JSON.stringify(defaultAgent) : "" });
-		if (success) clearWorkspaceConnectionCache(teamId);
-		return success;
+		const updated = await updateWorkAppSlackWorkspace(runDbClient_default)(dbWorkspace.id, {
+			defaultAgentId: defaultAgent?.agentId ?? null,
+			defaultProjectId: defaultAgent?.projectId ?? null,
+			defaultGrantAccessToMembers: defaultAgent?.grantAccessToMembers ?? null
+		});
+		if (updated) clearWorkspaceConnectionCache(teamId);
+		return !!updated;
 	} catch (error) {
 		logger.error({
 			error,
@@ -301,10 +291,16 @@ async function setWorkspaceDefaultAgent(teamId, defaultAgent) {
 		return false;
 	}
 }
-async function getWorkspaceDefaultAgentFromNango(teamId) {
+async function getWorkspaceDefaultAgent(teamId) {
 	if (isSlackDevMode()) return getDevDefaultAgent(loadSlackDevConfig());
 	try {
-		return (await findWorkspaceConnectionByTeamId(teamId))?.defaultAgent || null;
+		const dbWorkspace = await findWorkAppSlackWorkspaceBySlackTeamId(runDbClient_default)(teamId);
+		if (!dbWorkspace?.defaultAgentId || !dbWorkspace.defaultProjectId) return null;
+		return {
+			agentId: dbWorkspace.defaultAgentId,
+			projectId: dbWorkspace.defaultProjectId,
+			grantAccessToMembers: dbWorkspace.defaultGrantAccessToMembers ?? true
+		};
 	} catch (error) {
 		logger.error({
 			error,
@@ -313,6 +309,8 @@ async function getWorkspaceDefaultAgentFromNango(teamId) {
 		return null;
 	}
 }
+/** @deprecated Use `getWorkspaceDefaultAgent` instead */
+const getWorkspaceDefaultAgentFromNango = getWorkspaceDefaultAgent;
 /**
 * Compute a stable, deterministic connection ID for a Slack workspace.
 * Format: "T:<team_id>" or "E:<enterprise_id>:T:<team_id>" for Enterprise Grid
@@ -447,9 +445,10 @@ async function storeWorkspaceInstallation(data) {
 	}
 }
 /**
-* List all workspace installations from Nango.
+* List all workspace installations for a tenant.
+* Reads workspace metadata from PostgreSQL and retrieves bot tokens from Nango.
 */
-async function listWorkspaceInstallations() {
+async function listWorkspaceInstallations(tenantId) {
 	if (isSlackDevMode()) {
 		const devConfig = loadSlackDevConfig();
 		if (!devConfig) return [];
@@ -463,38 +462,31 @@ async function listWorkspaceInstallations() {
 		}];
 	}
 	try {
-		const nango = getSlackNango();
-		const integrationId = getSlackIntegrationId();
-		const connections = await nango.listConnections();
+		const dbWorkspaces = await listWorkAppSlackWorkspacesByTenant(runDbClient_default)(tenantId);
 		const workspaces = [];
-		for (const conn of connections.connections) if (conn.provider_config_key === integrationId) try {
-			const fullConn = await nango.getConnection(integrationId, conn.connection_id);
-			const metadata = fullConn.metadata;
-			const credentials = fullConn;
-			if (metadata?.connection_type === "workspace" && credentials.credentials?.access_token) {
-				let defaultAgent;
-				if (metadata?.default_agent) try {
-					defaultAgent = JSON.parse(metadata.default_agent);
-				} catch {}
-				workspaces.push({
-					connectionId: conn.connection_id,
-					teamId: metadata.slack_team_id || "",
-					teamName: metadata.slack_team_name,
-					teamDomain: metadata.slack_team_domain || void 0,
-					botToken: credentials.credentials.access_token,
-					tenantId: metadata.tenant_id || metadata.inkeep_tenant_id || "",
-					defaultAgent
-				});
-			}
-		} catch (error) {
-			logger.warn({
-				error,
-				connectionId: conn.connection_id
-			}, "Failed to get Nango connection during list");
-		}
+		await Promise.all(dbWorkspaces.map(async (ws) => {
+			const botToken = await getConnectionAccessToken(ws.nangoConnectionId);
+			if (!botToken) return;
+			const defaultAgent = ws.defaultAgentId && ws.defaultProjectId ? {
+				agentId: ws.defaultAgentId,
+				projectId: ws.defaultProjectId,
+				grantAccessToMembers: ws.defaultGrantAccessToMembers ?? true
+			} : void 0;
+			workspaces.push({
+				connectionId: ws.nangoConnectionId,
+				teamId: ws.slackTeamId,
+				teamName: ws.slackTeamName || void 0,
+				botToken,
+				tenantId: ws.tenantId,
+				defaultAgent
+			});
+		}));
 		return workspaces;
 	} catch (error) {
-		logger.error({ error }, "Failed to list workspace installations");
+		logger.error({
+			error,
+			tenantId
+		}, "Failed to list workspace installations");
 		return [];
 	}
 }
@@ -534,4 +526,4 @@ async function deleteWorkspaceInstallation(connectionId) {
 }
 
 //#endregion
-export { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata };
+export { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-work-apps",
-  "version": "0.53.13",
+  "version": "0.55.0",
   "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.53.13"
+    "@inkeep/agents-core": "0.55.0"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",