@inkeep/agents-work-apps 0.68.4 → 0.70.0

package/dist/github/index.d.ts

@@ -4,10 +4,10 @@ import "./routes/setup.js";
 import "./routes/tokenExchange.js";
 import { WebhookVerificationResult, verifyWebhookSignature } from "./routes/webhooks.js";
 import { Hono } from "hono";
-import * as hono_types3 from "hono/types";
+import * as hono_types6 from "hono/types";
 
 //#region src/github/index.d.ts
-declare function createGithubRoutes(): Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
-declare const githubRoutes: Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+declare function createGithubRoutes(): Hono<hono_types6.BlankEnv, hono_types6.BlankSchema, "/">;
+declare const githubRoutes: Hono<hono_types6.BlankEnv, hono_types6.BlankSchema, "/">;
 //#endregion
 export { GenerateInstallationAccessTokenResult, GenerateTokenError, GenerateTokenResult, GitHubAppConfig, InstallationAccessToken, InstallationInfo, LookupInstallationError, LookupInstallationForRepoResult, LookupInstallationResult, WebhookVerificationResult, clearConfigCache, createAppJwt, createGithubRoutes, determineStatus, fetchInstallationDetails, fetchInstallationRepositories, generateInstallationAccessToken, getGitHubAppConfig, getGitHubAppName, getStateSigningSecret, getWebhookSecret, githubRoutes, isGitHubAppConfigured, isGitHubAppNameConfigured, isStateSigningConfigured, isWebhookConfigured, lookupInstallationForRepo, validateGitHubAppConfigOnStartup, validateGitHubInstallFlowConfigOnStartup, validateGitHubWebhookConfigOnStartup, verifyWebhookSignature };

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

@@ -1,7 +1,7 @@
-import * as hono0 from "hono";
+import * as hono2 from "hono";
 
 //#region src/github/mcp/auth.d.ts
