@inkeep/agents-work-apps 0.0.0-dev-20260204182014 → 0.0.0-dev-20260204210021

package/dist/slack/services/events/modal-submission.js

@@ -1,279 +0,0 @@
-import { env } from "../../../env.js";
-import { getLogger } from "../../../logger.js";
-import runDbClient_default from "../../../db/runDbClient.js";
-import { findWorkspaceConnectionByTeamId } from "../nango.js";
-import { getSlackClient } from "../client.js";
-import { classifyError, getThreadContext, getUserFriendlyErrorMessage, markdownToMrkdwn, sendResponseUrlMessage } from "./utils.js";
-import { findWorkAppSlackUserMapping, signSlackUserToken } from "@inkeep/agents-core";
-
-//#region src/slack/services/events/modal-submission.ts
-/**
-* Handler for Slack modal submission events
-*/
-const logger = getLogger("slack-modal-submission");
-async function handleModalSubmission(view) {
-	try {
-		const metadata = JSON.parse(view.private_metadata || "{}");
-		const values = view.state?.values || {};
-		const agentSelectValue = values.agent_select_block?.agent_select;
-		const questionValue = values.question_block?.question_input;
-		const visibilityValue = values.visibility_block?.visibility_checkbox;
-		const includeContextValue = values.context_block?.include_context_checkbox;
-		const question = questionValue?.value || "";
-		const isEphemeral = visibilityValue?.selected_options?.some((o) => o.value === "ephemeral") || false;
-		const includeContext = includeContextValue?.selected_options?.some((o) => o.value === "include_context") ?? true;
-		let agentId = metadata.selectedAgentId;
-		let projectId = metadata.selectedProjectId;
-		if (agentSelectValue?.selected_option?.value) try {
-			const parsed = JSON.parse(agentSelectValue.selected_option.value);
-			agentId = parsed.agentId;
-			projectId = parsed.projectId;
-		} catch {
-			logger.warn({ value: agentSelectValue.selected_option.value }, "Failed to parse agent select value");
-		}
-		if (!agentId || !projectId) {
-			logger.error({ metadata }, "Missing agent or project ID in modal submission");
-			return;
-		}
-		const workspaceConnection = await findWorkspaceConnectionByTeamId(metadata.teamId);
-		if (!workspaceConnection?.botToken) {
-			logger.error({ teamId: metadata.teamId }, "No bot token for modal submission");
-			return;
-		}
-		const slackClient = getSlackClient(workspaceConnection.botToken);
-		const tenantId = metadata.tenantId;
-		let fullQuestion = question;
-		if (metadata.isInThread && metadata.threadTs && includeContext) {
-			const contextMessages = await getThreadContext(slackClient, metadata.channel, metadata.threadTs);
-			if (contextMessages) fullQuestion = question ? `Based on the following conversation:\n\n${contextMessages}\n\nUser request: ${question}` : `Based on the following conversation, please provide a helpful response or summary:\n\n${contextMessages}`;
-		}
-		if (!fullQuestion) {
-			logger.warn({ metadata }, "No question provided in modal submission");
-			return;
-		}
-		const existingLink = await findWorkAppSlackUserMapping(runDbClient_default)(tenantId, metadata.slackUserId, metadata.teamId, "work-apps-slack");
-		if (!existingLink) {
-			if (isEphemeral) await slackClient.chat.postEphemeral({
-				channel: metadata.channel,
-				user: metadata.slackUserId,
-				text: "🔗 You need to link your account first. Use `/inkeep link` to get started."
-			});
-			else await slackClient.chat.postMessage({
-				channel: metadata.channel,
-				thread_ts: metadata.threadTs || metadata.messageTs,
-				text: "🔗 You need to link your account first. Use `/inkeep link` to get started."
-			});
-			return;
-		}
-		const slackUserToken = await signSlackUserToken({
-			inkeepUserId: existingLink.inkeepUserId,
-			tenantId,
-			slackTeamId: metadata.teamId,
-			slackUserId: metadata.slackUserId
-		});
-		const apiBaseUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
-		const replyThreadTs = metadata.threadTs || metadata.messageTs;
-		let thinkingMessageTs;
-		if (isEphemeral) {
-			const thinkingPayload = {
-				channel: metadata.channel,
-				user: metadata.slackUserId,
-				text: `_${agentId} is thinking..._`
-			};
-			if (metadata.isInThread && metadata.threadTs) thinkingPayload.thread_ts = metadata.threadTs;
-			await slackClient.chat.postEphemeral(thinkingPayload);
-		} else thinkingMessageTs = (await slackClient.chat.postMessage({
-			channel: metadata.channel,
-			thread_ts: replyThreadTs,
-			text: `_${agentId} is thinking..._`
-		})).ts;
-		const 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: fullQuestion
-				}],
-				stream: false
-			})
-		});
-		let responseText = "No response received";
-		let isError = false;
-		if (response.ok) {
-			const result = await response.json();
-			responseText = markdownToMrkdwn(result.choices?.[0]?.message?.content || result.message?.content || responseText);
-		} else {
-			isError = true;
-			responseText = getUserFriendlyErrorMessage(classifyError(null, response.status), agentId);
-			logger.warn({
-				status: response.status,
-				statusText: response.statusText,
-				agentId
-			}, "Agent API returned error");
-		}
-		if (isEphemeral) try {
-			if (isError) {
-				const ephemeralPayload = {
-					channel: metadata.channel,
-					user: metadata.slackUserId,
-					text: responseText,
-					blocks: [{
-						type: "section",
-						text: {
-							type: "mrkdwn",
-							text: responseText
-						}
-					}]
-				};
-				if (metadata.isInThread && metadata.threadTs) ephemeralPayload.thread_ts = metadata.threadTs;
-				await slackClient.chat.postEphemeral(ephemeralPayload);
-			} else {
-				const shareButtons = [];
-				if (metadata.isInThread && metadata.threadTs) shareButtons.push({
-					type: "button",
-					text: {
-						type: "plain_text",
-						text: "Share to Thread",
-						emoji: true
-					},
-					action_id: "share_to_thread",
-					style: "primary",
-					value: JSON.stringify({
-						channelId: metadata.channel,
-						threadTs: metadata.threadTs,
-						text: responseText,
-						agentName: agentId
-					})
-				});
-				shareButtons.push({
-					type: "button",
-					text: {
-						type: "plain_text",
-						text: "Share to Channel",
-						emoji: true
-					},
-					action_id: "share_to_channel",
-					value: JSON.stringify({
-						channelId: metadata.channel,
-						text: responseText,
-						agentName: agentId
-					})
-				});
-				const ephemeralPayload = {
-					channel: metadata.channel,
-					user: metadata.slackUserId,
-					text: responseText,
-					blocks: [
-						{
-							type: "section",
-							text: {
-								type: "mrkdwn",
-								text: responseText
-							}
-						},
-						{
-							type: "context",
-							elements: [{
-								type: "mrkdwn",
-								text: `Powered by *${agentId}* via Inkeep • Only visible to you`
-							}]
-						},
-						{
-							type: "actions",
-							elements: shareButtons
-						}
-					]
-				};
-				if (metadata.isInThread && metadata.threadTs) ephemeralPayload.thread_ts = metadata.threadTs;
-				await slackClient.chat.postEphemeral(ephemeralPayload);
-			}
-		} catch (ephemeralError) {
-			logger.error({ ephemeralError }, "Failed to post ephemeral message");
-		}
-		else {
-			if (isError) await slackClient.chat.postMessage({
-				channel: metadata.channel,
-				thread_ts: replyThreadTs,
-				text: responseText,
-				blocks: [{
-					type: "section",
-					text: {
-						type: "mrkdwn",
-						text: responseText
-					}
-				}]
-			});
-			else await slackClient.chat.postMessage({
-				channel: metadata.channel,
-				thread_ts: replyThreadTs,
-				text: responseText,
-				blocks: [{
-					type: "section",
-					text: {
-						type: "mrkdwn",
-						text: responseText
-					}
-				}, {
-					type: "context",
-					elements: [{
-						type: "mrkdwn",
-						text: `Powered by *${agentId}* via Inkeep`
-					}]
-				}]
-			});
-			if (thinkingMessageTs) try {
-				await slackClient.chat.delete({
-					channel: metadata.channel,
-					ts: thinkingMessageTs
-				});
-			} catch (deleteError) {
-				logger.warn({ deleteError }, "Failed to delete thinking message");
-			}
-		}
-		if (metadata.buttonResponseUrl) try {
-			await sendResponseUrlMessage(metadata.buttonResponseUrl, {
-				text: "",
-				delete_original: true
-			});
-		} catch (deleteError) {
-			logger.warn({ deleteError }, "Failed to delete button message");
-		}
-		logger.info({
-			agentId,
-			projectId,
-			tenantId,
-			slackUserId: metadata.slackUserId,
-			isEphemeral
-		}, "Modal submission agent execution completed");
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : String(error);
-		logger.error({
-			errorMessage: errorMsg,
-			view
-		}, "Failed to handle modal submission");
-		try {
-			const metadata = JSON.parse(view.private_metadata || "{}");
-			const workspaceConnection = await findWorkspaceConnectionByTeamId(metadata.teamId);
-			if (workspaceConnection?.botToken) {
-				const slackClient = getSlackClient(workspaceConnection.botToken);
-				const userMessage = getUserFriendlyErrorMessage(classifyError(error));
-				await slackClient.chat.postEphemeral({
-					channel: metadata.channel,
-					user: metadata.slackUserId,
-					text: userMessage
-				});
-			}
-		} catch (notifyError) {
-			logger.error({ notifyError }, "Failed to notify user of modal submission error");
-		}
-	}
-}
-
-//#endregion
-export { handleModalSubmission };

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

