@5ss/ai-tools 2.11.1

package/dist/slack-Di5BBNpt.js

@@ -0,0 +1,1455 @@
+import { t as ToolError } from "./errors-DoSpNHvs.js";
+import { n as defineModule, r as defineTool } from "./define-CvpJ_pNP.js";
+import { n as requireAuth } from "./provider-CgDAlg6K.js";
+import { t as HttpService } from "./http-service-DDNCO1s4.js";
+import { a as toArrayBuffer, n as bytesToBase64, t as base64ToBytes } from "./bytes-BxpimpQx.js";
+import { isPlainObject, isString } from "es-toolkit";
+import { z } from "zod";
+import { createHmac, timingSafeEqual } from "node:crypto";
+//#region src/vendors/slack/contracts.ts
+const MAX_MEDIA_BYTES = 100 * 1024 * 1024;
+const slackChatActionSchema = z.enum([
+	"typing",
+	"upload_photo",
+	"record_video",
+	"upload_video",
+	"record_voice",
+	"upload_voice",
+	"upload_document",
+	"choose_sticker",
+	"find_location",
+	"record_video_note",
+	"upload_video_note"
+]);
+const slackAuthSchema = z.object({ bot_token: z.string().min(1).describe("Slack bot token (xoxb-…)") });
+const slackSendTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel or conversation id"),
+	text: z.string().min(1).max(4e4).describe("Message text (max 40000 characters)"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional thread_ts to reply in a thread"),
+	reply_markup: z.unknown().optional().describe("Optional Slack blocks array (Block Kit)")
+});
+const slackMessageOutputSchema = z.object({
+	message_id: z.string().describe("Slack message timestamp (ts) as string"),
+	file_id: z.string().min(1).optional().describe("Slack file id when the message carries an uploaded file (sendMedia)")
+});
+const slackEditTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel or conversation id"),
+	message_id: z.string().min(1).describe("Message ts to edit"),
+	text: z.string().min(1).max(4e4).describe("Replacement text (max 40000 characters)"),
+	reply_markup: z.unknown().optional().describe("Optional Slack blocks array (Block Kit)")
+});
+const slackSendChatActionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel or conversation id"),
+	action: slackChatActionSchema.describe("Chat action. With reply_to_message_id (thread_ts), maps to assistant.threads.setStatus loading text."),
+	reply_to_message_id: z.string().min(1).optional().describe("Thread root ts (thread_ts). Required for assistant status; without it sendChatAction is a no-op on Slack.")
+});
+/** Clear assistant thread status (empty status). Needs the same thread_ts as set. */
+const slackStopTypingInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel or conversation id"),
+	reply_to_message_id: z.string().min(1).optional().describe("Thread root ts (thread_ts). Required to clear assistant status; without it stop is a no-op.")
+});
+const slackSetReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel or conversation id"),
+	message_id: z.string().min(1).describe("Message ts to react to"),
+	emoji: z.string().min(1).max(64).describe("Emoji name (with or without colons), e.g. thumbsup or :thumbsup:")
+});
+const slackClearReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel or conversation id"),
+	message_id: z.string().min(1).describe("Message ts to clear a reaction on"),
+	emoji: z.string().min(1).max(64).describe("Emoji name to remove (with or without colons); required on Slack")
+});
+const slackSendMediaInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel or conversation id"),
+	kind: z.enum(["photo", "document"]).describe("Media kind"),
+	body_base64: z.string().min(1).describe("File body as base64"),
+	file_name: z.string().min(1).describe("File name including extension"),
+	caption: z.string().max(3e3).optional().describe("Optional initial comment / caption"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional thread_ts for the upload"),
+	content_type: z.string().optional().describe("Optional content type for the upload")
+});
+const slackDownloadFileInputSchema = z.object({
+	file_id: z.string().min(1).describe("Slack file id from an inbound attachment"),
+	file_name: z.string().min(1).optional().describe("Preferred file name for the download result")
+});
+const slackDownloadFileOutputSchema = z.object({
+	file_name: z.string(),
+	file_size: z.number().optional(),
+	body_base64: z.string().describe("Downloaded file body as base64")
+});
+const slackAnswerCallbackInputSchema = z.object({
+	callback_query_id: z.string().min(1).describe("Slack response_url from an interactive payload, or opaque callback id"),
+	text: z.string().max(3e3).optional().describe("Optional ephemeral response text"),
+	show_alert: z.boolean().optional().describe("Ignored on Slack; reserved for channel seam parity")
+});
+const slackGetBotOutputSchema = z.object({
+	bot_id: z.string(),
+	username: z.string(),
+	display_name: z.string()
+});
+const slackOkOutputSchema = z.object({ ok: z.boolean() });
+const slackPostEphemeralInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Slack channel id"),
+	user_id: z.string().min(1).describe("User id who should see the ephemeral message"),
+	text: z.string().min(1).max(4e4).describe("Ephemeral message text"),
+	reply_markup: z.unknown().optional().describe("Optional Slack blocks array (Block Kit)")
+});
+const slackListConversationsInputSchema = z.object({
+	limit: z.number().int().min(1).max(1e3).optional().describe("Page size (default Slack limit)"),
+	cursor: z.string().min(1).optional().describe("Pagination cursor from a previous page"),
+	types: z.string().min(1).optional().describe("Comma-separated conversation types, e.g. public_channel,private_channel,im,mpim")
+});
+const slackListConversationsOutputSchema = z.object({
+	channels: z.array(z.object({
+		id: z.string(),
+		name: z.string().optional(),
+		is_channel: z.boolean().optional(),
+		is_im: z.boolean().optional(),
+		is_mpim: z.boolean().optional(),
+		is_private: z.boolean().optional()
+	})),
+	next_cursor: z.string().optional()
+});
+const MAX_SLACK_MEDIA_BATCH = 10;
+/** Host-only: full assistant.threads.setStatus (custom status + loading_messages). */
+const slackSetAssistantStatusInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel or DM id containing the assistant thread"),
+	thread_ts: z.string().min(1).describe("Thread root message ts"),
+	status: z.string().describe("Status text Slack shows after the app name (empty string clears)"),
+	loading_messages: z.array(z.string().min(1)).max(10).optional().describe("Up to 10 rotating loading messages")
+});
+const slackSetSuggestedPromptsInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel or DM id"),
+	thread_ts: z.string().min(1).optional().describe("Thread ts; optional in agent Messages-tab experience"),
+	title: z.string().min(1).optional().describe("Title above the prompt list"),
+	prompts: z.array(z.object({
+		title: z.string().min(1),
+		message: z.string().min(1)
+	})).min(1).max(4).describe("Up to four suggested prompts")
+});
+const slackPublishHomeInputSchema = z.object({
+	user_id: z.string().min(1).describe("User id to publish the Home tab view for"),
+	view: z.unknown().describe("Slack home view payload (type home + blocks)"),
+	hash: z.string().min(1).optional().describe("Optional view hash for race protection")
+});
+const slackStartStreamInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel or DM id"),
+	thread_ts: z.string().min(1).describe("Parent message ts (streamed messages are thread replies)"),
+	markdown_text: z.string().max(12e3).optional().describe("Optional initial markdown chunk"),
+	recipient_user_id: z.string().min(1).optional().describe("Required when streaming into channels"),
+	recipient_team_id: z.string().min(1).optional().describe("Required when streaming into channels"),
+	task_display_mode: z.enum([
+		"timeline",
+		"plan",
+		"dense"
+	]).optional()
+});
+const slackAppendStreamInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel or DM id"),
+	message_id: z.string().min(1).describe("Streaming message ts from startStream"),
+	markdown_text: z.string().min(1).max(12e3).describe("Markdown text to append")
+});
+const slackStopStreamInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel or DM id"),
+	message_id: z.string().min(1).describe("Streaming message ts"),
+	markdown_text: z.string().max(12e3).optional().describe("Optional final markdown append"),
+	blocks: z.unknown().optional().describe("Optional Block Kit blocks on finalize")
+});
+const slackAuthRevokeInputSchema = z.object({ test: z.boolean().optional().describe("When true, tests revoke without revoking (Slack auth.revoke test flag)") });
+const slackAuthRevokeOutputSchema = z.object({ revoked: z.boolean() });
+const slackUsersInfoInputSchema = z.object({
+	user_id: z.string().min(1).describe("Slack user id"),
+	include_locale: z.boolean().optional()
+});
+const slackUsersInfoOutputSchema = z.object({
+	user_id: z.string(),
+	name: z.string().optional(),
+	real_name: z.string().optional(),
+	display_name: z.string().optional(),
+	is_bot: z.boolean().optional(),
+	tz: z.string().optional(),
+	profile: z.record(z.string(), z.unknown()).optional()
+});
+const slackUsersConversationsInputSchema = z.object({
+	user_id: z.string().min(1).optional().describe("User id; omit for the authed user"),
+	limit: z.number().int().min(1).max(1e3).optional(),
+	cursor: z.string().min(1).optional(),
+	types: z.string().min(1).optional().describe("e.g. public_channel,private_channel,im,mpim"),
+	exclude_archived: z.boolean().optional()
+});
+const slackConversationInfoInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel, group, or DM id"),
+	include_locale: z.boolean().optional(),
+	include_num_members: z.boolean().optional()
+});
+const slackConversationInfoOutputSchema = z.object({
+	id: z.string(),
+	name: z.string().optional(),
+	is_channel: z.boolean().optional(),
+	is_im: z.boolean().optional(),
+	is_mpim: z.boolean().optional(),
+	is_private: z.boolean().optional(),
+	is_archived: z.boolean().optional(),
+	num_members: z.number().optional(),
+	raw: z.record(z.string(), z.unknown()).optional()
+});
+const slackConversationHistoryInputSchema = z.object({
+	chat_id: z.string().min(1),
+	limit: z.number().int().min(1).max(1e3).optional(),
+	cursor: z.string().min(1).optional(),
+	oldest: z.string().min(1).optional(),
+	latest: z.string().min(1).optional(),
+	inclusive: z.boolean().optional()
+});
+const slackConversationRepliesInputSchema = z.object({
+	chat_id: z.string().min(1),
+	message_id: z.string().min(1).describe("Parent message ts"),
+	limit: z.number().int().min(1).max(1e3).optional(),
+	cursor: z.string().min(1).optional(),
+	oldest: z.string().min(1).optional(),
+	latest: z.string().min(1).optional(),
+	inclusive: z.boolean().optional()
+});
+const slackConversationMessagesOutputSchema = z.object({
+	messages: z.array(z.record(z.string(), z.unknown())),
+	next_cursor: z.string().optional(),
+	has_more: z.boolean().optional()
+});
+/** Host batch upload: many files, one completeUploadExternal share. */
+const slackSendMediaBatchItemSchema = z.object({
+	file_name: z.string().min(1),
+	body_base64: z.string().min(1).optional().describe("File body as base64 (tool/host JSON path)"),
+	content_type: z.string().optional(),
+	title: z.string().min(1).optional()
+});
+const slackSendMediaBatchInputSchema = z.object({
+	chat_id: z.string().min(1),
+	files: z.array(slackSendMediaBatchItemSchema).min(1).max(10),
+	caption: z.string().max(3e3).optional(),
+	reply_to_message_id: z.string().min(1).optional()
+});
+const slackSendMediaBatchOutputSchema = z.object({
+	message_id: z.string(),
+	file_ids: z.array(z.string().min(1)).min(1)
+});
+//#endregion
+//#region src/vendors/slack/domain.ts
+/**
+* Slack payload shaping + envelope/result parse.
+* No HTTP — client owns transport.
+*/
+var SlackClientError = class extends ToolError {
+	failureKind;
+	constructor(input) {
+		super(input.message, {
+			code: "upstream",
+			retryable: input.failureKind === "outcome_unknown",
+			cause: input.cause,
+			details: {
+				method: input.method,
+				failure_kind: input.failureKind,
+				status: input.status,
+				slack_error: input.slackError,
+				retry_after_seconds: input.retryAfterSeconds
+			}
+		});
+		this.name = "SlackClientError";
+		this.failureKind = input.failureKind;
+	}
+};
+function isSlackDefiniteRejection(error) {
+	return error instanceof SlackClientError && error.failureKind === "definite_rejection";
+}
+function isSlackOutcomeUnknown(error) {
+	return error instanceof SlackClientError && error.failureKind === "outcome_unknown";
+}
+/** Network / abort / transport failures before a parseable Slack envelope. */
+function throwSlackTransportError(method, error) {
+	if (error instanceof SlackClientError) throw error;
+	throw new SlackClientError({
+		message: error instanceof Error ? error.message : `${method} request failed`,
+		failureKind: "outcome_unknown",
+		method,
+		cause: error
+	});
+}
+/** Client/auth/validation errors that should not be retried as if delivery might have succeeded. */
+const DEFINITE_SLACK_ERRORS = /* @__PURE__ */ new Set([
+	"invalid_auth",
+	"not_authed",
+	"account_inactive",
+	"token_revoked",
+	"token_expired",
+	"invalid_token",
+	"missing_scope",
+	"not_allowed_token_type",
+	"ekm_access_denied",
+	"access_denied",
+	"org_login_required",
+	"team_access_not_granted",
+	"channel_not_found",
+	"is_archived",
+	"not_in_channel",
+	"is_inactive",
+	"method_not_supported_for_channel_type",
+	"msg_too_long",
+	"no_text",
+	"invalid_arguments",
+	"invalid_blocks",
+	"invalid_blocks_format",
+	"cant_update_message",
+	"message_not_found",
+	"cant_delete_message",
+	"already_reacted",
+	"no_reaction",
+	"invalid_name",
+	"too_many_emoji",
+	"file_not_found",
+	"file_deleted",
+	"cant_find_user",
+	"user_not_found",
+	"user_not_visible",
+	"invalid_channel",
+	"name_taken",
+	"restricted_action",
+	"as_user_not_supported",
+	"cannot_reply_to_message",
+	"thread_not_found"
+]);
+const RETRYABLE_SLACK_ERRORS = /* @__PURE__ */ new Set([
+	"rate_limited",
+	"ratelimited",
+	"internal_error",
+	"fatal_error",
+	"service_unavailable",
+	"request_timeout"
+]);
+function isDefiniteStatus(status) {
+	return status === 400 || status === 401 || status === 403 || status === 404;
+}
+function classifySlackFailure(status, errorCode) {
+	if (status === 429 || status >= 500) return "outcome_unknown";
+	if (errorCode && RETRYABLE_SLACK_ERRORS.has(errorCode)) return "outcome_unknown";
+	if (errorCode && DEFINITE_SLACK_ERRORS.has(errorCode)) return "definite_rejection";
+	if (isDefiniteStatus(status)) return "definite_rejection";
+	return "outcome_unknown";
+}
+/** Map Slack `{ ok, error?, … }` (HTTP may be non-2xx). Returns the full envelope object when ok. */
+function parseSlackResult(label, status, data) {
+	if (!isPlainObject(data) || typeof data["ok"] !== "boolean") throw new SlackClientError({
+		message: `${label} returned an invalid envelope`,
+		failureKind: status === 429 || status >= 500 || status === 0 ? "outcome_unknown" : classifySlackFailure(status, void 0),
+		method: label,
+		status
+	});
+	if (data["ok"] === true) return data;
+	const errorCode = isString(data["error"]) ? data["error"] : void 0;
+	const retryAfter = typeof data["retry_after"] === "number" ? data["retry_after"] : typeof data["Retry-After"] === "number" ? data["Retry-After"] : void 0;
+	throw new SlackClientError({
+		message: errorCode ? `${label} failed: ${errorCode}` : `${label} failed`,
+		failureKind: classifySlackFailure(status, errorCode),
+		method: label,
+		status,
+		...errorCode && { slackError: errorCode },
+		...retryAfter !== void 0 && { retryAfterSeconds: retryAfter }
+	});
+}
+/** Strip surrounding colons from emoji names (`:thumbsup:` → `thumbsup`). */
+function normalizeEmojiName(emoji) {
+	return emoji.replace(/^:+/, "").replace(/:+$/, "");
+}
+function parseMessageTs(value) {
+	const ts = value["ts"];
+	if (!isString(ts) || ts.length === 0) throw new ToolError("Slack returned an invalid message ts", { code: "upstream" });
+	return { message_id: ts };
+}
+function parseOk(value) {
+	if (value["ok"] !== true) throw new ToolError("Slack returned unexpected result", { code: "upstream" });
+}
+function parseBot(value) {
+	const botId = firstString$1(value["bot_id"], value["user_id"]);
+	const username = firstString$1(value["user"], value["team"]);
+	const displayName = firstString$1(value["user"], value["team"]);
+	if (!botId || !username || !displayName) throw new ToolError("Slack auth.test returned invalid bot identity", { code: "upstream" });
+	return {
+		bot_id: botId,
+		username,
+		display_name: displayName
+	};
+}
+function parseFileInfo(value) {
+	const file = value["file"];
+	if (!isPlainObject(file) || !isString(file["id"])) throw new ToolError("Slack files.info returned invalid payload", { code: "upstream" });
+	const downloadUrl = file["url_private_download"];
+	if (!isString(downloadUrl) || downloadUrl.length === 0) throw new ToolError("Slack files.info missing url_private_download", { code: "upstream" });
+	return {
+		file_id: file["id"],
+		url_private_download: downloadUrl,
+		...isString(file["name"]) && { file_name: file["name"] },
+		...typeof file["size"] === "number" && { file_size: file["size"] }
+	};
+}
+function parseDownload(input, file, bytes) {
+	return {
+		file_name: input.file_name ?? file.file_name ?? file.file_id,
+		...file.file_size !== void 0 && { file_size: file.file_size },
+		body_base64: bytesToBase64(bytes)
+	};
+}
+function parseUploadUrl(value) {
+	const uploadUrl = value["upload_url"];
+	const fileId = value["file_id"];
+	if (!isString(uploadUrl) || uploadUrl.length === 0 || !isString(fileId) || fileId.length === 0) throw new ToolError("Slack files.getUploadURLExternal returned invalid payload", { code: "upstream" });
+	return {
+		upload_url: uploadUrl,
+		file_id: fileId
+	};
+}
+/**
+* Prefer message ts from shares; fall back to uploaded file id.
+* Always surface `file_id` when known so hosts can download the just-uploaded file.
+*/
+function parseUploadComplete(value, knownFileId) {
+	const files = value["files"];
+	if (Array.isArray(files) && files.length > 0) {
+		const first = files[0];
+		if (isPlainObject(first)) {
+			const fileId = (isString(first["id"]) && first["id"].length > 0 ? first["id"] : void 0) ?? knownFileId;
+			const fromShares = extractTsFromShares(first["shares"]);
+			if (fromShares) return {
+				message_id: fromShares,
+				...fileId && { file_id: fileId }
+			};
+			if (fileId) return {
+				message_id: fileId,
+				file_id: fileId
+			};
+		}
+	}
+	if (knownFileId) return {
+		message_id: knownFileId,
+		file_id: knownFileId
+	};
+	throw new ToolError("Slack files.completeUploadExternal returned invalid payload", { code: "upstream" });
+}
+function extractTsFromShares(shares) {
+	if (!isPlainObject(shares)) return void 0;
+	for (const bucket of Object.values(shares)) {
+		if (!isPlainObject(bucket)) continue;
+		for (const entries of Object.values(bucket)) {
+			if (!Array.isArray(entries)) continue;
+			for (const entry of entries) if (isPlainObject(entry) && isString(entry["ts"]) && entry["ts"].length > 0) return entry["ts"];
+		}
+	}
+}
+function parseConversationsList(value) {
+	const channelsRaw = value["channels"];
+	if (!Array.isArray(channelsRaw)) throw new ToolError("Slack conversations.list returned invalid payload", { code: "upstream" });
+	const channels = [];
+	for (const row of channelsRaw) {
+		if (!isPlainObject(row) || !isString(row["id"])) continue;
+		channels.push({
+			id: row["id"],
+			...isString(row["name"]) && { name: row["name"] },
+			...typeof row["is_channel"] === "boolean" && { is_channel: row["is_channel"] },
+			...typeof row["is_im"] === "boolean" && { is_im: row["is_im"] },
+			...typeof row["is_mpim"] === "boolean" && { is_mpim: row["is_mpim"] },
+			...typeof row["is_private"] === "boolean" && { is_private: row["is_private"] }
+		});
+	}
+	const nextCursor = nextCursorFrom(value);
+	return {
+		channels,
+		...nextCursor && { next_cursor: nextCursor }
+	};
+}
+/** Empty + size checks shared by base64 and raw-byte media paths. */
+function assertMediaBytes(bytes) {
+	if (bytes.byteLength === 0) throw new ToolError("Media body must not be empty", { code: "bad_input" });
+	if (bytes.byteLength > 104857600) throw new ToolError("Media exceeds 100 MiB limit", {
+		code: "too_large",
+		details: {
+			max_bytes: MAX_MEDIA_BYTES,
+			content_length: bytes.byteLength
+		}
+	});
+	return bytes;
+}
+function decodeMediaBytes(bodyBase64) {
+	let bytes;
+	try {
+		bytes = base64ToBytes(bodyBase64);
+	} catch (error) {
+		throw new ToolError("Invalid base64 body", {
+			code: "bad_input",
+			cause: error
+		});
+	}
+	return assertMediaBytes(bytes);
+}
+/** Host may pass raw bytes instead of base64 (client path only). */
+function resolveMediaBytes(input) {
+	const bytes = input.body !== void 0 ? assertMediaBytes(input.body) : input.body_base64 ? decodeMediaBytes(input.body_base64) : void 0;
+	if (!bytes) throw new ToolError("Media requires body_base64 or body (Uint8Array)", { code: "bad_input" });
+	return {
+		bytes,
+		body: toArrayBuffer(bytes)
+	};
+}
+function nextCursorFrom(value) {
+	const metadata = value["response_metadata"];
+	return isPlainObject(metadata) ? firstString$1(metadata["next_cursor"]) : void 0;
+}
+function parseUsersInfo(value) {
+	const user = value["user"];
+	if (!isPlainObject(user) || !isString(user["id"])) throw new ToolError("Slack users.info returned invalid payload", { code: "upstream" });
+	const profile = isPlainObject(user["profile"]) ? user["profile"] : void 0;
+	const out = { user_id: user["id"] };
+	const name = firstString$1(user["name"]);
+	if (name) out.name = name;
+	const realName = firstString$1(user["real_name"]);
+	if (realName) out.real_name = realName;
+	const displayName = firstString$1(profile?.["display_name"], profile?.["real_name"], user["real_name"]);
+	if (displayName) out.display_name = displayName;
+	if (typeof user["is_bot"] === "boolean") out.is_bot = user["is_bot"];
+	const tz = firstString$1(user["tz"]);
+	if (tz) out.tz = tz;
+	if (profile) out.profile = profile;
+	return out;
+}
+function parseConversationInfo(value) {
+	const channel = value["channel"];
+	if (!isPlainObject(channel) || !isString(channel["id"])) throw new ToolError("Slack conversations.info returned invalid payload", { code: "upstream" });
+	const out = {
+		id: channel["id"],
+		raw: channel
+	};
+	const name = firstString$1(channel["name"]);
+	if (name) out.name = name;
+	if (typeof channel["is_channel"] === "boolean") out.is_channel = channel["is_channel"];
+	if (typeof channel["is_im"] === "boolean") out.is_im = channel["is_im"];
+	if (typeof channel["is_mpim"] === "boolean") out.is_mpim = channel["is_mpim"];
+	if (typeof channel["is_private"] === "boolean") out.is_private = channel["is_private"];
+	if (typeof channel["is_archived"] === "boolean") out.is_archived = channel["is_archived"];
+	if (typeof channel["num_members"] === "number") out.num_members = channel["num_members"];
+	return out;
+}
+function parseConversationMessages(value) {
+	const messagesRaw = value["messages"];
+	if (!Array.isArray(messagesRaw)) throw new ToolError("Slack conversation messages payload invalid", { code: "upstream" });
+	const out = { messages: messagesRaw.filter(isPlainObject) };
+	const nextCursor = nextCursorFrom(value);
+	if (nextCursor) out.next_cursor = nextCursor;
+	if (typeof value["has_more"] === "boolean") out.has_more = value["has_more"];
+	return out;
+}
+function parseAuthRevoke(value) {
+	return { revoked: value["revoked"] === true };
+}
+function parseStreamTs(value) {
+	const ts = firstString$1(value["ts"]);
+	if (!ts) throw new ToolError("Slack stream API returned invalid payload (missing ts)", { code: "upstream" });
+	return { message_id: ts };
+}
+function parseUploadBatchComplete(value, knownFileIds) {
+	const files = Array.isArray(value["files"]) ? value["files"] : [];
+	const fromResponse = [];
+	for (const file of files) if (isPlainObject(file)) {
+		const id = firstString$1(file["id"]);
+		if (id) fromResponse.push(id);
+	}
+	const fileIds = fromResponse.length > 0 ? fromResponse : knownFileIds;
+	const first = isPlainObject(files[0]) ? files[0] : void 0;
+	const messageId = (first ? extractTsFromShares(first["shares"]) : void 0) ?? fileIds[0];
+	if (!messageId || fileIds.length === 0) throw new ToolError("Slack files.completeUploadExternal returned no file ids", { code: "upstream" });
+	return {
+		message_id: messageId,
+		file_ids: fileIds
+	};
+}
+function isHttpsUrl(value) {
+	return value.startsWith("https://") || value.startsWith("http://");
+}
+/**
+* Map shared chat-action enum → assistant.threads.setStatus status text.
+* Slack renders as "{App Name} {status}" (do not include the app name).
+*/
+function assistantStatusFromChatAction(action) {
+	switch (action) {
+		case "upload_photo":
+		case "upload_video":
+		case "upload_voice":
+		case "upload_document":
+		case "upload_video_note": return "is uploading a file…";
+		case "record_video":
+		case "record_voice":
+		case "record_video_note": return "is recording…";
+		case "choose_sticker":
+		case "find_location": return "is working on your request…";
+		default: return "is checking the request…";
+	}
+}
+function firstString$1(...values) {
+	for (const value of values) if (isString(value) && value.length > 0) return value;
+}
+//#endregion
+//#region src/vendors/slack/client.ts
+/**
+* Slack Web API vendor client.
+* Host: `new SlackClient(auth)`. Agent tools: `fromContext(ctx)`.
+*/
+var SlackClient = class SlackClient {
+	#token;
+	/** Authenticated Slack Web API (`https://slack.com/api`). */
+	#http;
+	/** Bare HTTP for pre-signed upload URLs and interactive response_url (no bot Authorization). */
+	#external;
+	constructor(auth, options = {}) {
+		const parsed = slackAuthSchema.safeParse(auth);
+		if (!parsed.success) throw new ToolError("Invalid Slack auth credentials", {
+			code: "bad_auth",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		this.#token = parsed.data.bot_token;
+		this.#http = new HttpService({
+			...options,
+			baseURL: "https://slack.com/api",
+			headers: {
+				Authorization: `Bearer ${parsed.data.bot_token}`,
+				"Content-Type": "application/json"
+			},
+			label: "Slack"
+		});
+		this.#external = new HttpService({
+			...options,
+			label: "Slack"
+		});
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, slackAuthSchema);
+		return new SlackClient(auth, {
+			...ctx.fetch && { fetch: ctx.fetch },
+			...ctx.signal && { signal: ctx.signal }
+		});
+	}
+	async #api(method, body, label) {
+		try {
+			const res = await this.#http.post(`/${method}`, body, {
+				label,
+				noThrow: true
+			});
+			return parseSlackResult(label, res.status, res.data);
+		} catch (error) {
+			throwSlackTransportError(label, error);
+		}
+	}
+	/** Form-urlencoded Web API call (used where Slack documents form as primary, e.g. getUploadURLExternal). */
+	async #apiForm(method, body, label) {
+		try {
+			const res = await this.#http.post(`/${method}`, body, {
+				label,
+				noThrow: true,
+				headers: {
+					Authorization: `Bearer ${this.#token}`,
+					"Content-Type": "application/x-www-form-urlencoded"
+				}
+			});
+			return parseSlackResult(label, res.status, res.data);
+		} catch (error) {
+			throwSlackTransportError(label, error);
+		}
+	}
+	/** POST chat.postMessage */
+	async sendText(input) {
+		const body = {
+			channel: input.chat_id,
+			text: input.text,
+			...input.reply_to_message_id && { thread_ts: input.reply_to_message_id },
+			...input.reply_markup !== void 0 && { blocks: input.reply_markup }
+		};
+		return parseMessageTs(await this.#api("chat.postMessage", body, "Slack chat.postMessage"));
+	}
+	/** POST chat.update */
+	async editText(input) {
+		const body = {
+			channel: input.chat_id,
+			ts: input.message_id,
+			text: input.text,
+			...input.reply_markup !== void 0 && { blocks: input.reply_markup }
+		};
+		return parseMessageTs(await this.#api("chat.update", body, "Slack chat.update"));
+	}
+	/**
+	* Chat action (typing / upload_*).
+	* With `reply_to_message_id` (thread_ts): `assistant.threads.setStatus` loading line.
+	* Without thread_ts: no-op (Slack has no channel-level typing API).
+	* @see https://docs.slack.dev/reference/methods/assistant.threads.setStatus
+	*/
+	async sendChatAction(input) {
+		const threadTs = input.reply_to_message_id;
+		if (!threadTs) return;
+		parseOk(await this.#api("assistant.threads.setStatus", {
+			channel_id: input.chat_id,
+			thread_ts: threadTs,
+			status: assistantStatusFromChatAction(input.action)
+		}, "Slack assistant.threads.setStatus"));
+	}
+	/**
+	* Clear assistant thread status (`status: ""`).
+	* Requires `reply_to_message_id` (thread_ts); otherwise no-op.
+	*/
+	async stopTyping(input) {
+		const threadTs = input.reply_to_message_id;
+		if (!threadTs) return;
+		parseOk(await this.#api("assistant.threads.setStatus", {
+			channel_id: input.chat_id,
+			thread_ts: threadTs,
+			status: ""
+		}, "Slack assistant.threads.setStatus clear"));
+	}
+	/** POST reactions.add */
+	async setReaction(input) {
+		parseOk(await this.#api("reactions.add", {
+			channel: input.chat_id,
+			timestamp: input.message_id,
+			name: normalizeEmojiName(input.emoji)
+		}, "Slack reactions.add"));
+	}
+	/** POST reactions.remove — emoji required on Slack. */
+	async clearReaction(input) {
+		parseOk(await this.#api("reactions.remove", {
+			channel: input.chat_id,
+			timestamp: input.message_id,
+			name: normalizeEmojiName(input.emoji)
+		}, "Slack reactions.remove"));
+	}
+	/**
+	* External upload flow:
+	* files.getUploadURLExternal → POST bytes to upload_url → files.completeUploadExternal
+	* @see https://docs.slack.dev/reference/methods/files.getUploadURLExternal
+	*/
+	async sendMedia(input) {
+		const { bytes, body } = resolveMediaBytes(input);
+		const form = new URLSearchParams();
+		form.set("filename", input.file_name);
+		form.set("length", String(bytes.byteLength));
+		const upload = parseUploadUrl(await this.#apiForm("files.getUploadURLExternal", form, "Slack files.getUploadURLExternal"));
+		const putHeaders = { "Content-Type": input.content_type ?? "application/octet-stream" };
+		let put;
+		try {
+			put = await this.#external.post(upload.upload_url, body, {
+				label: "Slack file upload POST",
+				noThrow: true,
+				headers: putHeaders
+			});
+		} catch (error) {
+			throwSlackTransportError("Slack file upload POST", error);
+		}
+		if (!put.ok) throw new SlackClientError({
+			message: `Slack file upload POST failed with HTTP ${put.status}`,
+			failureKind: put.status === 400 || put.status === 401 || put.status === 403 || put.status === 404 ? "definite_rejection" : "outcome_unknown",
+			method: "Slack file upload POST",
+			status: put.status
+		});
+		return parseUploadComplete(await this.#api("files.completeUploadExternal", {
+			files: [{
+				id: upload.file_id,
+				title: input.file_name
+			}],
+			channel_id: input.chat_id,
+			...input.reply_to_message_id && { thread_ts: input.reply_to_message_id },
+			...input.caption && { initial_comment: input.caption }
+		}, "Slack files.completeUploadExternal"), upload.file_id);
+	}
+	/** POST files.info + GET url_private_download (Bearer). */
+	async downloadFile(input) {
+		const file = parseFileInfo(await this.#api("files.info", { file: input.file_id }, "Slack files.info"));
+		let res;
+		try {
+			res = await this.#http.bytes("GET", file.url_private_download, {
+				label: "Slack downloadFile",
+				noThrow: true,
+				headers: { Authorization: `Bearer ${this.#token}` }
+			});
+		} catch (error) {
+			throwSlackTransportError("Slack downloadFile", error);
+		}
+		if (!res.ok) throw new SlackClientError({
+			message: `Slack downloadFile failed with HTTP ${res.status}`,
+			failureKind: res.status === 400 || res.status === 401 || res.status === 403 || res.status === 404 ? "definite_rejection" : "outcome_unknown",
+			method: "Slack downloadFile",
+			status: res.status
+		});
+		return parseDownload(input, file, res.bytes);
+	}
+	/**
+	* Answer an interactive payload.
+	* When callback_query_id is an http(s) response_url, POST ephemeral JSON to it.
+	* Otherwise no-op success (Slack has no Telegram-style answerCallbackQuery id).
+	*/
+	async answerCallback(input) {
+		if (!isHttpsUrl(input.callback_query_id)) return;
+		const body = {
+			replace_original: false,
+			response_type: "ephemeral",
+			...input.text && { text: input.text }
+		};
+		let res;
+		try {
+			res = await this.#external.post(input.callback_query_id, body, {
+				label: "Slack response_url",
+				noThrow: true,
+				headers: { "Content-Type": "application/json" }
+			});
+		} catch (error) {
+			throwSlackTransportError("Slack response_url", error);
+		}
+		if (!res.ok) throw new SlackClientError({
+			message: `Slack response_url failed with HTTP ${res.status}`,
+			failureKind: res.status === 400 || res.status === 401 || res.status === 403 || res.status === 404 ? "definite_rejection" : "outcome_unknown",
+			method: "Slack response_url",
+			status: res.status
+		});
+	}
+	/** POST auth.test */
+	async getBot() {
+		return parseBot(await this.#api("auth.test", {}, "Slack auth.test"));
+	}
+	/** POST chat.postEphemeral */
+	async postEphemeral(input) {
+		const body = {
+			channel: input.chat_id,
+			user: input.user_id,
+			text: input.text,
+			...input.reply_markup !== void 0 && { blocks: input.reply_markup }
+		};
+		const messageTs = (await this.#api("chat.postEphemeral", body, "Slack chat.postEphemeral"))["message_ts"];
+		if (typeof messageTs === "string" && messageTs.length > 0) return { message_id: messageTs };
+		return { message_id: "ephemeral" };
+	}
+	/** POST conversations.list */
+	async listConversations(input = {}) {
+		const body = {
+			...input.limit !== void 0 && { limit: input.limit },
+			...input.cursor && { cursor: input.cursor },
+			...input.types && { types: input.types }
+		};
+		return parseConversationsList(await this.#api("conversations.list", body, "Slack conversations.list"));
+	}
+	/**
+	* Full assistant.threads.setStatus (custom status + optional loading_messages).
+	* Prefer this over sendChatAction when the host already has status copy.
+	* @see https://docs.slack.dev/reference/methods/assistant.threads.setStatus
+	*/
+	async setAssistantStatus(input) {
+		parseOk(await this.#api("assistant.threads.setStatus", {
+			channel_id: input.chat_id,
+			thread_ts: input.thread_ts,
+			status: input.status,
+			...input.loading_messages && input.loading_messages.length > 0 && { loading_messages: input.loading_messages }
+		}, "Slack assistant.threads.setStatus"));
+	}
+	/** POST assistant.threads.setSuggestedPrompts (max 4). */
+	async setSuggestedPrompts(input) {
+		parseOk(await this.#api("assistant.threads.setSuggestedPrompts", {
+			channel_id: input.chat_id,
+			prompts: input.prompts,
+			...input.thread_ts && { thread_ts: input.thread_ts },
+			...input.title && { title: input.title }
+		}, "Slack assistant.threads.setSuggestedPrompts"));
+	}
+	/** POST views.publish — App Home for a user. */
+	async publishHome(input) {
+		parseOk(await this.#api("views.publish", {
+			user_id: input.user_id,
+			view: input.view,
+			...input.hash && { hash: input.hash }
+		}, "Slack views.publish"));
+	}
+	/** POST chat.startStream — begins a streaming thread reply. */
+	async startStream(input) {
+		const body = {
+			channel: input.chat_id,
+			thread_ts: input.thread_ts,
+			...input.markdown_text && { markdown_text: input.markdown_text },
+			...input.recipient_user_id && { recipient_user_id: input.recipient_user_id },
+			...input.recipient_team_id && { recipient_team_id: input.recipient_team_id },
+			...input.task_display_mode && { task_display_mode: input.task_display_mode }
+		};
+		return parseStreamTs(await this.#api("chat.startStream", body, "Slack chat.startStream"));
+	}
+	/** POST chat.appendStream */
+	async appendStream(input) {
+		return parseStreamTs(await this.#api("chat.appendStream", {
+			channel: input.chat_id,
+			ts: input.message_id,
+			markdown_text: input.markdown_text
+		}, "Slack chat.appendStream"));
+	}
+	/** POST chat.stopStream */
+	async stopStream(input) {
+		const body = {
+			channel: input.chat_id,
+			ts: input.message_id,
+			...input.markdown_text && { markdown_text: input.markdown_text },
+			...input.blocks !== void 0 && { blocks: input.blocks }
+		};
+		return parseStreamTs(await this.#api("chat.stopStream", body, "Slack chat.stopStream"));
+	}
+	/** POST auth.revoke — disconnect installation (host-only). */
+	async authRevoke(input = {}) {
+		const body = { ...input.test !== void 0 && { test: input.test } };
+		return parseAuthRevoke(await this.#api("auth.revoke", body, "Slack auth.revoke"));
+	}
+	/** POST users.info */
+	async usersInfo(input) {
+		return parseUsersInfo(await this.#api("users.info", {
+			user: input.user_id,
+			...input.include_locale !== void 0 && { include_locale: input.include_locale }
+		}, "Slack users.info"));
+	}
+	/** POST users.conversations */
+	async usersConversations(input = {}) {
+		const body = {
+			...input.user_id && { user: input.user_id },
+			...input.limit !== void 0 && { limit: input.limit },
+			...input.cursor && { cursor: input.cursor },
+			...input.types && { types: input.types },
+			...input.exclude_archived !== void 0 && { exclude_archived: input.exclude_archived }
+		};
+		return parseConversationsList(await this.#api("users.conversations", body, "Slack users.conversations"));
+	}
+	/** POST conversations.info */
+	async conversationsInfo(input) {
+		return parseConversationInfo(await this.#api("conversations.info", {
+			channel: input.chat_id,
+			...input.include_locale !== void 0 && { include_locale: input.include_locale },
+			...input.include_num_members !== void 0 && { include_num_members: input.include_num_members }
+		}, "Slack conversations.info"));
+	}
+	/** POST conversations.history */
+	async conversationsHistory(input) {
+		const body = {
+			channel: input.chat_id,
+			...input.limit !== void 0 && { limit: input.limit },
+			...input.cursor && { cursor: input.cursor },
+			...input.oldest && { oldest: input.oldest },
+			...input.latest && { latest: input.latest },
+			...input.inclusive !== void 0 && { inclusive: input.inclusive }
+		};
+		return parseConversationMessages(await this.#api("conversations.history", body, "Slack conversations.history"));
+	}
+	/** POST conversations.replies */
+	async conversationsReplies(input) {
+		const body = {
+			channel: input.chat_id,
+			ts: input.message_id,
+			...input.limit !== void 0 && { limit: input.limit },
+			...input.cursor && { cursor: input.cursor },
+			...input.oldest && { oldest: input.oldest },
+			...input.latest && { latest: input.latest },
+			...input.inclusive !== void 0 && { inclusive: input.inclusive }
+		};
+		return parseConversationMessages(await this.#api("conversations.replies", body, "Slack conversations.replies"));
+	}
+	/**
+	* Multi-file external upload: get URL + PUT each file, then one completeUploadExternal.
+	* Host may pass `body` (Uint8Array) on each item instead of body_base64.
+	*/
+	async sendMediaBatch(input) {
+		const completed = [];
+		for (const file of input.files) {
+			const { bytes, body } = resolveMediaBytes(file);
+			const form = new URLSearchParams();
+			form.set("filename", file.file_name);
+			form.set("length", String(bytes.byteLength));
+			const upload = parseUploadUrl(await this.#apiForm("files.getUploadURLExternal", form, "Slack files.getUploadURLExternal"));
+			let put;
+			try {
+				put = await this.#external.post(upload.upload_url, body, {
+					label: "Slack file upload POST",
+					noThrow: true,
+					headers: { "Content-Type": file.content_type ?? "application/octet-stream" }
+				});
+			} catch (error) {
+				throwSlackTransportError("Slack file upload POST", error);
+			}
+			if (!put.ok) throw new SlackClientError({
+				message: `Slack file upload POST failed with HTTP ${put.status}`,
+				failureKind: put.status === 400 || put.status === 401 || put.status === 403 || put.status === 404 ? "definite_rejection" : "outcome_unknown",
+				method: "Slack file upload POST",
+				status: put.status
+			});
+			completed.push({
+				id: upload.file_id,
+				...file.title || file.file_name ? { title: file.title ?? file.file_name } : {}
+			});
+		}
+		return parseUploadBatchComplete(await this.#api("files.completeUploadExternal", {
+			files: completed,
+			channel_id: input.chat_id,
+			...input.reply_to_message_id && { thread_ts: input.reply_to_message_id },
+			...input.caption && { initial_comment: input.caption }
+		}, "Slack files.completeUploadExternal"), completed.map((f) => f.id));
+	}
+	/**
+	* Download file bytes for host (no base64). Tool path still uses downloadFile → body_base64.
+	*/
+	async downloadFileBytes(input) {
+		const file = parseFileInfo(await this.#api("files.info", { file: input.file_id }, "Slack files.info"));
+		let res;
+		try {
+			res = await this.#http.bytes("GET", file.url_private_download, {
+				label: "Slack downloadFileBytes",
+				noThrow: true,
+				headers: { Authorization: `Bearer ${this.#token}` }
+			});
+		} catch (error) {
+			throwSlackTransportError("Slack downloadFileBytes", error);
+		}
+		if (!res.ok) throw new SlackClientError({
+			message: `Slack downloadFileBytes failed with HTTP ${res.status}`,
+			failureKind: res.status === 400 || res.status === 401 || res.status === 403 || res.status === 404 ? "definite_rejection" : "outcome_unknown",
+			method: "Slack downloadFileBytes",
+			status: res.status
+		});
+		const out = {
+			file_name: input.file_name ?? file.file_name ?? file.file_id,
+			body: res.bytes
+		};
+		if (file.file_size !== void 0) out.file_size = file.file_size;
+		return out;
+	}
+};
+//#endregion
+//#region src/vendors/slack/module.ts
+const emptyInputSchema = z.object({}).describe("No input fields");
+const slackSendTextTool = defineTool({
+	id: "slack-send-text",
+	name: "slackSendText",
+	description: "Send a text message to a Slack channel or DM. Optional reply_to_message_id anchors a thread reply. Optional reply_markup is a Block Kit blocks array. Returns the new message_id (ts).",
+	inputSchema: slackSendTextInputSchema,
+	outputSchema: slackMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "node",
+	execute: async (input, ctx) => SlackClient.fromContext(ctx).sendText(input)
+});
+const slackEditTextTool = defineTool({
+	id: "slack-edit-text",
+	name: "slackEditText",
+	description: "Edit the text of an existing Slack message. Used for progressive live updates and corrections.",
+	inputSchema: slackEditTextInputSchema,
+	outputSchema: slackMessageOutputSchema,
+	sideEffect: "write",
+	runtime: "node",
+	execute: async (input, ctx) => SlackClient.fromContext(ctx).editText(input)
+});
+const slackSendChatActionTool = defineTool({
+	id: "slack-send-chat-action",
+	name: "slackSendChatAction",
+	description: "Show busy status on a Slack assistant thread. Pass reply_to_message_id as the thread root ts (thread_ts) to call assistant.threads.setStatus (e.g. “is checking the request…”). Without reply_to_message_id this is a no-op (no channel-level typing API).",
+	inputSchema: slackSendChatActionInputSchema,
+	outputSchema: slackOkOutputSchema,
+	sideEffect: "none",
+	runtime: "node",
+	execute: async (input, ctx) => {
+		await SlackClient.fromContext(ctx).sendChatAction(input);
+		return { ok: true };
+	}
+});
+const slackSetReactionTool = defineTool({
+	id: "slack-set-reaction",
+	name: "slackSetReaction",
+	description: "Add an emoji reaction on a Slack message. Pass the emoji name with or without colons (e.g. thumbsup or :thumbsup:).",
+	inputSchema: slackSetReactionInputSchema,
+	outputSchema: slackOkOutputSchema,
+	sideEffect: "write",
+	runtime: "node",
+	execute: async (input, ctx) => {
+		await SlackClient.fromContext(ctx).setReaction(input);
+		return { ok: true };
+	}
+});
+const slackClearReactionTool = defineTool({
+	id: "slack-clear-reaction",
+	name: "slackClearReaction",
+	description: "Remove one emoji reaction the bot added on a Slack message. emoji is required (Slack cannot clear all reactions in one call).",
+	inputSchema: slackClearReactionInputSchema,
+	outputSchema: slackOkOutputSchema,
+	sideEffect: "write",
+	runtime: "node",
+	execute: async (input, ctx) => {
+		await SlackClient.fromContext(ctx).clearReaction(input);
+		return { ok: true };
+	}
+});
+const slackSendMediaTool = defineTool({
+	id: "slack-send-media",
+	name: "slackSendMedia",
+	description: "Upload one photo or document to a Slack channel from a base64 body (external upload flow). Optional caption becomes the initial comment.",
+	inputSchema: slackSendMediaInputSchema,
+	outputSchema: slackMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "node",
+	execute: async (input, ctx) => SlackClient.fromContext(ctx).sendMedia(input)
+});
+const slackDownloadFileTool = defineTool({
+	id: "slack-download-file",
+	name: "slackDownloadFile",
+	description: "Download a Slack file by file_id and return the body as base64 with optional size and name.",
+	inputSchema: slackDownloadFileInputSchema,
+	outputSchema: slackDownloadFileOutputSchema,
+	sideEffect: "read",
+	runtime: "node",
+	execute: async (input, ctx) => SlackClient.fromContext(ctx).downloadFile(input)
+});
+const slackAnswerCallbackTool = defineTool({
+	id: "slack-answer-callback",
+	name: "slackAnswerCallback",
+	description: "Acknowledge a Slack interactive payload. When callback_query_id is a response_url, posts an ephemeral reply. Otherwise succeeds without a network call.",
+	inputSchema: slackAnswerCallbackInputSchema,
+	outputSchema: slackOkOutputSchema,
+	sideEffect: "write",
+	runtime: "node",
+	execute: async (input, ctx) => {
+		await SlackClient.fromContext(ctx).answerCallback(input);
+		return { ok: true };
+	}
+});
+const slackGetBotTool = defineTool({
+	id: "slack-get-bot",
+	name: "slackGetBot",
+	description: "Return the current Slack bot identity, including bot_id, username, and display_name.",
+	inputSchema: emptyInputSchema,
+	outputSchema: slackGetBotOutputSchema,
+	sideEffect: "read",
+	runtime: "node",
+	execute: async (_input, ctx) => SlackClient.fromContext(ctx).getBot()
+});
+const slackModule = defineModule({
+	id: "slack",
+	title: "Slack",
+	description: "Slack Web API vendor pack: text, media upload, chat-action parity, reactions, file download, interactive callbacks, bot identity. Expand with more Web API methods over time. Not a multi-provider messaging seam.",
+	runtime: "node",
+	auth: {
+		type: "custom",
+		schema: slackAuthSchema
+	},
+	categories: ["messaging", "chat"],
+	classification: "pii",
+	tags: ["slack"],
+	tools: [
+		slackSendTextTool,
+		slackEditTextTool,
+		slackSendChatActionTool,
+		slackSetReactionTool,
+		slackClearReactionTool,
+		slackSendMediaTool,
+		slackDownloadFileTool,
+		slackAnswerCallbackTool,
+		slackGetBotTool
+	]
+});
+//#endregion
+//#region src/vendors/slack/reference.ts
+/**
+* Pure Slack mrkdwn / reference helpers (no HTTP).
+* Host uses these when resolving mentions, channel refs, and permalinks for tools.
+*/
+/** User mention: `<@U123>` or `<@U123|label>` → user id. */
+const USER_MENTION = /<@([UW][A-Z0-9]+)(?:\|[^>]*)?>/g;
+/** Channel reference: `<#C123>` or `<#C123|name>` → channel id. */
+const CHANNEL_REF = /<#([CGD][A-Z0-9]+)(?:\|[^>]*)?>/g;
+/** Special commands / mailto / bare links in angle brackets. */
+const SPECIAL_CMD = /<!([^>|]+)(?:\|[^>]*)?>/g;
+/**
+* Extract Slack user ids mentioned in message text (`<@U…>`).
+*/
+function extractSlackUserMentions(text) {
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	USER_MENTION.lastIndex = 0;
+	let match;
+	while ((match = USER_MENTION.exec(text)) !== null) {
+		const id = match[1];
+		if (id && !seen.has(id)) {
+			seen.add(id);
+			ids.push(id);
+		}
+	}
+	return ids;
+}
+/**
+* Extract channel ids from `<#C…>` references in text.
+*/
+function extractSlackChannelRefs(text) {
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	CHANNEL_REF.lastIndex = 0;
+	let match;
+	while ((match = CHANNEL_REF.exec(text)) !== null) {
+		const id = match[1];
+		if (id && !seen.has(id)) {
+			seen.add(id);
+			ids.push(id);
+		}
+	}
+	return ids;
+}
+/**
+* Format a user mention for outgoing mrkdwn.
+*/
+function formatSlackUserMention(userId, label) {
+	return label && label.length > 0 ? `<@${userId}|${label}>` : `<@${userId}>`;
+}
+/**
+* Format a channel reference for outgoing mrkdwn.
+*/
+function formatSlackChannelRef(channelId, name) {
+	return name && name.length > 0 ? `<#${channelId}|${name}>` : `<#${channelId}>`;
+}
+/**
+* Build an app message permalink.
+* @see https://api.slack.com/methods/chat.getPermalink (host may also call the API)
+*/
+function formatSlackMessagePermalink(input) {
+	const domain = input.team_domain.replace(/^https?:\/\//, "").replace(/\.slack\.com\/?$/, "");
+	const ts = input.message_id.replace(".", "");
+	return `https://${domain}.slack.com/archives/${input.chat_id}/p${ts}`;
+}
+/**
+* Strip a leading bot user mention from inbound text (common in channels with @bot).
+* Only removes a mention of `botUserId` at the start (optional surrounding whitespace).
+*/
+function stripLeadingSlackBotMention(text, botUserId) {
+	if (!botUserId) return text;
+	const escaped = botUserId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const re = new RegExp(`^\\s*<@${escaped}(?:\\|[^>]*)?>\\s*`);
+	return text.replace(re, "");
+}
+/**
+* Lightweight mrkdwn → plain-ish text for logging / model context (not full Slack rendering).
+* Removes mention markup, channel refs, and special commands; keeps link labels when present.
+*/
+function slackMrkdwnToPlainText(text) {
+	let out = text;
+	out = out.replace(USER_MENTION, (_m, id) => `@${id}`);
+	out = out.replace(CHANNEL_REF, (_m, id) => `#${id}`);
+	out = out.replace(SPECIAL_CMD, (_m, cmd) => `@${cmd}`);
+	out = out.replace(/<([^|>]+)\|([^>]+)>/g, "$2");
+	out = out.replace(/<([^>]+)>/g, "$1");
+	return out;
+}
+//#endregion
+//#region src/vendors/slack/webhook.ts
+/**
+* Verify Slack request signature (X-Slack-Signature).
+* HMAC-SHA256 of `v0:{timestamp}:{raw_body}` compared to `v0={hex}`.
+* Rejects empty inputs and timestamps older/newer than maxAgeSeconds (default 5 minutes).
+*/
+function verifySlackRequestSignature(input) {
+	const { signing_secret, raw_body, timestamp, signature } = input;
+	if (!signing_secret || !timestamp || !signature) return false;
+	if (!/^\d+$/.test(timestamp)) return false;
+	const maxAge = input.maxAgeSeconds ?? 300;
+	const now = input.nowSeconds ?? Math.floor(Date.now() / 1e3);
+	const ts = Number.parseInt(timestamp, 10);
+	if (!Number.isFinite(ts) || Math.abs(now - ts) > maxAge) return false;
+	const base = `v0:${timestamp}:${raw_body}`;
+	const expected = `v0=${createHmac("sha256", signing_secret).update(base, "utf8").digest("hex")}`;
+	const a = Buffer.from(expected, "utf8");
+	const b = Buffer.from(signature, "utf8");
+	if (a.byteLength !== b.byteLength) return false;
+	return timingSafeEqual(a, b);
+}
+/**
+* Parse one raw Slack Events API / interactive body into a normalized inbound event.
+* Handles url_verification challenges, event_callback messages, and interactive payloads.
+*/
+function parseSlackEvent(body, options) {
+	if (isString(body)) return parseSlackEvent(tryParseJson(body) ?? tryParsePayloadForm(body) ?? body, options);
+	if (!isPlainObject(body)) return {
+		ok: false,
+		reason: "body_not_object"
+	};
+	const receivedAt = options?.received_at ?? (/* @__PURE__ */ new Date()).toISOString();
+	const allowGroups = options?.allow_group_chats ?? true;
+	if (body["type"] === "url_verification" && isString(body["challenge"])) return {
+		ok: true,
+		challenge: body["challenge"]
+	};
+	if (body["type"] === "event_callback" && isPlainObject(body["event"])) return parseEventCallback(body, body["event"], receivedAt, allowGroups);
+	if (isInteractionType(body["type"])) return parseInteraction(body, receivedAt);
+	if (isString(body["type"]) && (body["type"] === "message" || body["type"] === "app_mention")) {
+		const teamId = isString(body["team"]) ? body["team"] : void 0;
+		return parseMessageEvent(body, {
+			eventId: firstString(body["event_ts"], body["ts"]) ?? "unknown",
+			receivedAt,
+			allowGroups,
+			rawType: body["type"],
+			...teamId && { teamId }
+		});
+	}
+	return {
+		ok: false,
+		reason: "unsupported_event_type"
+	};
+}
+function parseEventCallback(envelope, event, receivedAt, allowGroups) {
+	const eventId = firstString(envelope["event_id"], event["event_ts"], event["ts"]);
+	if (!eventId) return {
+		ok: false,
+		reason: "missing_event_id"
+	};
+	const teamId = isString(envelope["team_id"]) ? envelope["team_id"] : void 0;
+	const type = isString(event["type"]) ? event["type"] : "unknown";
+	if (type === "message" || type === "app_mention") return parseMessageEvent(event, {
+		eventId,
+		receivedAt,
+		allowGroups,
+		rawType: type,
+		...teamId && { teamId }
+	});
+	return {
+		ok: false,
+		reason: "unsupported_event_type"
+	};
+}
+function parseMessageEvent(event, ctx) {
+	const subtype = isString(event["subtype"]) ? event["subtype"] : void 0;
+	if (subtype && subtype !== "file_share") return {
+		ok: false,
+		reason: "unsupported_message_subtype"
+	};
+	const chatId = firstString(event["channel"]);
+	if (!chatId) return {
+		ok: false,
+		reason: "missing_channel"
+	};
+	const channelType = firstString(event["channel_type"]);
+	if (!ctx.allowGroups && channelType && channelType !== "im" && channelType !== "mpim") return {
+		ok: false,
+		reason: "non_dm_chat"
+	};
+	const userId = firstString(event["user"]);
+	const messageId = firstString(event["ts"]);
+	const text = firstString(event["text"]);
+	const media = collectMedia(event);
+	const replyTo = firstString(event["thread_ts"]);
+	const replyToParent = replyTo && messageId && replyTo !== messageId ? replyTo : void 0;
+	if (!text && media.length === 0) return {
+		ok: false,
+		reason: "empty_message"
+	};
+	return {
+		ok: true,
+		event: {
+			channel: "slack",
+			event_id: ctx.eventId,
+			chat_id: chatId,
+			raw_type: ctx.rawType,
+			received_at: ctx.receivedAt,
+			...userId && { user_id: userId },
+			...messageId && { message_id: messageId },
+			...text && { text },
+			...media.length > 0 && { media },
+			...replyToParent && { reply_to: replyToParent },
+			...channelType && { chat_type: channelType },
+			...ctx.teamId && { team_id: ctx.teamId }
+		}
+	};
+}
+function parseInteraction(body, receivedAt) {
+	const type = isString(body["type"]) ? body["type"] : "interaction";
+	const channel = body["channel"];
+	const chatId = isPlainObject(channel) ? firstString(channel["id"]) : firstString(body["channel_id"], body["channel"]);
+	if (!chatId) return {
+		ok: false,
+		reason: "interaction_missing_channel"
+	};
+	const user = body["user"];
+	const userId = isPlainObject(user) ? firstString(user["id"]) : firstString(body["user_id"]);
+	const username = isPlainObject(user) ? firstString(user["username"], user["name"]) : void 0;
+	const message = body["message"];
+	const messageId = isPlainObject(message) ? firstString(message["ts"]) : firstString(body["message_ts"]);
+	const responseUrl = firstString(body["response_url"]);
+	const callbackData = extractCallbackData(body);
+	const team = body["team"];
+	const teamId = isPlainObject(team) ? firstString(team["id"]) : firstString(body["team_id"]);
+	return {
+		ok: true,
+		event: {
+			channel: "slack",
+			event_id: firstString(body["trigger_id"], responseUrl, messageId) ?? `${type}:${chatId}`,
+			chat_id: chatId,
+			raw_type: type,
+			received_at: receivedAt,
+			...userId && { user_id: userId },
+			...username && { username },
+			...messageId && { message_id: messageId },
+			...responseUrl && { callback_query_id: responseUrl },
+			...callbackData && { callback_data: callbackData },
+			...teamId && { team_id: teamId }
+		}
+	};
+}
+function extractCallbackData(body) {
+	const actions = body["actions"];
+	if (Array.isArray(actions) && actions.length > 0) {
+		const first = actions[0];
+		if (isPlainObject(first)) {
+			const selected = first["selected_option"];
+			const selectedValue = isPlainObject(selected) ? selected["value"] : void 0;
+			return firstString(first["value"], first["action_id"], selectedValue);
+		}
+	}
+	const view = body["view"];
+	if (isPlainObject(view) && isString(view["callback_id"])) return view["callback_id"];
+	return firstString(body["callback_id"]);
+}
+function collectMedia(event) {
+	const out = [];
+	const files = event["files"];
+	if (!Array.isArray(files)) return out;
+	for (const file of files) {
+		if (!isPlainObject(file) || !isString(file["id"])) continue;
+		const mimetype = isString(file["mimetype"]) ? file["mimetype"] : void 0;
+		const kind = mimetype?.startsWith("image/") ? "photo" : "document";
+		out.push({
+			kind,
+			ref: file["id"],
+			...isString(file["name"]) && { file_name: file["name"] },
+			...typeof file["size"] === "number" && { file_size: file["size"] },
+			...mimetype && { media_type: mimetype },
+			...isString(file["file_access"]) && { unique_ref: file["file_access"] }
+		});
+	}
+	return out;
+}
+function isInteractionType(type) {
+	return type === "block_actions" || type === "interactive_message" || type === "shortcut" || type === "message_action" || type === "view_submission" || type === "view_closed" || type === "slash_command";
+}
+function tryParseJson(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+}
+/** Interactive endpoints often post `payload=<urlencoded json>`. */
+function tryParsePayloadForm(raw) {
+	if (!raw.includes("payload=")) return void 0;
+	try {
+		const payload = new URLSearchParams(raw).get("payload");
+		if (!payload) return void 0;
+		return JSON.parse(payload);
+	} catch {
+		return;
+	}
+}
+function firstString(...values) {
+	for (const value of values) if (isString(value) && value.length > 0) return value;
+}
+//#endregion
+export { slackSetAssistantStatusInputSchema as $, slackAuthSchema as A, slackGetBotOutputSchema as B, isSlackOutcomeUnknown as C, slackAppendStreamInputSchema as D, slackAnswerCallbackInputSchema as E, slackConversationMessagesOutputSchema as F, slackPostEphemeralInputSchema as G, slackListConversationsOutputSchema as H, slackConversationRepliesInputSchema as I, slackSendMediaBatchInputSchema as J, slackPublishHomeInputSchema as K, slackDownloadFileInputSchema as L, slackConversationHistoryInputSchema as M, slackConversationInfoInputSchema as N, slackAuthRevokeInputSchema as O, slackConversationInfoOutputSchema as P, slackSendTextInputSchema as Q, slackDownloadFileOutputSchema as R, isSlackDefiniteRejection as S, MAX_SLACK_MEDIA_BATCH as T, slackMessageOutputSchema as U, slackListConversationsInputSchema as V, slackOkOutputSchema as W, slackSendMediaBatchOutputSchema as X, slackSendMediaBatchItemSchema as Y, slackSendMediaInputSchema as Z, slackSendMediaTool as _, formatSlackChannelRef as a, slackUsersConversationsInputSchema as at, SlackClient as b, slackMrkdwnToPlainText as c, slackClearReactionTool as d, slackSetReactionInputSchema as et, slackDownloadFileTool as f, slackSendChatActionTool as g, slackModule as h, extractSlackUserMentions as i, slackStopTypingInputSchema as it, slackClearReactionInputSchema as j, slackAuthRevokeOutputSchema as k, stripLeadingSlackBotMention as l, slackGetBotTool as m, verifySlackRequestSignature as n, slackStartStreamInputSchema as nt, formatSlackMessagePermalink as o, slackUsersInfoInputSchema as ot, slackEditTextTool as p, slackSendChatActionInputSchema as q, extractSlackChannelRefs as r, slackStopStreamInputSchema as rt, formatSlackUserMention as s, slackUsersInfoOutputSchema as st, parseSlackEvent as t, slackSetSuggestedPromptsInputSchema as tt, slackAnswerCallbackTool as u, slackSendTextTool as v, MAX_MEDIA_BYTES as w, SlackClientError as x, slackSetReactionTool as y, slackEditTextInputSchema as z };
+
+//# sourceMappingURL=slack-Di5BBNpt.js.map