-declare const githubMcpAuth: () => hono0.MiddlewareHandler<{
+declare const githubMcpAuth: () => hono2.MiddlewareHandler<{
   Variables: {
     toolId: string;
     tenantId: string;

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

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import * as hono_types7 from "hono/types";
+import * as hono_types1 from "hono/types";
 
 //#region src/github/mcp/index.d.ts
 declare const app: Hono<{
@@ -8,6 +8,6 @@ declare const app: Hono<{
     tenantId: string;
     projectId: string;
   };
-}, hono_types7.BlankSchema, "/">;
+}, hono_types1.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_types8 from "hono/types";
+import * as hono_types2 from "hono/types";
 
 //#region src/github/routes/setup.d.ts
-declare const app: Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
+declare const app: Hono<hono_types2.BlankEnv, hono_types2.BlankSchema, "/">;
 //#endregion
 export { app as default };

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

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

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

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import * as hono_types1 from "hono/types";
+import * as hono_types0 from "hono/types";
 
 //#region src/github/routes/webhooks.d.ts
 interface WebhookVerificationResult {
@@ -7,6 +7,6 @@ interface WebhookVerificationResult {
   error?: string;
 }
 declare function verifyWebhookSignature(payload: string, signature: string | undefined, secret: string): WebhookVerificationResult;
-declare const app: Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
+declare const app: Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
 //#endregion
 export { WebhookVerificationResult, app as default, verifyWebhookSignature };

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

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

package/dist/slack/services/events/block-actions.d.ts

@@ -1,8 +1,7 @@
+import { getSlackClient } from "../client.js";
+
 //#region src/slack/services/events/block-actions.d.ts
-/**
- * Handlers for Slack block action events (button clicks, selections, etc.)
- * and message shortcuts
- */
+
 /**
  * Handle tool approval/denial button clicks.
  * Called when a user clicks "Approve" or "Deny" on a tool approval message.
@@ -37,5 +36,23 @@ declare function handleMessageShortcut(params: {
   threadTs?: string;
   responseUrl?: string;
 }): Promise<void>;
+/**
+ * Consume the SSE continuation stream returned after a durable tool approval.
+ * Accumulates text-delta events and posts the final result to the Slack thread.
+ * If the continuation triggers another tool approval (chained/delegated), posts
+ * the approval buttons — the next button click will recursively enter this flow.
+ */
+declare function consumeApprovalContinuationStream(params: {
+  response: Response;
+  slackClient: ReturnType<typeof getSlackClient>;
+  channel: string;
+  threadTs?: string;
+  agentName: string;
+  conversationId: string;
+  projectId: string;
+  agentId: string;
+  slackUserId: string;
+  thinkingMessageTs?: string;
+}): Promise<void>;
 //#endregion
-export { handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval };
+export { consumeApprovalContinuationStream, handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval };

package/dist/slack/services/events/block-actions.js

@@ -1,9 +1,10 @@
 import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
 import { findWorkspaceConnectionByTeamId } from "../nango.js";
-import { fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, getChannelAgentConfig, sendResponseUrlMessage } from "./utils.js";
+import { fetchAgentsForProject, fetchProjectsForTenant, findCachedUserMapping, getChannelAgentConfig, markdownToMrkdwn, sendResponseUrlMessage } from "./utils.js";
+import { lookupAgentName } from "../agent-resolution.js";
 import { SlackStrings } from "../../i18n/strings.js";
-import { ToolApprovalButtonValueSchema, buildToolApprovalDoneBlocks } from "../blocks/index.js";
+import { ToolApprovalButtonValueSchema, buildToolApprovalBlocks, buildToolApprovalDoneBlocks, createContextBlock, createContextBlockFromText } from "../blocks/index.js";
 import { getSlackClient } from "../client.js";
 import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
 import { buildAgentSelectorModal, buildMessageShortcutModal } from "../modals.js";
@@ -64,6 +65,15 @@ async function handleToolApproval(params) {
 				slackTeamId: teamId,
 				slackUserId
 			});
+			if (responseUrl) await sendResponseUrlMessage(responseUrl, {
+				text: approved ? `✅ Approved \`${toolName}\`` : `❌ Denied \`${toolName}\``,
+				replace_original: true,
+				blocks: buildToolApprovalDoneBlocks({
+					toolName,
+					approved,
+					actorUserId: slackUserId
+				})
+			}).catch((e) => logger.warn({ error: e }, "Failed to update approval message"));
 			const apiUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
 			const approvalResponse = await getInProcessFetch()(`${apiUrl}/run/api/chat`, {
 				method: "POST",
@@ -108,21 +118,38 @@ async function handleToolApproval(params) {
 				span.end();
 				return;
 			}
-			if (responseUrl) await sendResponseUrlMessage(responseUrl, {
-				text: approved ? `✅ Approved \`${toolName}\`` : `❌ Denied \`${toolName}\``,
-				replace_original: true,
-				blocks: buildToolApprovalDoneBlocks({
-					toolName,
-					approved,
-					actorUserId: slackUserId
-				})
-			}).catch((e) => logger.warn({ error: e }, "Failed to update approval message"));
 			logger.info({
 				toolCallId,
 				conversationId,
 				approved,
 				slackUserId
 			}, "Tool approval processed");
+			const contentType = approvalResponse.headers.get("content-type") || "";
+			if (approvalResponse.body && contentType.includes("text/event-stream")) {
+				const agentName = await lookupAgentName(tenantId, projectId, agentId) || agentId;
+				const thinkingText = SlackStrings.status.thinking(agentName);
+				const thinkingMsg = await slackClient.chat.postMessage({
+					channel: buttonValue.channel,
+					...approvalThreadParam,
+					blocks: [createContextBlockFromText(thinkingText)],
+					text: thinkingText
+				}).catch((e) => {
+					logger.warn({ error: e }, "Failed to post thinking message");
+					return null;
+				});
+				await consumeApprovalContinuationStream({
+					response: approvalResponse,
+					slackClient,
+					channel: buttonValue.channel,
+					threadTs: buttonValue.threadTs,
+					agentName,
+					conversationId,
+					projectId,
+					agentId,
+					slackUserId,
+					thinkingMessageTs: thinkingMsg?.ts
+				});
+			}
 			span.end();
 		} catch (error) {
 			if (error instanceof Error) setSpanWithError(span, error);
@@ -343,6 +370,130 @@ async function handleMessageShortcut(params) {
 		}
 	});
 }
+const CONTINUATION_TIMEOUT_MS = 12e4;
+/**
+* Consume the SSE continuation stream returned after a durable tool approval.
+* Accumulates text-delta events and posts the final result to the Slack thread.
+* If the continuation triggers another tool approval (chained/delegated), posts
+* the approval buttons — the next button click will recursively enter this flow.
+*/
+async function consumeApprovalContinuationStream(params) {
+	const { response, slackClient, channel, threadTs, agentName, conversationId, projectId, agentId, slackUserId, thinkingMessageTs } = params;
+	const threadParam = threadTs ? { thread_ts: threadTs } : {};
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let fullText = "";
+	let chainedApprovalPosted = false;
+	const toolCallIdToName = /* @__PURE__ */ new Map();
+	const toolCallIdToInput = /* @__PURE__ */ new Map();
+	const timeoutId = setTimeout(() => {
+		reader.cancel().catch(() => {});
+	}, CONTINUATION_TIMEOUT_MS);
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.startsWith("data: ")) continue;
+				const jsonStr = line.slice(6).trim();
+				if (!jsonStr || jsonStr === "[DONE]") continue;
+				try {
+					const data = JSON.parse(jsonStr);
+					if (data.type === "text-delta" && data.delta) fullText += data.delta;
+					else if (data.type === "tool-input-available" && data.toolCallId && data.toolName) {
+						toolCallIdToName.set(String(data.toolCallId), String(data.toolName));
+						if (data.input && typeof data.input === "object") toolCallIdToInput.set(String(data.toolCallId), data.input);
+					} else if (data.type === "tool-approval-request" && data.toolCallId && conversationId) {
+						const toolCallId = data.toolCallId;
+						const toolName = toolCallIdToName.get(toolCallId) || "Tool";
+						const input = toolCallIdToInput.get(toolCallId);
+						const buttonValue = {
+							toolCallId,
+							conversationId,
+							projectId,
+							agentId,
+							slackUserId,
+							channel,
+							threadTs,
+							toolName
+						};
+						await slackClient.chat.postMessage({
+							channel,
+							...threadParam,
+							text: `Tool approval required: \`${toolName}\``,
+							blocks: buildToolApprovalBlocks({
+								toolName,
+								input,
+								buttonValue: JSON.stringify(buttonValue)
+							})
+						}).catch((e) => logger.warn({
+							error: e,
+							toolCallId
+						}, "Failed to post chained approval message"));
+						chainedApprovalPosted = true;
+						clearTimeout(timeoutId);
+					}
+				} catch {}
+			}
+		}
+	} catch (error) {
+		logger.warn({
+			error: error instanceof Error ? error.message : String(error),
+			channel,
+			threadTs,
+			conversationId,
+			agentId
+		}, "Error reading approval continuation stream");
+		if (fullText.length === 0) await slackClient.chat.postMessage({
+			channel,
+			...threadParam,
+			text: "_Something went wrong while processing the tool result. Please try again._"
+		}).catch((e) => logger.warn({ error: e }, "Failed to post continuation error message"));
+	} finally {
+		clearTimeout(timeoutId);
+		reader.cancel().catch(() => {});
+	}
+	if (thinkingMessageTs) await slackClient.chat.delete({
+		channel,
+		ts: thinkingMessageTs
+	}).catch((e) => logger.warn({ error: e }, "Failed to delete thinking message"));
+	if (fullText.length > 0) {
+		const slackText = markdownToMrkdwn(fullText);
+		const SLACK_SECTION_LIMIT = 3e3;
+		const truncatedText = slackText.length > SLACK_SECTION_LIMIT ? `${slackText.slice(0, SLACK_SECTION_LIMIT - 3)}...` : slackText;
+		await slackClient.chat.postMessage({
+			channel,
+			...threadParam,
+			text: slackText,
+			blocks: [{
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: truncatedText
+				}
+			}, createContextBlock({ agentName })]
+		}).catch((e) => logger.warn({
+			error: e,
+			channel,
+			threadTs
+		}, "Failed to post approval continuation result"));
+		logger.info({
+			channel,
+			threadTs,
+			conversationId,
+			responseLength: fullText.length
+		}, "Approval continuation stream completed");
+	} else if (!chainedApprovalPosted) logger.warn({
+		channel,
+		threadTs,
+		conversationId
+	}, "Approval continuation stream completed with no text and no chained approval");
+}
 
 //#endregion
