@inkeep/agents-work-apps 0.50.6 → 0.52.0

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

@@ -1,9 +1,9 @@
 import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
-import { createContextBlock } from "../blocks/index.js";
+import { buildCitationsBlock, buildDataArtifactBlocks, buildDataComponentBlocks, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createContextBlock } from "../blocks/index.js";
 import { SlackErrorType, classifyError, extractApiErrorMessage, getUserFriendlyErrorMessage } from "./utils.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
-import { getInProcessFetch } from "@inkeep/agents-core";
+import { getInProcessFetch, retryWithBackoff } from "@inkeep/agents-core";
 
 //#region src/slack/services/events/streaming.ts
 /**
@@ -50,6 +50,10 @@ async function streamAgentResponse(params) {
 			projectId
 		}, "Starting streaming agent response");
 		const abortController = new AbortController();
+		const abortPromise = new Promise((_, reject) => {
+			abortController.signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("Stream timeout")), { once: true });
+		});
+		let reader;
 		const timeoutId = setTimeout(() => {
 			logger.warn({
 				channel,
@@ -177,7 +181,7 @@ async function streamAgentResponse(params) {
 				errorMessage
 			};
 		}
-		const reader = response.body.getReader();
+		reader = response.body.getReader();
 		const decoder = new TextDecoder();
 		let buffer = "";
 		let fullText = "";
@@ -187,10 +191,18 @@ async function streamAgentResponse(params) {
 			recipient_user_id: slackUserId,
 			thread_ts: threadTs
 		});
+		const pendingApprovalMessages = [];
+		const toolCallIdToName = /* @__PURE__ */ new Map();
+		const toolErrors = [];
+		const citations = [];
+		const summaryLabels = [];
+		let richMessageCount = 0;
+		let richMessageCapWarned = false;
+		const MAX_RICH_MESSAGES = 20;
 		try {
 			let agentCompleted = false;
 			while (true) {
-				const { done, value } = await reader.read();
+				const { done, value } = await Promise.race([reader.read(), abortPromise]);
 				if (done) break;
 				buffer += decoder.decode(value, { stream: true });
 				const lines = buffer.split("\n");
@@ -208,6 +220,149 @@ async function streamAgentResponse(params) {
 							}
 							continue;
 						}
+						if (data.type === "tool-approval-request" && conversationId) {
+							const toolName = data.toolName || "Tool";
+							const toolCallId = data.toolCallId;
+							const input = data.input;
+							const buttonValue = {
+								toolCallId,
+								conversationId,
+								projectId,
+								agentId,
+								slackUserId,
+								channel,
+								threadTs,
+								toolName
+							};
+							const approvalPost = await slackClient.chat.postMessage({
+								channel,
+								thread_ts: threadTs,
+								text: `Tool approval required: \`${toolName}\``,
+								blocks: buildToolApprovalBlocks({
+									toolName,
+									input,
+									buttonValue: JSON.stringify(buttonValue)
+								})
+							}).catch((e) => {
+								logger.warn({
+									error: e,
+									toolCallId
+								}, "Failed to post tool approval message");
+								return null;
+							});
+							if (approvalPost?.ts) pendingApprovalMessages.push({
+								messageTs: approvalPost.ts,
+								toolName,
+								toolCallId
+							});
+							clearTimeout(timeoutId);
+							continue;
+						}
+						if (data.type === "tool-input-available" && data.toolCallId && data.toolName) {
+							toolCallIdToName.set(String(data.toolCallId), String(data.toolName));
+							continue;
+						}
+						if (data.type === "tool-output-denied" && data.toolCallId) {
+							const idx = pendingApprovalMessages.findIndex((m) => m.toolCallId === data.toolCallId);
+							if (idx !== -1) pendingApprovalMessages.splice(idx, 1);
+							continue;
+						}
+						if (data.type === "tool-output-error" && data.toolCallId) {
+							const toolName = toolCallIdToName.get(String(data.toolCallId)) || "Tool";
+							toolErrors.push({
+								toolName,
+								errorText: String(data.errorText || "Unknown error")
+							});
+							continue;
+						}
+						if (data.type === "data-component" && data.data && typeof data.data === "object") {
+							if (richMessageCount < MAX_RICH_MESSAGES) {
+								const { blocks, overflowJson, componentType } = buildDataComponentBlocks({
+									id: String(data.id || ""),
+									data: data.data
+								});
+								if (overflowJson) {
+									const label = componentType || "data-component";
+									await retryWithBackoff(() => slackClient.files.uploadV2({
+										channel_id: channel,
+										thread_ts: threadTs,
+										filename: `${label}.json`,
+										content: overflowJson,
+										initial_comment: `📊 ${label}`
+									}), { label: "slack-file-upload" }).catch((e) => logger.warn({
+										error: e,
+										channel,
+										threadTs,
+										agentId,
+										componentType: label
+									}, "Failed to upload data component file"));
+								} else await slackClient.chat.postMessage({
+									channel,
+									thread_ts: threadTs,
+									text: "📊 Data component",
+									blocks
+								}).catch((e) => logger.warn({ error: e }, "Failed to post data component"));
+								richMessageCount++;
+							} else if (!richMessageCapWarned) {
+								logger.warn({
+									channel,
+									threadTs,
+									agentId,
+									eventType: "data-component",
+									MAX_RICH_MESSAGES
+								}, "MAX_RICH_MESSAGES cap reached — additional rich content will be dropped");
+								richMessageCapWarned = true;
+							}
+							continue;
+						}
+						if (data.type === "data-artifact" && data.data && typeof data.data === "object") {
+							const artifactData = data.data;
+							if (typeof artifactData.type === "string" && artifactData.type.toLowerCase() === "citation") {
+								const summary = artifactData.artifactSummary;
+								if (summary?.url && !citations.some((c) => c.url === summary.url)) citations.push({
+									title: summary.title,
+									url: summary.url
+								});
+							} else if (richMessageCount < MAX_RICH_MESSAGES) {
+								const { blocks, overflowContent, artifactName } = buildDataArtifactBlocks({ data: artifactData });
+								if (overflowContent) {
+									const label = artifactName || "artifact";
+									await retryWithBackoff(() => slackClient.files.uploadV2({
+										channel_id: channel,
+										thread_ts: threadTs,
+										filename: `${label}.md`,
+										content: overflowContent,
+										initial_comment: `📄 ${label}`
+									}), { label: "slack-file-upload" }).catch((e) => logger.warn({
+										error: e,
+										channel,
+										threadTs,
+										agentId,
+										artifactName: label
+									}, "Failed to upload artifact file"));
+								} else await slackClient.chat.postMessage({
+									channel,
+									thread_ts: threadTs,
+									text: "📄 Data",
+									blocks
+								}).catch((e) => logger.warn({ error: e }, "Failed to post data artifact"));
+								richMessageCount++;
+							} else if (!richMessageCapWarned) {
+								logger.warn({
+									channel,
+									threadTs,
+									agentId,
+									eventType: "data-artifact",
+									MAX_RICH_MESSAGES
+								}, "MAX_RICH_MESSAGES cap reached — additional rich content will be dropped");
+								richMessageCapWarned = true;
+							}
+							continue;
+						}
+						if (data.type === "data-summary" && data.data?.label) {
+							summaryLabels.push(String(data.data.label));
+							continue;
+						}
 						if (data.type === "text-start" || data.type === "text-end") continue;
 						if (data.type === "text-delta" && data.delta) {
 							fullText += data.delta;
@@ -225,9 +380,12 @@ async function streamAgentResponse(params) {
 				if (agentCompleted) break;
 			}
 			clearTimeout(timeoutId);
-			const contextBlock = createContextBlock({ agentName });
+			const stopBlocks = [];
+			for (const { toolName, errorText } of toolErrors) stopBlocks.push(buildToolOutputErrorBlock(toolName, errorText));
+			if (summaryLabels.length > 0) stopBlocks.push(buildSummaryBreadcrumbBlock(summaryLabels));
+			stopBlocks.push(createContextBlock({ agentName }));
 			try {
-				await withTimeout(streamer.stop({ blocks: [contextBlock] }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.stop");
+				await withTimeout(streamer.stop({ blocks: stopBlocks.slice(0, 50) }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.stop");
 			} catch (stopError) {
 				span.setAttribute(SLACK_SPAN_KEYS.STREAM_FINALIZATION_FAILED, true);
 				logger.warn({
@@ -237,6 +395,15 @@ async function streamAgentResponse(params) {
 					responseLength: fullText.length
 				}, "Failed to finalize chatStream — content was already delivered");
 			}
+			if (citations.length > 0) {
+				const citationBlocks = buildCitationsBlock(citations);
+				if (citationBlocks.length > 0) await slackClient.chat.postMessage({
+					channel,
+					thread_ts: threadTs,
+					text: "📚 Sources",
+					blocks: citationBlocks
+				}).catch((e) => logger.warn({ error: e }, "Failed to post citations"));
+			}
 			if (thinkingMessageTs) try {
 				await slackClient.chat.delete({
 					channel,
@@ -250,13 +417,26 @@ async function streamAgentResponse(params) {
 				threadTs,
 				responseLength: fullText.length,
 				agentId,
-				conversationId
+				conversationId,
+				toolErrorCount: toolErrors.length,
+				citationCount: citations.length,
+				richMessageCount
 			}, "Streaming completed");
 			span.end();
 			return { success: true };
 		} catch (streamError) {
 			clearTimeout(timeoutId);
+			reader?.cancel().catch(() => {});
 			if (streamError instanceof Error) setSpanWithError(span, streamError);
+			for (const { messageTs, toolName } of pendingApprovalMessages) await slackClient.chat.update({
+				channel,
+				ts: messageTs,
+				text: `⏱️ Expired · \`${toolName}\``,
+				blocks: buildToolApprovalExpiredBlocks({ toolName })
+			}).catch((e) => logger.warn({
+				error: e,
+				messageTs
+			}, "Failed to expire approval message"));
 			if (fullText.length > 0) {
 				span.setAttribute(SLACK_SPAN_KEYS.CONTENT_ALREADY_DELIVERED, true);
 				logger.warn({
@@ -275,6 +455,22 @@ async function streamAgentResponse(params) {
 				span.end();
 				return { success: true };
 			}
+			if (pendingApprovalMessages.length > 0) {
+				for (const { toolName } of pendingApprovalMessages) await slackClient.chat.postMessage({
+					channel,
+					thread_ts: threadTs,
+					text: `Approval for \`${toolName}\` has expired.`
+				}).catch((e) => logger.warn({ error: e }, "Failed to send approval expired notification"));
+				await withTimeout(streamer.stop(), CLEANUP_TIMEOUT_MS, "streamer.stop-cleanup").catch((e) => logger.warn({ error: e }, "Failed to stop streamer during error cleanup"));
+				if (thinkingMessageTs) try {
+					await slackClient.chat.delete({
+						channel,
+						ts: thinkingMessageTs
+					});
+				} catch {}
+				span.end();
+				return { success: true };
+			}
 			logger.error({ streamError }, "Error during Slack streaming");
 			await withTimeout(streamer.stop(), CLEANUP_TIMEOUT_MS, "streamer.stop-cleanup").catch((e) => logger.warn({ error: e }, "Failed to stop streamer during error cleanup"));
 			if (thinkingMessageTs) try {

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

@@ -8,12 +8,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;

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

@@ -239,9 +239,12 @@ async function resolveChannelAgentConfig(teamId, channelId, workspace) {
 async function sendResponseUrlMessage(responseUrl, message) {
 	try {
 		const payload = { text: message.text };
-		if (message.replace_original) payload.replace_original = true;
+		if (message.replace_original === true) payload.replace_original = true;
 		else if (message.delete_original) payload.delete_original = true;
-		else if (message.response_type) payload.response_type = message.response_type;
+		else {
+			payload.replace_original = false;
+			if (message.response_type) payload.response_type = message.response_type;
+		}
 		if (message.blocks) payload.blocks = message.blocks;
 		logger.info({
 			hasBlocks: !!message.blocks,

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

@@ -1,11 +1,11 @@
 import { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
-import { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, buildConversationResponseBlocks, buildFollowUpButton, createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
+import { AgentConfigSources, ContextBlockParams, FollowUpButtonParams, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
 import { checkUserIsChannelMember, 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 { SlackCommandPayload, SlackCommandResponse } from "./types.js";
 import { handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand } from "./commands/index.js";
 import { InlineSelectorMetadata, handleAppMention } from "./events/app-mention.js";
-import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal } from "./events/block-actions.js";
+import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval } from "./events/block-actions.js";
 import { handleFollowUpSubmission, handleModalSubmission } from "./events/modal-submission.js";
 import { AgentOption, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, FollowUpModalMetadata, ModalMetadata, buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "./modals.js";
 import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
@@ -13,4 +13,4 @@ import { StreamResult, streamAgentResponse } from "./events/streaming.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, FollowUpButtonParams, FollowUpModalMetadata, InlineSelectorMetadata, ModalMetadata, ResolvedAgentConfig, SlackCommandPayload, SlackCommandResponse, SlackErrorType, SlackWorkspaceConnection, StreamResult, WorkspaceInstallData, buildAgentSelectorModal, buildConversationResponseBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };
+export { AgentConfigSources, AgentOption, AgentResolutionParams, BuildAgentSelectorModalParams, BuildMessageShortcutModalParams, ContextBlockParams, DefaultAgentConfig, FollowUpButtonParams, FollowUpModalMetadata, InlineSelectorMetadata, ModalMetadata, ResolvedAgentConfig, SlackCommandPayload, SlackCommandResponse, SlackErrorType, SlackWorkspaceConnection, StreamResult, ToolApprovalButtonValue, ToolApprovalButtonValueSchema, WorkspaceInstallData, buildAgentSelectorModal, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };

package/dist/slack/services/index.js

@@ -1,16 +1,16 @@
 import { clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createConnectSession, deleteWorkspaceInstallation, findWorkspaceConnectionByTeamId, getConnectionAccessToken, getSlackIntegrationId, getSlackNango, getWorkspaceDefaultAgentFromNango, listWorkspaceInstallations, setWorkspaceDefaultAgent, storeWorkspaceInstallation, updateConnectionMetadata } from "./nango.js";
 import { getAgentConfigSources, resolveEffectiveAgent } from "./agent-resolution.js";
-import { buildConversationResponseBlocks, buildFollowUpButton, createAlreadyLinkedMessage, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
+import { ToolApprovalButtonValueSchema, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, createAlreadyLinkedMessage, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage } from "./blocks/index.js";
 import { checkUserIsChannelMember, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackTeamInfo, getSlackUserInfo, postMessage, postMessageInThread, revokeSlackToken } from "./client.js";
 import { SlackErrorType, checkIfBotThread, classifyError, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, generateSlackConversationId, getChannelAgentConfig, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, markdownToMrkdwn, sendResponseUrlMessage } from "./events/utils.js";
 import { buildAgentSelectorModal, buildFollowUpModal, buildMessageShortcutModal } from "./modals.js";
 import { handleAgentPickerCommand, handleCommand, handleHelpCommand, handleLinkCommand, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand } from "./commands/index.js";
 import { streamAgentResponse } from "./events/streaming.js";
 import { handleAppMention } from "./events/app-mention.js";
-import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal } from "./events/block-actions.js";
+import { handleMessageShortcut, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleToolApproval } from "./events/block-actions.js";
 import { handleFollowUpSubmission, 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 { SlackErrorType, buildAgentSelectorModal, buildConversationResponseBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };
+export { SlackErrorType, ToolApprovalButtonValueSchema, buildAgentSelectorModal, buildCitationsBlock, buildConversationResponseBlocks, buildDataArtifactBlocks, buildDataComponentBlocks, buildFollowUpButton, buildFollowUpModal, buildMessageShortcutModal, buildSummaryBreadcrumbBlock, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, buildToolApprovalExpiredBlocks, buildToolOutputErrorBlock, checkIfBotThread, checkUserIsChannelMember, classifyError, clearWorkspaceConnectionCache, computeWorkspaceConnectionId, createAlreadyLinkedMessage, createConnectSession, createContextBlock, createCreateInkeepAccountMessage, createErrorMessage, createJwtLinkMessage, createNotLinkedMessage, createStatusMessage, createUnlinkSuccessMessage, createUpdatedHelpMessage, deleteWorkspaceInstallation, extractApiErrorMessage, fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, findWorkspaceConnectionByTeamId, generateSlackConversationId, getAgentConfigSources, getBotTokenForTeam, getChannelAgentConfig, getConnectionAccessToken, getSlackChannelInfo, getSlackChannels, getSlackClient, getSlackIntegrationId, getSlackNango, getSlackTeamInfo, getSlackUserInfo, getThreadContext, getUserFriendlyErrorMessage, getWorkspaceDefaultAgent, getWorkspaceDefaultAgentFromNango, handleAgentPickerCommand, handleAppMention, handleCommand, handleFollowUpSubmission, handleHelpCommand, handleLinkCommand, handleMessageShortcut, handleModalSubmission, handleOpenAgentSelectorModal, handleOpenFollowUpModal, handleQuestionCommand, handleStatusCommand, handleToolApproval, handleUnlinkCommand, listWorkspaceInstallations, markdownToMrkdwn, parseSlackCommandBody, parseSlackEventBody, postMessage, postMessageInThread, resolveEffectiveAgent, revokeSlackToken, sendResponseUrlMessage, setBotTokenForTeam, setWorkspaceDefaultAgent, storeWorkspaceInstallation, streamAgentResponse, updateConnectionMetadata, verifySlackRequest };

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 } from "@inkeep/agents-core";
+import { findWorkAppSlackWorkspaceBySlackTeamId, retryWithBackoff } from "@inkeep/agents-core";
 import { Nango } from "@nangohq/node";
 
 //#region src/slack/services/nango.ts
@@ -30,28 +30,6 @@ const workspaceConnectionCache = /* @__PURE__ */ new Map();
 const CACHE_TTL_MS = 6e4;
 const logger = getLogger("slack-nango");
 /**
-* Retry a function with exponential backoff for transient failures.
-* Retries on AbortError (timeout) and 5xx HTTP errors.
-*/
-async function retryWithBackoff(fn, maxAttempts = 3) {
-	for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
-		return await fn();
-	} catch (error) {
-		const isTimeout = error.name === "AbortError";
-		const isServerError = typeof error.status === "number" && error.status >= 500;
-		if (!(isTimeout || isServerError) || attempt === maxAttempts) throw error;
-		const delay = Math.min(500 * 2 ** (attempt - 1), 2e3) + Math.random() * 100;
-		logger.warn({
-			attempt,
-			maxAttempts,
-			isTimeout,
-			delay: Math.round(delay)
-		}, "Retrying Nango API call after transient failure");
-		await new Promise((resolve) => setTimeout(resolve, delay));
-	}
-	throw new Error("Unreachable");
-}
-/**
 * Evict expired entries from workspace cache to bound memory.
 */
 function evictWorkspaceCache() {

package/dist/slack/tracer.d.ts

@@ -15,6 +15,7 @@ declare const SLACK_SPAN_NAMES: {
   readonly OPEN_FOLLOW_UP_MODAL: "slack.open_follow_up_modal";
   readonly PROJECT_SELECT_UPDATE: "slack.project_select_update";
   readonly CALL_AGENT_API: "slack.call_agent_api";
+  readonly TOOL_APPROVAL: "slack.tool_approval";
 };
 declare const SLACK_SPAN_KEYS: {
   readonly TEAM_ID: "slack.team_id";

package/dist/slack/tracer.js

@@ -13,7 +13,8 @@ const SLACK_SPAN_NAMES = {
 	OPEN_AGENT_SELECTOR_MODAL: "slack.open_agent_selector_modal",
 	OPEN_FOLLOW_UP_MODAL: "slack.open_follow_up_modal",
 	PROJECT_SELECT_UPDATE: "slack.project_select_update",
-	CALL_AGENT_API: "slack.call_agent_api"
+	CALL_AGENT_API: "slack.call_agent_api",
+	TOOL_APPROVAL: "slack.tool_approval"
 };
 const SLACK_SPAN_KEYS = {
 	TEAM_ID: "slack.team_id",

package/package.json

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