@inkeep/agents-work-apps 0.0.0-dev-20260212220816 → 0.0.0-dev-20260213181729

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

@@ -2,6 +2,7 @@ import { env } from "../../../env.js";
 import { getLogger } from "../../../logger.js";
 import { createContextBlock } from "../blocks/index.js";
 import { SlackErrorType, classifyError, getUserFriendlyErrorMessage } from "./utils.js";
+import { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer } from "../../tracer.js";
 
 //#region src/slack/services/events/streaming.ts
 /**
@@ -28,46 +29,87 @@ async function withTimeout(promise, ms, label) {
 	}
 }
 async function streamAgentResponse(params) {
-	const { slackClient, channel, threadTs, thinkingMessageTs, slackUserId, teamId, jwtToken, projectId, agentId, question, agentName, conversationId } = params;
-	const apiUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
-	logger.debug({
-		conversationId,
-		channel,
-		threadTs
-	}, "Streaming agent response with conversation context");
-	const abortController = new AbortController();
-	const timeoutId = setTimeout(() => {
-		logger.warn({
+	return tracer.startActiveSpan(SLACK_SPAN_NAMES.STREAM_AGENT_RESPONSE, async (span) => {
+		const { slackClient, channel, threadTs, thinkingMessageTs, slackUserId, teamId, jwtToken, projectId, agentId, question, agentName, conversationId } = params;
+		span.setAttribute(SLACK_SPAN_KEYS.TEAM_ID, teamId);
+		span.setAttribute(SLACK_SPAN_KEYS.CHANNEL_ID, channel);
+		span.setAttribute(SLACK_SPAN_KEYS.USER_ID, slackUserId);
+		span.setAttribute(SLACK_SPAN_KEYS.PROJECT_ID, projectId);
+		span.setAttribute(SLACK_SPAN_KEYS.AGENT_ID, agentId);
+		if (conversationId) span.setAttribute(SLACK_SPAN_KEYS.CONVERSATION_ID, conversationId);
+		span.setAttribute(SLACK_SPAN_KEYS.THREAD_TS, threadTs);
+		const apiUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
+		logger.info({
+			conversationId,
 			channel,
 			threadTs,
-			timeoutMs: STREAM_TIMEOUT_MS
-		}, "Stream timeout reached");
-		abortController.abort();
-	}, STREAM_TIMEOUT_MS);
-	let response;
-	try {
-		response = await fetch(`${apiUrl.replace(/\/$/, "")}/run/api/chat`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${jwtToken}`,
-				"x-inkeep-project-id": projectId,
-				"x-inkeep-agent-id": agentId
-			},
-			body: JSON.stringify({
-				messages: [{
-					role: "user",
-					content: question
-				}],
-				stream: true,
-				...conversationId && { conversationId }
-			}),
-			signal: abortController.signal
-		});
-	} catch (fetchError) {
-		clearTimeout(timeoutId);
-		if (fetchError.name === "AbortError") {
-			const errorType = SlackErrorType.TIMEOUT;
+			agentId,
+			projectId
+		}, "Starting streaming agent response");
+		const abortController = new AbortController();
+		const timeoutId = setTimeout(() => {
+			logger.warn({
+				channel,
+				threadTs,
+				timeoutMs: STREAM_TIMEOUT_MS
+			}, "Stream timeout reached");
+			abortController.abort();
+		}, STREAM_TIMEOUT_MS);
+		let response;
+		try {
+			response = await fetch(`${apiUrl.replace(/\/$/, "")}/run/api/chat`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${jwtToken}`,
+					"x-inkeep-project-id": projectId,
+					"x-inkeep-agent-id": agentId
+				},
+				body: JSON.stringify({
+					messages: [{
+						role: "user",
+						content: question
+					}],
+					stream: true,
+					...conversationId && { conversationId }
+				}),
+				signal: abortController.signal
+			});
+		} catch (fetchError) {
+			clearTimeout(timeoutId);
+			if (fetchError.name === "AbortError") {
+				const errorType = SlackErrorType.TIMEOUT;
+				const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
+				await slackClient.chat.postMessage({
+					channel,
+					thread_ts: threadTs,
+					text: errorMessage
+				});
+				if (thinkingMessageTs) try {
+					await slackClient.chat.delete({
+						channel,
+						ts: thinkingMessageTs
+					});
+				} catch {}
+				span.end();
+				return {
+					success: false,
+					errorType,
+					errorMessage
+				};
+			}
+			if (fetchError instanceof Error) setSpanWithError(span, fetchError);
+			span.end();
+			throw fetchError;
+		}
+		if (!response.ok) {
+			clearTimeout(timeoutId);
+			const errorBody = await response.text().catch(() => "Unknown error");
+			logger.error({
+				status: response.status,
+				errorBody
+			}, "Agent streaming request failed");
+			const errorType = classifyError(null, response.status);
 			const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
 			await slackClient.chat.postMessage({
 				channel,
@@ -80,153 +122,133 @@ async function streamAgentResponse(params) {
 					ts: thinkingMessageTs
 				});
 			} catch {}
+			span.end();
 			return {
 				success: false,
 				errorType,
 				errorMessage
 			};
 		}
-		throw fetchError;
-	}
-	if (!response.ok) {
-		clearTimeout(timeoutId);
-		const errorBody = await response.text().catch(() => "Unknown error");
-		logger.error({
-			status: response.status,
-			errorBody
-		}, "Agent streaming request failed");
-		const errorType = classifyError(null, response.status);
-		const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
-		await slackClient.chat.postMessage({
-			channel,
-			thread_ts: threadTs,
-			text: errorMessage
-		});
-		if (thinkingMessageTs) try {
-			await slackClient.chat.delete({
-				channel,
-				ts: thinkingMessageTs
-			});
-		} catch {}
-		return {
-			success: false,
-			errorType,
-			errorMessage
-		};
-	}
-	if (!response.body) {
-		clearTimeout(timeoutId);
-		logger.error({
-			status: response.status,
-			channel,
-			threadTs
-		}, "Agent API returned 200 but no response body");
-		const errorType = SlackErrorType.API_ERROR;
-		const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
-		await slackClient.chat.postMessage({
-			channel,
-			thread_ts: threadTs,
-			text: errorMessage
-		});
-		if (thinkingMessageTs) try {
-			await slackClient.chat.delete({
-				channel,
-				ts: thinkingMessageTs
-			});
-		} catch {}
-		return {
-			success: false,
-			errorType,
-			errorMessage
-		};
-	}
-	const reader = response.body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = "";
-	let fullText = "";
-	const streamer = slackClient.chatStream({
-		channel,
-		recipient_team_id: teamId,
-		recipient_user_id: slackUserId,
-		thread_ts: threadTs
-	});
-	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 === "data-operation") continue;
-					if (data.type === "text-start" || data.type === "text-end") continue;
-					if (data.type === "text-delta" && data.delta) {
-						fullText += data.delta;
-						await withTimeout(streamer.append({ markdown_text: data.delta }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.append");
-					} else if (data.object === "chat.completion.chunk" && data.choices?.[0]?.delta?.content) {
-						const content = data.choices[0].delta.content;
-						try {
-							if (JSON.parse(content).type === "data-operation") continue;
-						} catch {}
-						fullText += content;
-						await withTimeout(streamer.append({ markdown_text: content }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.append");
-					}
-				} catch {}
-			}
-		}
-		clearTimeout(timeoutId);
-		const contextBlock = createContextBlock({ agentName });
-		await withTimeout(streamer.stop({ blocks: [contextBlock] }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.stop");
-		if (thinkingMessageTs) try {
-			await slackClient.chat.delete({
-				channel,
-				ts: thinkingMessageTs
-			});
-		} catch (deleteError) {
-			logger.warn({ deleteError }, "Failed to delete acknowledgement message");
-		}
-		logger.debug({
-			channel,
-			threadTs,
-			responseLength: fullText.length
-		}, "Streaming completed");
-		return { success: true };
-	} catch (streamError) {
-		clearTimeout(timeoutId);
-		logger.error({ streamError }, "Error during Slack streaming");
-		await withTimeout(streamer.stop(), CHATSTREAM_OP_TIMEOUT_MS, "streamer.stop").catch((e) => logger.warn({ error: e }, "Failed to stop streamer during error cleanup"));
-		if (thinkingMessageTs) try {
-			await slackClient.chat.delete({
+		if (!response.body) {
+			clearTimeout(timeoutId);
+			logger.error({
+				status: response.status,
 				channel,
-				ts: thinkingMessageTs
-			});
-		} catch {}
-		const errorType = classifyError(streamError);
-		const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
-		try {
+				threadTs
+			}, "Agent API returned 200 but no response body");
+			const errorType = SlackErrorType.API_ERROR;
+			const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
 			await slackClient.chat.postMessage({
 				channel,
 				thread_ts: threadTs,
 				text: errorMessage
 			});
-		} catch (notifyError) {
-			logger.warn({
-				notifyError,
+			if (thinkingMessageTs) try {
+				await slackClient.chat.delete({
+					channel,
+					ts: thinkingMessageTs
+				});
+			} catch {}
+			span.end();
+			return {
+				success: false,
+				errorType,
+				errorMessage
+			};
+		}
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let fullText = "";
+		const streamer = slackClient.chatStream({
+			channel,
+			recipient_team_id: teamId,
+			recipient_user_id: slackUserId,
+			thread_ts: threadTs
+		});
+		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 === "data-operation") continue;
+						if (data.type === "text-start" || data.type === "text-end") continue;
+						if (data.type === "text-delta" && data.delta) {
+							fullText += data.delta;
+							await withTimeout(streamer.append({ markdown_text: data.delta }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.append");
+						} else if (data.object === "chat.completion.chunk" && data.choices?.[0]?.delta?.content) {
+							const content = data.choices[0].delta.content;
+							try {
+								if (JSON.parse(content).type === "data-operation") continue;
+							} catch {}
+							fullText += content;
+							await withTimeout(streamer.append({ markdown_text: content }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.append");
+						}
+					} catch {}
+				}
+			}
+			clearTimeout(timeoutId);
+			const contextBlock = createContextBlock({ agentName });
+			await withTimeout(streamer.stop({ blocks: [contextBlock] }), CHATSTREAM_OP_TIMEOUT_MS, "streamer.stop");
+			if (thinkingMessageTs) try {
+				await slackClient.chat.delete({
+					channel,
+					ts: thinkingMessageTs
+				});
+			} catch (deleteError) {
+				logger.warn({ deleteError }, "Failed to delete acknowledgement message");
+			}
+			logger.info({
 				channel,
-				threadTs
-			}, "Failed to notify user of stream error");
+				threadTs,
+				responseLength: fullText.length,
+				agentId,
+				conversationId
+			}, "Streaming completed");
+			span.end();
+			return { success: true };
+		} catch (streamError) {
+			clearTimeout(timeoutId);
+			if (streamError instanceof Error) setSpanWithError(span, streamError);
+			logger.error({ streamError }, "Error during Slack streaming");
+			await withTimeout(streamer.stop(), CHATSTREAM_OP_TIMEOUT_MS, "streamer.stop").catch((e) => logger.warn({ error: e }, "Failed to stop streamer during error cleanup"));
+			if (thinkingMessageTs) try {
+				await slackClient.chat.delete({
+					channel,
+					ts: thinkingMessageTs
+				});
+			} catch {}
+			const errorType = classifyError(streamError);
+			const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
+			try {
+				await slackClient.chat.postMessage({
+					channel,
+					thread_ts: threadTs,
+					text: errorMessage
+				});
+			} catch (notifyError) {
+				logger.warn({
+					notifyError,
+					channel,
+					threadTs
+				}, "Failed to notify user of stream error");
+			}
+			span.end();
+			return {
+				success: false,
+				errorType,
+				errorMessage
+			};
 		}
-		return {
-			success: false,
-			errorType,
-			errorMessage
-		};
-	}
+	});
 }
 
 //#endregion

package/dist/slack/tracer.d.ts

@@ -0,0 +1,40 @@
+import { setSpanWithError } from "@inkeep/agents-core";
+import * as _opentelemetry_api0 from "@opentelemetry/api";
+
+//#region src/slack/tracer.d.ts
+declare const tracer: _opentelemetry_api0.Tracer;
+declare const SLACK_SPAN_NAMES: {
+  readonly WEBHOOK: "slack.webhook";
+  readonly APP_MENTION: "slack.app_mention";
+  readonly BLOCK_ACTION: "slack.block_action";
+  readonly MODAL_SUBMISSION: "slack.modal_submission";
+  readonly FOLLOW_UP_SUBMISSION: "slack.follow_up_submission";
+  readonly MESSAGE_SHORTCUT: "slack.message_shortcut";
+  readonly STREAM_AGENT_RESPONSE: "slack.stream_agent_response";
+  readonly OPEN_AGENT_SELECTOR_MODAL: "slack.open_agent_selector_modal";
+  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";
+};
+declare const SLACK_SPAN_KEYS: {
+  readonly TEAM_ID: "slack.team_id";
+  readonly CHANNEL_ID: "slack.channel_id";
+  readonly USER_ID: "slack.user_id";
+  readonly EVENT_TYPE: "slack.event_type";
+  readonly INNER_EVENT_TYPE: "slack.inner_event_type";
+  readonly CALLBACK_ID: "slack.callback_id";
+  readonly ACTION_IDS: "slack.action_ids";
+  readonly THREAD_TS: "slack.thread_ts";
+  readonly MESSAGE_TS: "slack.message_ts";
+  readonly TENANT_ID: "slack.tenant_id";
+  readonly PROJECT_ID: "slack.project_id";
+  readonly AGENT_ID: "slack.agent_id";
+  readonly CONVERSATION_ID: "slack.conversation_id";
+  readonly OUTCOME: "slack.outcome";
+  readonly IS_BOT_MESSAGE: "slack.is_bot_message";
+  readonly HAS_QUERY: "slack.has_query";
+  readonly IS_IN_THREAD: "slack.is_in_thread";
+};
+type SlackOutcome = 'handled' | 'ignored_bot_message' | 'ignored_unknown_event' | 'ignored_no_action_match' | 'url_verification' | 'validation_error' | 'signature_invalid' | 'error';
+//#endregion
+export { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, SlackOutcome, setSpanWithError, tracer };

package/dist/slack/tracer.js

@@ -0,0 +1,39 @@
+import { getTracer, setSpanWithError } from "@inkeep/agents-core";
+
+//#region src/slack/tracer.ts
+const tracer = getTracer("agents-work-apps-slack");
+const SLACK_SPAN_NAMES = {
+	WEBHOOK: "slack.webhook",
+	APP_MENTION: "slack.app_mention",
+	BLOCK_ACTION: "slack.block_action",
+	MODAL_SUBMISSION: "slack.modal_submission",
+	FOLLOW_UP_SUBMISSION: "slack.follow_up_submission",
+	MESSAGE_SHORTCUT: "slack.message_shortcut",
+	STREAM_AGENT_RESPONSE: "slack.stream_agent_response",
+	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"
+};
+const SLACK_SPAN_KEYS = {
+	TEAM_ID: "slack.team_id",
+	CHANNEL_ID: "slack.channel_id",
+	USER_ID: "slack.user_id",
+	EVENT_TYPE: "slack.event_type",
+	INNER_EVENT_TYPE: "slack.inner_event_type",
+	CALLBACK_ID: "slack.callback_id",
+	ACTION_IDS: "slack.action_ids",
+	THREAD_TS: "slack.thread_ts",
+	MESSAGE_TS: "slack.message_ts",
+	TENANT_ID: "slack.tenant_id",
+	PROJECT_ID: "slack.project_id",
+	AGENT_ID: "slack.agent_id",
+	CONVERSATION_ID: "slack.conversation_id",
+	OUTCOME: "slack.outcome",
+	IS_BOT_MESSAGE: "slack.is_bot_message",
+	HAS_QUERY: "slack.has_query",
+	IS_IN_THREAD: "slack.is_in_thread"
+};
+
+//#endregion
+export { SLACK_SPAN_KEYS, SLACK_SPAN_NAMES, setSpanWithError, tracer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-work-apps",
-  "version": "0.0.0-dev-20260212220816",
+  "version": "0.0.0-dev-20260213181729",
   "description": "First party integrations for Inkeep Agents",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -24,15 +24,16 @@
     "@nangohq/node": "^0.69.20",
     "@octokit/auth-app": "^8.1.2",
     "@octokit/rest": "^22.0.1",
+    "@opentelemetry/api": "^1.9.0",
     "@slack/types": "^2.18.0",
     "@slack/web-api": "^7.9.1",
-    "slack-block-builder": "^2.8.0",
     "drizzle-orm": "^0.44.7",
     "fetch-to-node": "^2.1.0",
     "hono": "^4.11.7",
     "jose": "^6.1.0",
     "minimatch": "^10.1.1",
-    "@inkeep/agents-core": "0.0.0-dev-20260212220816"
+    "slack-block-builder": "^2.8.0",
+    "@inkeep/agents-core": "0.0.0-dev-20260213181729"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",