@inkeep/agents-work-apps 0.53.0 → 0.53.2

package/dist/slack/services/resume-intent.js

@@ -0,0 +1,338 @@
+import { env } from "../../env.js";
+import { getLogger } from "../../logger.js";
+import { findWorkspaceConnectionByTeamId } from "./nango.js";
+import { generateSlackConversationId, sendResponseUrlMessage } from "./events/utils.js";
+import { resolveEffectiveAgent } from "./agent-resolution.js";
+import { createContextBlock } from "./blocks/index.js";
+import { getSlackClient } from "./client.js";
+import { streamAgentResponse } from "./events/streaming.js";
+import { signSlackUserToken } from "@inkeep/agents-core";
+
+//#region src/slack/services/resume-intent.ts
+const logger = getLogger("slack-resume-intent");
+function getChannelAuthClaims(agentConfig, channelId) {
+	return {
+		slackAuthorized: agentConfig?.grantAccessToMembers ?? false,
+		slackAuthSource: agentConfig?.source && agentConfig.source !== "none" ? agentConfig.source : void 0,
+		slackChannelId: channelId,
+		slackAuthorizedProjectId: agentConfig?.projectId
+	};
+}
+async function resumeSmartLinkIntent(params) {
+	const { intent, teamId, slackUserId, inkeepUserId, tenantId, slackEnterpriseId } = params;
+	const startTime = Date.now();
+	try {
+		const botToken = (await findWorkspaceConnectionByTeamId(teamId))?.botToken;
+		if (!botToken) {
+			logger.error({
+				teamId,
+				entryPoint: intent.entryPoint
+			}, "No bot token available for resume");
+			return;
+		}
+		const slackClient = getSlackClient(botToken);
+		const tokenCtx = {
+			inkeepUserId,
+			tenantId,
+			slackTeamId: teamId,
+			slackUserId,
+			slackEnterpriseId
+		};
+		let resolvedAgentId;
+		let deliveryMethod;
+		switch (intent.entryPoint) {
+			case "mention":
+				resolvedAgentId = intent.agentId;
+				deliveryMethod = "streaming";
+				await resumeMention(intent, slackClient, tokenCtx, teamId, tenantId);
+				break;
+			case "question_command":
+				deliveryMethod = intent.responseUrl ? "response_url" : "bot_token";
+				await resumeCommand(intent, slackClient, tokenCtx, teamId, tenantId);
+				break;
+			case "run_command":
+				deliveryMethod = intent.responseUrl ? "response_url" : "bot_token";
+				await resumeRunCommand(intent, slackClient, tokenCtx, teamId, tenantId);
+				break;
+		}
+		const durationMs = Date.now() - startTime;
+		logger.info({
+			event: "smart_link_intent_resumed",
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId,
+			agentId: resolvedAgentId || intent.agentId,
+			deliveryMethod,
+			durationMs
+		}, "Smart link intent resumed");
+	} catch (error) {
+		logger.error({
+			event: "smart_link_intent_failed",
+			entryPoint: intent.entryPoint,
+			error: error instanceof Error ? error.message : String(error)
+		}, "Smart link intent resume failed");
+	}
+}
+async function resumeMention(intent, slackClient, tokenCtx, teamId, tenantId) {
+	const { slackUserId } = tokenCtx;
+	if (!intent.agentId || !intent.projectId) {
+		logger.error({
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId,
+			hasAgentId: !!intent.agentId,
+			hasProjectId: !!intent.projectId
+		}, "Mention intent missing agentId or projectId");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, intent.threadTs);
+		return;
+	}
+	const replyThreadTs = intent.threadTs || intent.messageTs;
+	if (!replyThreadTs) {
+		logger.error({
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId
+		}, "Mention intent missing threadTs and messageTs");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, "We couldn't resume your question due to a technical issue. Please try mentioning @Inkeep again.");
+		return;
+	}
+	const agentConfig = await resolveEffectiveAgent({
+		tenantId,
+		teamId,
+		channelId: intent.channelId
+	});
+	const slackUserToken = await signSlackUserToken({
+		...tokenCtx,
+		...getChannelAuthClaims(agentConfig, intent.channelId)
+	});
+	const ackMessage = await slackClient.chat.postMessage({
+		channel: intent.channelId,
+		thread_ts: replyThreadTs,
+		text: "_Answering your question..._"
+	});
+	const conversationId = generateSlackConversationId({
+		teamId,
+		threadTs: replyThreadTs,
+		channel: intent.channelId,
+		isDM: false,
+		agentId: intent.agentId
+	});
+	await streamAgentResponse({
+		slackClient,
+		channel: intent.channelId,
+		threadTs: replyThreadTs,
+		thinkingMessageTs: ackMessage.ts || "",
+		slackUserId,
+		teamId,
+		jwtToken: slackUserToken,
+		projectId: intent.projectId,
+		agentId: intent.agentId,
+		question: intent.question,
+		agentName: intent.agentId,
+		conversationId
+	});
+}
+async function resumeCommand(intent, slackClient, tokenCtx, teamId, tenantId) {
+	const { slackUserId } = tokenCtx;
+	const resolvedAgent = await resolveEffectiveAgent({
+		tenantId,
+		teamId,
+		channelId: intent.channelId,
+		userId: slackUserId
+	});
+	if (!resolvedAgent) {
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, "The agent couldn't be found. Try asking your question again.");
+		return;
+	}
+	await executeAndDeliver({
+		intent,
+		slackClient,
+		slackUserToken: await signSlackUserToken({
+			...tokenCtx,
+			...getChannelAuthClaims(resolvedAgent, intent.channelId)
+		}),
+		slackUserId,
+		teamId,
+		agentId: resolvedAgent.agentId,
+		agentName: resolvedAgent.agentName || resolvedAgent.agentId,
+		projectId: resolvedAgent.projectId
+	});
+}
+async function resumeRunCommand(intent, slackClient, tokenCtx, teamId, tenantId) {
+	const { slackUserId } = tokenCtx;
+	if (!intent.agentIdentifier) {
+		logger.error({
+			entryPoint: intent.entryPoint,
+			channelId: intent.channelId
+		}, "Run command intent missing agentIdentifier");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId);
+		return;
+	}
+	const agentConfig = await resolveEffectiveAgent({
+		tenantId,
+		teamId,
+		channelId: intent.channelId
+	});
+	const slackUserToken = await signSlackUserToken({
+		...tokenCtx,
+		...getChannelAuthClaims(agentConfig, intent.channelId)
+	});
+	const agentInfo = await findAgentByIdentifierViaApi(tenantId, intent.agentIdentifier, slackUserToken);
+	if (!agentInfo) {
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, `Agent "${intent.agentIdentifier}" couldn't be found. Try asking your question again.`);
+		return;
+	}
+	await executeAndDeliver({
+		intent,
+		slackClient,
+		slackUserToken,
+		slackUserId,
+		teamId,
+		agentId: agentInfo.id,
+		agentName: agentInfo.name || agentInfo.id,
+		projectId: agentInfo.projectId
+	});
+}
+async function findAgentByIdentifierViaApi(tenantId, identifier, authToken) {
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), 1e4);
+	try {
+		const projectsResponse = await fetch(`${apiBaseUrl}/manage/tenants/${tenantId}/projects`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${authToken}`
+			},
+			signal: controller.signal
+		});
+		if (!projectsResponse.ok) return null;
+		const projectsData = await projectsResponse.json();
+		const projects = projectsData.data || projectsData || [];
+		return (await Promise.all(projects.map(async (project) => {
+			try {
+				const agentsResponse = await fetch(`${apiBaseUrl}/manage/tenants/${tenantId}/projects/${project.id}/agents`, {
+					method: "GET",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${authToken}`
+					},
+					signal: controller.signal
+				});
+				if (!agentsResponse.ok) return [];
+				const agentsData = await agentsResponse.json();
+				return (agentsData.data || agentsData || []).map((agent) => ({
+					id: agent.id,
+					name: agent.name,
+					projectId: project.id
+				}));
+			} catch (error) {
+				logger.warn({
+					error: error instanceof Error ? error.message : String(error),
+					projectId: project.id
+				}, "Failed to fetch agents for project during identifier lookup");
+				return [];
+			}
+		}))).flat().find((a) => a.id === identifier || a.name?.toLowerCase() === identifier.toLowerCase()) || null;
+	} catch (error) {
+		const isTimeout = error instanceof Error && error.name === "AbortError";
+		logger.warn({
+			error: error instanceof Error ? error.message : String(error),
+			tenantId,
+			identifier,
+			isTimeout
+		}, "Failed to find agent by identifier");
+		return null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function executeAndDeliver(params) {
+	const { intent, slackClient, slackUserToken, slackUserId, teamId, agentId, agentName, projectId } = params;
+	const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), 3e4);
+	let response;
+	try {
+		response = await fetch(`${apiBaseUrl}/run/api/chat`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${slackUserToken}`,
+				"x-inkeep-project-id": projectId,
+				"x-inkeep-agent-id": agentId
+			},
+			body: JSON.stringify({
+				messages: [{
+					role: "user",
+					content: intent.question
+				}],
+				stream: false
+			}),
+			signal: controller.signal
+		});
+	} catch (error) {
+		clearTimeout(timeout);
+		if (error.name === "AbortError") logger.warn({
+			teamId,
+			timeoutMs: 3e4
+		}, "Resume agent execution timed out");
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+	if (!response.ok) {
+		logger.error({
+			status: response.status,
+			agentId,
+			projectId
+		}, "Resume run API call failed");
+		await postErrorToChannel(slackClient, intent.channelId, slackUserId, void 0, "Something went wrong while answering your question. Please try again.");
+		return;
+	}
+	const result = await response.json();
+	const assistantMessage = result.choices?.[0]?.message?.content || result.message?.content || "No response received";
+	const contextBlock = createContextBlock({ agentName });
+	if (intent.responseUrl) try {
+		await sendResponseUrlMessage(intent.responseUrl, {
+			response_type: "ephemeral",
+			text: assistantMessage,
+			blocks: [{
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: assistantMessage
+				}
+			}, contextBlock]
+		});
+		return;
+	} catch {
+		logger.warn({ channelId: intent.channelId }, "response_url delivery failed, falling back to bot channel post");
+	}
+	await slackClient.chat.postMessage({
+		channel: intent.channelId,
+		text: assistantMessage,
+		blocks: [{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: assistantMessage
+			}
+		}, contextBlock]
+	});
+}
+async function postErrorToChannel(slackClient, channelId, slackUserId, threadTs, message = "The agent couldn't be found. Try asking your question again.") {
+	try {
+		await slackClient.chat.postEphemeral({
+			channel: channelId,
+			user: slackUserId,
+			thread_ts: threadTs,
+			text: message
+		});
+	} catch (error) {
+		logger.warn({
+			error,
+			channelId
+		}, "Failed to post error message to Slack");
+	}
+}
+
+//#endregion
+export { resumeSmartLinkIntent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-work-apps",
-  "version": "0.53.0",
+  "version": "0.53.2",
   "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.1.1",
     "slack-block-builder": "^2.8.0",
-    "@inkeep/agents-core": "0.53.0"
+    "@inkeep/agents-core": "0.53.2"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",