-export { handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval };
+export { consumeApprovalContinuationStream, handleMessageShortcut, handleOpenAgentSelectorModal, handleToolApproval };

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

@@ -120,6 +120,7 @@ async function streamAgentResponse(params) {
 						content: question
 					}],
 					stream: true,
+					executionMode: "durable",
 					...conversationId && { conversationId }
 				}),
 				signal: abortController.signal

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

@@ -10,9 +10,9 @@ import { AgentOption } from "../modals.js";
  */
 declare function findCachedUserMapping(tenantId: string, slackUserId: string, teamId: string, clientId?: string): Promise<{
   slackUserId: string;
-  id: string;
   createdAt: string;
   updatedAt: string;
+  id: string;
   tenantId: string;
   clientId: string;
   slackTeamId: string;

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

@@ -1,5 +1,5 @@
 import { SlackLinkIntent } from "@inkeep/agents-core";
-import * as slack_block_builder0 from "slack-block-builder";
+import * as slack_block_builder7 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_builder0.SlackMessageDto>;
+declare function buildLinkPromptMessage(result: LinkPromptResult): Readonly<slack_block_builder7.SlackMessageDto>;
 //#endregion
 export { LinkPromptResult, ResolveLinkActionParams, buildLinkPromptMessage, resolveUnlinkedUserAction };

package/package.json

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