@@ -1,27 +0,0 @@
-import { getSlackClient } from "../client.js";
-import { SlackErrorType } from "./utils.js";
-
-//#region src/slack/services/events/streaming.d.ts
-
-interface StreamResult {
-  success: boolean;
-  errorType?: SlackErrorType;
-  errorMessage?: string;
-}
-declare function streamAgentResponse(params: {
-  slackClient: ReturnType<typeof getSlackClient>;
-  channel: string;
-  threadTs: string;
-  thinkingMessageTs: string;
-  slackUserId: string;
-  teamId: string;
-  jwtToken: string;
-  projectId: string;
-  agentId: string;
-  question: string;
-  agentName: string;
-  conversationId?: string;
-  isEphemeral?: boolean;
-}): Promise<StreamResult>;
-//#endregion
-export { StreamResult, streamAgentResponse };

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

@@ -1,285 +0,0 @@
-import { env } from "../../../env.js";
-import { getLogger } from "../../../logger.js";
-import { SlackErrorType, classifyError, getUserFriendlyErrorMessage, markdownToMrkdwn } from "./utils.js";
-
-//#region src/slack/services/events/streaming.ts
-/**
-* Slack streaming utilities for agent responses
-*
-* Uses SlackUserToken JWT for authentication to Run API.
-*/
-const logger = getLogger("slack-streaming");
-async function streamAgentResponse(params) {
-	const { slackClient, channel, threadTs, thinkingMessageTs, slackUserId, teamId, jwtToken, projectId, agentId, question, agentName, conversationId, isEphemeral = false } = params;
-	const apiUrl = env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
-	logger.debug({
-		conversationId,
-		channel,
-		threadTs
-	}, "Streaming agent response with conversation context");
-	const 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 }
-		})
-	});
-	if (!response.ok) {
-		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);
-		if (isEphemeral) await slackClient.chat.postEphemeral({
-			channel,
-			user: slackUserId,
-			thread_ts: threadTs,
-			text: errorMessage
-		});
-		else 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) {
-		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 = "";
-	if (isEphemeral) 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" || data.type === "text-start" || data.type === "text-end") continue;
-					if (data.type === "text-delta" && data.delta) fullText += data.delta;
-					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;
-					}
-				} catch {}
-			}
-		}
-		const formattedText = markdownToMrkdwn(fullText);
-		const contextBlock = {
-			type: "context",
-			elements: [{
-				type: "mrkdwn",
-				text: `_Private response_ • Powered by *${agentName}* via Inkeep`
-			}]
-		};
-		const shareButtons = [];
-		if (threadTs) shareButtons.push({
-			type: "button",
-			text: {
-				type: "plain_text",
-				text: "Share to Thread",
-				emoji: true
-			},
-			action_id: "share_to_thread",
-			style: "primary",
-			value: JSON.stringify({
-				channelId: channel,
-				threadTs,
-				text: formattedText,
-				agentName
-			})
-		});
-		shareButtons.push({
-			type: "button",
-			text: {
-				type: "plain_text",
-				text: "Share to Channel",
-				emoji: true
-			},
-			action_id: "share_to_channel",
-			value: JSON.stringify({
-				channelId: channel,
-				text: formattedText,
-				agentName
-			})
-		});
-		await slackClient.chat.postEphemeral({
-			channel,
-			user: slackUserId,
-			thread_ts: threadTs,
-			text: formattedText,
-			blocks: [
-				{
-					type: "section",
-					text: {
-						type: "mrkdwn",
-						text: formattedText
-					}
-				},
-				contextBlock,
-				{
-					type: "actions",
-					elements: shareButtons
-				}
-			]
-		});
-		logger.debug({
-			channel,
-			threadTs,
-			responseLength: fullText.length,
-			isEphemeral
-		}, "Ephemeral response posted");
-		return { success: true };
-	} catch (error) {
-		logger.error({ error }, "Error posting ephemeral response");
-		const errorType = classifyError(error);
-		const errorMessage = getUserFriendlyErrorMessage(errorType, agentName);
-		try {
-			await slackClient.chat.postEphemeral({
-				channel,
-				user: slackUserId,
-				thread_ts: threadTs,
-				text: errorMessage
-			});
-		} catch {}
-		return {
-			success: false,
-			errorType,
-			errorMessage
-		};
-	}
-	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 streamer.append({ markdown_text: data.delta });
-					} 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 streamer.append({ markdown_text: content });
-					}
-				} catch {}
-			}
-		}
-		const contextBlock = {
-			type: "context",
-			elements: [{
-				type: "mrkdwn",
-				text: `Powered by *${agentName}* via Inkeep`
-			}]
-		};
-		await streamer.stop({ blocks: [contextBlock] });
-		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) {
-		logger.error({ streamError }, "Error during Slack streaming");
-		await streamer.stop();
-		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 {}
-		return {
-			success: false,
-			errorType,
-			errorMessage
-		};
-	}
-}
-
-//#endregion
-export { streamAgentResponse };