@5ss/ai-tools 2.11.1

package/dist/modules/messaging/index.js

@@ -0,0 +1,1067 @@
+import { d as isImessageDefiniteRejection, f as isImessageOutcomeUnknown, h as imessageAuthSchema, m as MAX_MEDIA_BYTES } from "../../client-CCKGsTeI.js";
+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 { n as bytesToBase64, t as base64ToBytes } from "../../bytes-BxpimpQx.js";
+import { m as s3AuthSchema, p as S3Client } from "../../s3-CsOaPWMP.js";
+import { n as runBatchItems, t as batchResultSchema } from "../../batch-Co1ujeAW.js";
+import { n as createTypingPulse, t as createLiveMessage } from "../../transport-B4vn-XiQ.js";
+import { A as slackAuthSchema, C as isSlackOutcomeUnknown, S as isSlackDefiniteRejection, b as SlackClient, w as MAX_MEDIA_BYTES$1 } from "../../slack-Di5BBNpt.js";
+import { _ as isTeamsOutcomeUnknown, b as teamsAuthSchema, g as isTeamsDefiniteRejection, m as TeamsClient, v as MAX_MEDIA_BYTES$2 } from "../../teams-DYAHNb39.js";
+import { _ as isTelegramOutcomeUnknown, b as telegramAuthSchema, g as isTelegramDefiniteRejection, m as TelegramClient, v as MAX_MEDIA_BYTES$3 } from "../../telegram-DDXWzkfL.js";
+import { isError } from "es-toolkit";
+import { z } from "zod";
+//#region src/modules/messaging/contracts.ts
+/**
+* Messaging seam contracts — shared I/O + provider auth union.
+*/
+const MAX_MESSAGING_MEDIA_BATCH = 10;
+const messagingChatActionSchema = 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"
+]);
+/** Optional object storage for ArtifactRef media IO (send source / download destination). */
+const messagingStorageAuth = s3AuthSchema.optional().describe("S3-compatible object storage for ArtifactRef media (source on send, destination_key on download)");
+/** Host auth: channel credentials + provider discriminator. */
+const telegramMessagingAuthSchema = telegramAuthSchema.extend({
+	provider: z.literal("telegram"),
+	storage: messagingStorageAuth
+});
+const slackMessagingAuthSchema = slackAuthSchema.extend({
+	provider: z.literal("slack"),
+	storage: messagingStorageAuth
+});
+const teamsMessagingAuthSchema = teamsAuthSchema.extend({
+	provider: z.literal("teams"),
+	storage: messagingStorageAuth
+});
+const imessageMessagingAuthSchema = imessageAuthSchema.extend({
+	provider: z.literal("imessage"),
+	storage: messagingStorageAuth
+});
+const messagingAuthSchema = z.discriminatedUnion("provider", [
+	telegramMessagingAuthSchema,
+	slackMessagingAuthSchema,
+	teamsMessagingAuthSchema,
+	imessageMessagingAuthSchema
+]);
+const serviceUrlOptional = z.string().min(1).optional().describe("Activity service base URL when the bound channel requires it for this call");
+const messagingSendTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	text: z.string().min(1).describe("Message text"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional message id to reply to (thread/reply)"),
+	reply_markup: z.unknown().optional().describe("Optional channel-native markup (blocks, attachments, …)"),
+	service_url: serviceUrlOptional
+});
+/** Common send/edit/media result shell for journaling. */
+const messagingMessageOutputSchema = z.object({
+	message_id: z.string().describe("Provider message id as string"),
+	file_id: z.string().optional().describe("File id when the send created a downloadable attachment"),
+	attachment_message_ids: z.array(z.string()).optional().describe("Additional attachment message ids when a single call produced more than one message")
+});
+const messagingEditTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	message_id: z.string().min(1).describe("Message id to edit"),
+	text: z.string().min(1).describe("Replacement text"),
+	reply_markup: z.unknown().optional().describe("Optional channel-native markup"),
+	service_url: serviceUrlOptional
+});
+const messagingSendChatActionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	action: messagingChatActionSchema.describe("Chat action (typing, upload_document, …)"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional thread or reply anchor when the channel uses thread-scoped status"),
+	service_url: serviceUrlOptional
+});
+const messagingStopTypingInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional thread or reply anchor when the channel uses thread-scoped status"),
+	service_url: serviceUrlOptional
+});
+const messagingSetReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	message_id: z.string().min(1).describe("Message id to react to"),
+	emoji: z.string().min(1).max(64).describe("Any emoji the bound channel accepts")
+});
+/** Reaction result — store message_id when present for clearReaction. */
+const messagingReactionOutputSchema = z.object({ message_id: z.string().optional().describe("Reaction message id when the channel creates a separate reaction message; pass to clearReaction") });
+const messagingClearReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	message_id: z.string().min(1).describe("Message id to clear; use reaction message_id from setReaction when that was returned"),
+	emoji: z.string().min(1).max(64).optional().describe("Emoji to clear when the channel requires a reaction name")
+});
+/** Messaging only resolves object-store artifacts (not host-mapped keys). */
+const messagingObjectArtifactRefSchema = z.object({
+	store: z.literal("object").describe("Object storage owned by bound messaging storage auth"),
+	key: z.string().min(1).describe("Object key"),
+	media_type: z.string().min(1).optional().describe("MIME or format hint when known"),
+	filename: z.string().min(1).optional().describe("Original or display file name"),
+	byte_length: z.int().min(0).optional().describe("Size in bytes when known")
+});
+const messagingMediaBodyFields = {
+	kind: z.enum(["photo", "document"]).describe("Media kind"),
+	body_base64: z.string().min(1).optional().describe("File body as base64. Omit when source is set. Prefer source for large files."),
+	source: messagingObjectArtifactRefSchema.optional().describe("Object-store ArtifactRef for the media file. Prefer this over body_base64 for large files"),
+	file_name: z.string().min(1).optional().describe("File name including extension. Required with body_base64; defaults to source.filename when source is set"),
+	caption: z.string().optional().describe("Optional caption"),
+	content_type: z.string().optional().describe("Optional content type; defaults to source.media_type when source is set")
+};
+function refineMediaBody(val, ctx) {
+	const hasB64 = val.body_base64 !== void 0;
+	const hasSource = val.source !== void 0;
+	if (hasB64 === hasSource) ctx.addIssue({
+		code: "custom",
+		message: "Provide exactly one of body_base64 or source"
+	});
+	if (hasB64 && !val.file_name) ctx.addIssue({
+		code: "custom",
+		path: ["file_name"],
+		message: "file_name is required when body_base64 is set"
+	});
+	if (hasSource && !val.file_name && !val.source?.filename) ctx.addIssue({
+		code: "custom",
+		path: ["file_name"],
+		message: "file_name or source.filename is required when source is set"
+	});
+}
+const messagingSendMediaInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	...messagingMediaBodyFields,
+	reply_to_message_id: z.string().min(1).optional().describe("Optional reply / thread anchor"),
+	service_url: serviceUrlOptional
+}).superRefine(refineMediaBody);
+const messagingSendMediaBatchItemSchema = z.object({ ...messagingMediaBodyFields }).superRefine(refineMediaBody);
+const messagingSendMediaBatchInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	items: z.array(messagingSendMediaBatchItemSchema).min(1).max(10).describe(`1–10 media items in send order`),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional reply / thread anchor for the batch"),
+	service_url: serviceUrlOptional
+});
+const messagingSendMediaBatchOutputSchema = z.object({
+	message_ids: z.array(z.string()).describe("Successfully sent message ids in order"),
+	results: batchResultSchema(messagingMessageOutputSchema).describe("Per-item outcomes (partial failure allowed)")
+});
+const messagingDownloadFileInputSchema = z.object({
+	file_id: z.string().min(1).describe("Provider file id, content URL, or attachment message id"),
+	chat_id: z.string().min(1).optional().describe("Conversation id when the channel requires it for download"),
+	file_name: z.string().min(1).optional().describe("Preferred file name"),
+	destination_key: z.string().min(1).optional().describe("When set, persist downloaded bytes at this object key and return an ArtifactRef instead of body_base64"),
+	service_url: serviceUrlOptional
+});
+const messagingDownloadFileOutputSchema = z.object({
+	file_name: z.string(),
+	file_size: z.number().optional(),
+	body_base64: z.string().optional().describe("Downloaded file body as base64 when destination_key is omitted"),
+	artifact: messagingObjectArtifactRefSchema.optional().describe("Object-store ArtifactRef when destination_key is set")
+});
+const messagingAnswerCallbackInputSchema = z.object({
+	callback_query_id: z.string().min(1).describe("Callback / response id from an inbound interaction"),
+	text: z.string().max(3e3).optional().describe("Optional notification text"),
+	show_alert: z.boolean().optional().describe("When supported, show an alert instead of a toast"),
+	service_url: serviceUrlOptional
+});
+const messagingReadInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Channel conversation / chat id"),
+	message_id: z.string().min(1).describe("Message id to mark read up to"),
+	service_url: serviceUrlOptional
+});
+const messagingOkOutputSchema = z.object({ ok: z.boolean() });
+//#endregion
+//#region src/modules/messaging/domain.ts
+/**
+* Messaging seam helpers (no HTTP).
+*/
+/**
+* Intentional lifecycle no-op (e.g. read when the channel has no mark-as-read API).
+* Succeeds so multi-channel hosts can call one surface without branching.
+* Destructive gaps (unsend) must not live on the seam — use the vendor pack.
+*/
+function warnUnsupportedMessagingOp(provider, op) {
+	console.warn(`[messaging] ${provider}: ${op} is a successful no-op (not needed / not applicable on this channel)`);
+}
+/** Provider-neutral definite rejection (do not treat as possible delivery). */
+function isMessagingDefiniteRejection(error) {
+	return isTelegramDefiniteRejection(error) || isSlackDefiniteRejection(error) || isTeamsDefiniteRejection(error) || isImessageDefiniteRejection(error);
+}
+/**
+* Provider-neutral outcome-unknown (retry may duplicate).
+* Includes transport network/abort failures rethrown as vendor client errors.
+*/
+function isMessagingOutcomeUnknown(error) {
+	return isTelegramOutcomeUnknown(error) || isSlackOutcomeUnknown(error) || isTeamsOutcomeUnknown(error) || isImessageOutcomeUnknown(error);
+}
+/** Media byte ceiling for the bound channel (align object reads before channel decode). */
+function mediaMaxBytesForProvider(provider) {
+	switch (provider) {
+		case "teams": return MAX_MEDIA_BYTES$2;
+		case "slack": return MAX_MEDIA_BYTES$1;
+		case "telegram": return MAX_MEDIA_BYTES$3;
+		case "imessage": return MAX_MEDIA_BYTES;
+		default: return MAX_MEDIA_BYTES$3;
+	}
+}
+function toBatchError(error) {
+	if (error instanceof ToolError) return {
+		code: error.code,
+		message: error.message,
+		retryable: error.retryable
+	};
+	return {
+		code: "internal",
+		message: isError(error) ? error.message : "Batch item failed"
+	};
+}
+async function bodyFromSource(source, storage, maxBytes) {
+	if (!storage) throw new ToolError("ArtifactRef media requires storage credentials on messaging auth", { code: "bad_auth" });
+	return {
+		body_base64: bytesToBase64(await storage.getBytes(source.key, { maxBytes })),
+		file_name: source.filename,
+		content_type: source.media_type
+	};
+}
+async function resolveMediaBody(input, storage, maxBytes) {
+	if (input.body_base64 !== void 0) {
+		if (!input.file_name) throw new ToolError("file_name is required when body_base64 is set", { code: "bad_input" });
+		const raw = base64ToBytes(input.body_base64);
+		if (raw.byteLength > maxBytes) throw new ToolError("Media body exceeds channel size limit", {
+			code: "too_large",
+			details: {
+				max_bytes: maxBytes,
+				content_length: raw.byteLength
+			}
+		});
+		return {
+			body_base64: input.body_base64,
+			file_name: input.file_name,
+			content_type: input.content_type
+		};
+	}
+	if (!input.source) throw new ToolError("Provide exactly one of body_base64 or source", { code: "bad_input" });
+	const fromStore = await bodyFromSource(input.source, storage, maxBytes);
+	const file_name = input.file_name ?? fromStore.file_name;
+	if (!file_name) throw new ToolError("file_name or source.filename is required when source is set", { code: "bad_input" });
+	return {
+		body_base64: fromStore.body_base64,
+		file_name,
+		content_type: input.content_type ?? fromStore.content_type
+	};
+}
+/** Resolve public send-media input to channel-facing body_base64 payload. */
+async function resolveSendMediaInput(input, storage, maxBytes) {
+	const body = await resolveMediaBody(input, storage, maxBytes);
+	return {
+		chat_id: input.chat_id,
+		kind: input.kind,
+		body_base64: body.body_base64,
+		file_name: body.file_name,
+		content_type: body.content_type,
+		caption: input.caption,
+		reply_to_message_id: input.reply_to_message_id,
+		service_url: input.service_url
+	};
+}
+/**
+* Resolve each batch item independently, send only successes, merge failures by original index.
+* Preserves partial-failure contract when ArtifactRef resolution fails mid-batch.
+*/
+async function resolveAndSendMediaBatch(input, storage, maxBytes, sendBatch) {
+	const slots = [];
+	for (let index = 0; index < input.items.length; index++) {
+		const item = input.items[index];
+		if (!item) continue;
+		try {
+			const body = await resolveMediaBody(item, storage, maxBytes);
+			slots.push({
+				index,
+				ok: true,
+				item: {
+					kind: item.kind,
+					body_base64: body.body_base64,
+					file_name: body.file_name,
+					content_type: body.content_type,
+					caption: item.caption
+				}
+			});
+		} catch (error) {
+			slots.push({
+				index,
+				ok: false,
+				error: toBatchError(error)
+			});
+		}
+	}
+	const successes = slots.filter((s) => s.ok);
+	const results = [];
+	const message_ids = [];
+	if (successes.length === 0) {
+		for (const slot of slots) if (!slot.ok) results.push({
+			index: slot.index,
+			ok: false,
+			error: slot.error
+		});
+		return {
+			message_ids,
+			results: {
+				results,
+				succeeded: 0,
+				failed: results.length
+			}
+		};
+	}
+	const providerOut = await sendBatch({
+		chat_id: input.chat_id,
+		items: successes.map((s) => s.item),
+		reply_to_message_id: input.reply_to_message_id,
+		service_url: input.service_url
+	});
+	const providerByLocal = new Map(providerOut.results.results.map((row) => [row.index, row]));
+	let successCursor = 0;
+	for (const slot of slots) {
+		if (!slot.ok) {
+			results.push({
+				index: slot.index,
+				ok: false,
+				error: slot.error
+			});
+			continue;
+		}
+		const pr = providerByLocal.get(successCursor);
+		successCursor += 1;
+		if (!pr) {
+			results.push({
+				index: slot.index,
+				ok: false,
+				error: {
+					code: "internal",
+					message: "Missing provider batch result"
+				}
+			});
+			continue;
+		}
+		if (pr.ok && pr.value) {
+			results.push({
+				index: slot.index,
+				ok: true,
+				value: pr.value
+			});
+			if (pr.value.message_id) message_ids.push(pr.value.message_id);
+		} else results.push({
+			index: slot.index,
+			ok: false,
+			error: pr.error ?? {
+				code: "internal",
+				message: "Provider batch item failed"
+			}
+		});
+	}
+	const succeeded = results.filter((r) => r.ok).length;
+	return {
+		message_ids,
+		results: {
+			results,
+			succeeded,
+			failed: results.length - succeeded
+		}
+	};
+}
+/** After channel download, optionally land bytes in object storage. */
+async function finalizeDownloadOutput(got, destination_key, storage) {
+	if (!destination_key) return {
+		file_name: got.file_name,
+		file_size: got.file_size,
+		body_base64: got.body_base64
+	};
+	if (!storage) throw new ToolError("destination_key requires storage credentials on messaging auth", { code: "bad_auth" });
+	const bytes = base64ToBytes(got.body_base64);
+	await storage.putBytes(destination_key, bytes);
+	const file_size = got.file_size ?? bytes.byteLength;
+	return {
+		file_name: got.file_name,
+		file_size,
+		artifact: {
+			store: "object",
+			key: destination_key,
+			filename: got.file_name,
+			byte_length: file_size
+		}
+	};
+}
+/** Sequential sendMedia for channels without a native multi-file API. */
+async function sendMediaBatchSequential(sendOne, input) {
+	const batch = await runBatchItems(input.items, (item) => sendOne({
+		chat_id: input.chat_id,
+		kind: item.kind,
+		body_base64: item.body_base64,
+		file_name: item.file_name,
+		caption: item.caption,
+		content_type: item.content_type,
+		reply_to_message_id: input.reply_to_message_id,
+		service_url: input.service_url
+	}), { concurrency: 1 });
+	const message_ids = [];
+	for (const row of batch.results) if (row.ok && row.value?.message_id) message_ids.push(row.value.message_id);
+	return {
+		message_ids,
+		results: batch
+	};
+}
+//#endregion
+//#region src/modules/messaging/providers/imessage.ts
+/**
+* iMessage provider for the messaging seam.
+* Wraps `ImessageClient` (Photon Spectrum Cloud + Advanced iMessage gRPC).
+*
+* Vendor client is loaded via dynamic import so edge/browser packaging of the
+* messaging seam does not pull Node-only gRPC peers until iMessage is used.
+*/
+var ImessageMessagingProvider = class {
+	#auth;
+	#options;
+	#client;
+	#ready;
+	constructor(auth, options = {}) {
+		this.#auth = auth;
+		this.#options = options;
+	}
+	async #sdk() {
+		if (this.#client) return this.#client;
+		this.#ready ??= (async () => {
+			const { ImessageClient } = await import("../../client-CCKGsTeI.js").then((n) => n.n);
+			const { provider: _p, storage: _s, ...vendorAuth } = this.#auth;
+			const client = new ImessageClient(vendorAuth, this.#options);
+			this.#client = client;
+			return client;
+		})();
+		return this.#ready;
+	}
+	async sendText(input) {
+		return { message_id: (await (await this.#sdk()).sendText({
+			chat_id: input.chat_id,
+			text: input.text
+		})).message_id };
+	}
+	async editText(input) {
+		return { message_id: (await (await this.#sdk()).editText({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			text: input.text
+		})).message_id ?? input.message_id };
+	}
+	async sendChatAction(input) {
+		await (await this.#sdk()).sendChatAction({
+			chat_id: input.chat_id,
+			action: input.action
+		});
+	}
+	async stopTyping(input) {
+		await (await this.#sdk()).stopTyping({ chat_id: input.chat_id });
+	}
+	async setReaction(input) {
+		return { message_id: (await (await this.#sdk()).setReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			emoji: input.emoji
+		})).message_id };
+	}
+	/**
+	* Clears via setReaction(isSet=false). Requires emoji matching setReaction.
+	* `message_id` is the **target** message guid.
+	*/
+	async clearReaction(input) {
+		if (!input.emoji) throw new ToolError("iMessage clearReaction requires emoji (same tapback/emoji used when setting)", { code: "bad_input" });
+		await (await this.#sdk()).clearReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			emoji: input.emoji
+		});
+	}
+	async sendMedia(input) {
+		return { message_id: (await (await this.#sdk()).sendMedia({
+			chat_id: input.chat_id,
+			kind: input.kind,
+			body_base64: input.body_base64,
+			file_name: input.file_name,
+			...input.caption && { caption: input.caption },
+			...input.content_type && { content_type: input.content_type }
+		})).message_id };
+	}
+	sendMediaBatch(input) {
+		return sendMediaBatchSequential((item) => this.sendMedia(item), input);
+	}
+	async downloadFile(input) {
+		const fileId = input.chat_id ? input.file_id : splitImessageFileRef(input.file_id).file_id ?? input.file_id;
+		return (await this.#sdk()).downloadFile({
+			file_id: fileId,
+			...input.chat_id && { chat_id: input.chat_id },
+			...input.file_name && { file_name: input.file_name }
+		});
+	}
+	async answerCallback(_input) {
+		await (await this.#sdk()).answerCallback({});
+	}
+	async read(input) {
+		await (await this.#sdk()).read({
+			chat_id: input.chat_id,
+			...input.message_id && { message_id: input.message_id }
+		});
+	}
+};
+/** Legacy composite: `space_id::message_id` when chat_id is omitted (message_id is attachment guid). */
+function splitImessageFileRef(fileId) {
+	const idx = fileId.indexOf("::");
+	if (idx <= 0) return { file_id: fileId };
+	const chat_id = fileId.slice(0, idx);
+	const rest = fileId.slice(idx + 2);
+	if (chat_id.length === 0 || rest.length === 0) return { file_id: fileId };
+	return {
+		chat_id,
+		file_id: rest
+	};
+}
+//#endregion
+//#region src/modules/messaging/providers/slack.ts
+/**
+* Slack provider for the messaging seam. Wraps `SlackClient`.
+*/
+var SlackMessagingProvider = class {
+	#client;
+	constructor(auth, options = {}) {
+		const { provider: _p, storage: _s, ...vendorAuth } = auth;
+		this.#client = new SlackClient(vendorAuth, options);
+	}
+	sendText(input) {
+		return this.#client.sendText({
+			chat_id: input.chat_id,
+			text: input.text,
+			...input.reply_to_message_id && { reply_to_message_id: input.reply_to_message_id },
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		});
+	}
+	editText(input) {
+		return this.#client.editText({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			text: input.text,
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		});
+	}
+	sendChatAction(input) {
+		const body = {
+			chat_id: input.chat_id,
+			action: input.action
+		};
+		if (input.reply_to_message_id) body.reply_to_message_id = input.reply_to_message_id;
+		return this.#client.sendChatAction(body);
+	}
+	/** Clear assistant.threads.setStatus when reply_to_message_id (thread_ts) is set. */
+	stopTyping(input) {
+		const body = { chat_id: input.chat_id };
+		if (input.reply_to_message_id) body.reply_to_message_id = input.reply_to_message_id;
+		return this.#client.stopTyping(body);
+	}
+	async setReaction(input) {
+		await this.#client.setReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			emoji: input.emoji
+		});
+		return {};
+	}
+	clearReaction(input) {
+		if (!input.emoji) throw new ToolError("Slack clear reaction requires emoji", { code: "bad_input" });
+		return this.#client.clearReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			emoji: input.emoji
+		});
+	}
+	async sendMedia(input) {
+		const out = await this.#client.sendMedia({
+			chat_id: input.chat_id,
+			kind: input.kind,
+			body_base64: input.body_base64,
+			file_name: input.file_name,
+			...input.caption && { caption: input.caption },
+			...input.reply_to_message_id && { reply_to_message_id: input.reply_to_message_id },
+			...input.content_type && { content_type: input.content_type }
+		});
+		return {
+			message_id: out.message_id,
+			...out.file_id && { file_id: out.file_id }
+		};
+	}
+	sendMediaBatch(input) {
+		return sendMediaBatchSequential((item) => this.sendMedia(item), input);
+	}
+	downloadFile(input) {
+		return this.#client.downloadFile({
+			file_id: input.file_id,
+			...input.file_name && { file_name: input.file_name }
+		});
+	}
+	answerCallback(input) {
+		return this.#client.answerCallback({
+			callback_query_id: input.callback_query_id,
+			...input.text && { text: input.text },
+			...input.show_alert !== void 0 && { show_alert: input.show_alert }
+		});
+	}
+	async read(_input) {
+		warnUnsupportedMessagingOp("slack", "read");
+	}
+};
+//#endregion
+//#region src/modules/messaging/providers/teams.ts
+/**
+* Teams provider for the messaging seam. Wraps `TeamsClient`.
+*/
+function requireServiceUrl(serviceUrl, method) {
+	if (!serviceUrl) throw new ToolError(`${method} requires service_url when provider is teams`, { code: "bad_input" });
+	return serviceUrl;
+}
+var TeamsMessagingProvider = class {
+	#client;
+	constructor(auth, options = {}) {
+		const { provider: _p, storage: _s, ...vendorAuth } = auth;
+		this.#client = new TeamsClient(vendorAuth, options);
+	}
+	sendText(input) {
+		const service_url = requireServiceUrl(input.service_url, "messaging sendText");
+		return this.#client.sendText({
+			chat_id: input.chat_id,
+			text: input.text,
+			service_url,
+			...input.reply_to_message_id && { reply_to_message_id: input.reply_to_message_id },
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		});
+	}
+	editText(input) {
+		const service_url = requireServiceUrl(input.service_url, "messaging editText");
+		return this.#client.editText({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			text: input.text,
+			service_url,
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		});
+	}
+	sendChatAction(input) {
+		const service_url = requireServiceUrl(input.service_url, "messaging sendChatAction");
+		return this.#client.sendChatAction({
+			chat_id: input.chat_id,
+			action: input.action,
+			service_url
+		});
+	}
+	/** Teams typing is one-shot; stop is a successful no-op. */
+	async stopTyping(_input) {}
+	/**
+	* Graph reactions when Teams auth has tenant_id; otherwise client no-op.
+	*/
+	async setReaction(input) {
+		await this.#client.setReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			emoji: input.emoji
+		});
+		return {};
+	}
+	/**
+	* Graph unsetReaction when tenant_id bound; requires emoji for Graph.
+	* Without tenant_id, client no-ops.
+	*/
+	clearReaction(input) {
+		return this.#client.clearReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			...input.emoji && { emoji: input.emoji }
+		});
+	}
+	sendMedia(input) {
+		const service_url = requireServiceUrl(input.service_url, "messaging sendMedia");
+		return this.#client.sendMedia({
+			chat_id: input.chat_id,
+			kind: input.kind,
+			body_base64: input.body_base64,
+			file_name: input.file_name,
+			service_url,
+			...input.caption && { caption: input.caption },
+			...input.reply_to_message_id && { reply_to_message_id: input.reply_to_message_id },
+			...input.content_type && { content_type: input.content_type }
+		});
+	}
+	sendMediaBatch(input) {
+		return sendMediaBatchSequential((item) => this.sendMedia(item), input);
+	}
+	downloadFile(input) {
+		return this.#client.downloadFile({
+			file_id: input.file_id,
+			...input.file_name && { file_name: input.file_name },
+			...input.service_url && { service_url: input.service_url }
+		});
+	}
+	answerCallback(input) {
+		return this.#client.answerCallback({
+			callback_query_id: input.callback_query_id,
+			...input.text && { text: input.text },
+			...input.show_alert !== void 0 && { show_alert: input.show_alert },
+			...input.service_url && { service_url: input.service_url }
+		});
+	}
+	async read(_input) {
+		warnUnsupportedMessagingOp("teams", "read");
+	}
+};
+//#endregion
+//#region src/modules/messaging/providers/telegram.ts
+var TelegramMessagingProvider = class {
+	#client;
+	constructor(auth, options = {}) {
+		const { provider: _p, storage: _s, ...vendorAuth } = auth;
+		this.#client = new TelegramClient(vendorAuth, options);
+	}
+	async sendText(input) {
+		const out = await this.#client.sendText({
+			chat_id: input.chat_id,
+			text: input.text,
+			...input.reply_to_message_id && { reply_to_message_id: input.reply_to_message_id },
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		});
+		return {
+			message_id: out.message_id,
+			...out.file_id && { file_id: out.file_id }
+		};
+	}
+	async editText(input) {
+		return { message_id: (await this.#client.editText({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			text: input.text,
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		})).message_id };
+	}
+	sendChatAction(input) {
+		return this.#client.sendChatAction({
+			chat_id: input.chat_id,
+			action: input.action
+		});
+	}
+	/** Telegram typing auto-expires; stop is a successful no-op. */
+	async stopTyping(_input) {}
+	async setReaction(input) {
+		await this.#client.setReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			emoji: input.emoji
+		});
+		return {};
+	}
+	clearReaction(input) {
+		return this.#client.clearReaction({
+			chat_id: input.chat_id,
+			message_id: input.message_id
+		});
+	}
+	async sendMedia(input) {
+		const out = await this.#client.sendMedia({
+			chat_id: input.chat_id,
+			kind: input.kind,
+			body_base64: input.body_base64,
+			file_name: input.file_name,
+			...input.caption && { caption: input.caption },
+			...input.reply_to_message_id && { reply_to_message_id: input.reply_to_message_id },
+			...input.content_type && { content_type: input.content_type }
+		});
+		return {
+			message_id: out.message_id,
+			...out.file_id && { file_id: out.file_id }
+		};
+	}
+	async sendMediaBatch(input) {
+		const homogeneous = new Set(input.items.map((i) => i.kind)).size === 1;
+		const kind = input.items[0]?.kind;
+		if (homogeneous && kind && input.items.length >= 2 && input.items.length <= 10) {
+			const group = await this.#client.sendMediaGroup({
+				chat_id: input.chat_id,
+				items: input.items.map((item) => ({
+					kind: item.kind,
+					body_base64: item.body_base64,
+					file_name: item.file_name,
+					...item.caption && { caption: item.caption },
+					...item.content_type && { content_type: item.content_type }
+				})),
+				...input.reply_to_message_id && { reply_to_message_id: input.reply_to_message_id }
+			});
+			return {
+				message_ids: group.message_ids,
+				results: {
+					results: group.message_ids.map((message_id, index) => ({
+						index,
+						ok: true,
+						value: { message_id }
+					})),
+					succeeded: group.message_ids.length,
+					failed: 0
+				}
+			};
+		}
+		return sendMediaBatchSequential((item) => this.sendMedia(item), input);
+	}
+	downloadFile(input) {
+		return this.#client.downloadFile({
+			file_id: input.file_id,
+			...input.file_name && { file_name: input.file_name }
+		});
+	}
+	answerCallback(input) {
+		return this.#client.answerCallback({
+			callback_query_id: input.callback_query_id,
+			...input.text && { text: input.text },
+			...input.show_alert !== void 0 && { show_alert: input.show_alert }
+		});
+	}
+	async read(_input) {
+		warnUnsupportedMessagingOp("telegram", "read");
+	}
+};
+//#endregion
+//#region src/modules/messaging/client.ts
+/**
+* Messaging seam client — picks telegram / slack / teams / imessage from host auth.
+* Resolves ArtifactRef media via optional nested S3 storage before channel calls.
+*/
+function transportOptions(ctx) {
+	return {
+		...ctx.fetch && { fetch: ctx.fetch },
+		...ctx.signal && { signal: ctx.signal }
+	};
+}
+function providerFor(auth, ctx) {
+	const options = transportOptions(ctx);
+	switch (auth.provider) {
+		case "telegram": return new TelegramMessagingProvider(auth, options);
+		case "slack": return new SlackMessagingProvider(auth, options);
+		case "teams": return new TeamsMessagingProvider(auth, options);
+		case "imessage": return new ImessageMessagingProvider(auth, options);
+	}
+}
+function storageFor(auth, ctx) {
+	if (!auth.storage) return void 0;
+	return new S3Client(auth.storage, transportOptions(ctx));
+}
+var MessagingClient = class MessagingClient {
+	#ops;
+	#storage;
+	#maxMediaBytes;
+	constructor(ops, storage, maxMediaBytes) {
+		this.#ops = ops;
+		this.#storage = storage;
+		this.#maxMediaBytes = maxMediaBytes;
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, messagingAuthSchema);
+		return new MessagingClient(providerFor(auth, ctx), storageFor(auth, ctx), mediaMaxBytesForProvider(auth.provider));
+	}
+	static fromAuth(auth, ctx = {}) {
+		return new MessagingClient(providerFor(auth, ctx), storageFor(auth, ctx), mediaMaxBytesForProvider(auth.provider));
+	}
+	sendText(input) {
+		return this.#ops.sendText(input);
+	}
+	editText(input) {
+		return this.#ops.editText(input);
+	}
+	sendChatAction(input) {
+		return this.#ops.sendChatAction(input);
+	}
+	stopTyping(input) {
+		return this.#ops.stopTyping(input);
+	}
+	setReaction(input) {
+		return this.#ops.setReaction(input);
+	}
+	clearReaction(input) {
+		return this.#ops.clearReaction(input);
+	}
+	async sendMedia(input) {
+		const resolved = await resolveSendMediaInput(input, this.#storage, this.#maxMediaBytes);
+		return this.#ops.sendMedia(resolved);
+	}
+	async sendMediaBatch(input) {
+		return resolveAndSendMediaBatch(input, this.#storage, this.#maxMediaBytes, (resolved) => this.#ops.sendMediaBatch(resolved));
+	}
+	async downloadFile(input) {
+		return finalizeDownloadOutput(await this.#ops.downloadFile(input), input.destination_key, this.#storage);
+	}
+	answerCallback(input) {
+		return this.#ops.answerCallback(input);
+	}
+	read(input) {
+		return this.#ops.read(input);
+	}
+};
+//#endregion
+//#region src/modules/messaging/module.ts
+const messagingSendTextTool = defineTool({
+	id: "messaging-send-text",
+	name: "messagingSendText",
+	description: "Send a text message on the bound messaging channel. Optional reply_to_message_id anchors a reply or thread. Returns message_id.",
+	inputSchema: messagingSendTextInputSchema,
+	outputSchema: messagingMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => MessagingClient.fromContext(ctx).sendText(input)
+});
+const messagingEditTextTool = defineTool({
+	id: "messaging-edit-text",
+	name: "messagingEditText",
+	description: "Edit the text of an existing message on the bound messaging channel.",
+	inputSchema: messagingEditTextInputSchema,
+	outputSchema: messagingMessageOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => MessagingClient.fromContext(ctx).editText(input)
+});
+const messagingSendChatActionTool = defineTool({
+	id: "messaging-send-chat-action",
+	name: "messagingSendChatAction",
+	description: "Show a chat action on the conversation when supported (typing, upload_photo, upload_document, …). Optional reply_to_message_id anchors a thread when the channel uses thread-scoped status.",
+	inputSchema: messagingSendChatActionInputSchema,
+	outputSchema: messagingOkOutputSchema,
+	sideEffect: "none",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await MessagingClient.fromContext(ctx).sendChatAction(input);
+		return { ok: true };
+	}
+});
+const messagingStopTypingTool = defineTool({
+	id: "messaging-stop-typing",
+	name: "messagingStopTyping",
+	description: "Stop a typing or busy indicator on the conversation when supported. Optional reply_to_message_id clears thread-scoped status when the channel uses it.",
+	inputSchema: messagingStopTypingInputSchema,
+	outputSchema: messagingOkOutputSchema,
+	sideEffect: "none",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await MessagingClient.fromContext(ctx).stopTyping(input);
+		return { ok: true };
+	}
+});
+const messagingSetReactionTool = defineTool({
+	id: "messaging-set-reaction",
+	name: "messagingSetReaction",
+	description: "Set an emoji reaction on a message when supported. Returns optional message_id when the channel creates a separate reaction message — store it for clearReaction.",
+	inputSchema: messagingSetReactionInputSchema,
+	outputSchema: messagingReactionOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => MessagingClient.fromContext(ctx).setReaction(input)
+});
+const messagingClearReactionTool = defineTool({
+	id: "messaging-clear-reaction",
+	name: "messagingClearReaction",
+	description: "Clear a reaction on a message when supported. Pass emoji when required. When setReaction returned a message_id, pass that id instead of the target message id.",
+	inputSchema: messagingClearReactionInputSchema,
+	outputSchema: messagingOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await MessagingClient.fromContext(ctx).clearReaction(input);
+		return { ok: true };
+	}
+});
+const messagingSendMediaTool = defineTool({
+	id: "messaging-send-media",
+	name: "messagingSendMedia",
+	description: "Send one photo or document on the bound messaging channel. Provide body_base64 for small payloads or source ArtifactRef (object store) for large files.",
+	inputSchema: messagingSendMediaInputSchema,
+	outputSchema: messagingMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => MessagingClient.fromContext(ctx).sendMedia(input)
+});
+const messagingSendMediaBatchTool = defineTool({
+	id: "messaging-send-media-batch",
+	name: "messagingSendMediaBatch",
+	description: "Send 1–10 media items in order (body_base64 or source ArtifactRef per item). May use a native album when all items share the same kind (2–10); otherwise sequential. Partial failures are reported per item.",
+	inputSchema: messagingSendMediaBatchInputSchema,
+	outputSchema: messagingSendMediaBatchOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => MessagingClient.fromContext(ctx).sendMediaBatch(input)
+});
+const messagingDownloadFileTool = defineTool({
+	id: "messaging-download-file",
+	name: "messagingDownloadFile",
+	description: "Download a file by file_id (and optional chat_id / file_name). Returns body_base64 by default, or an ArtifactRef when destination_key is set (writes to bound object storage).",
+	inputSchema: messagingDownloadFileInputSchema,
+	outputSchema: messagingDownloadFileOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => MessagingClient.fromContext(ctx).downloadFile(input)
+});
+const messagingAnswerCallbackTool = defineTool({
+	id: "messaging-answer-callback",
+	name: "messagingAnswerCallback",
+	description: "Acknowledge an inbound interactive callback when supported (toast, alert, or response URL).",
+	inputSchema: messagingAnswerCallbackInputSchema,
+	outputSchema: messagingOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await MessagingClient.fromContext(ctx).answerCallback(input);
+		return { ok: true };
+	}
+});
+const messagingReadTool = defineTool({
+	id: "messaging-read",
+	name: "messagingRead",
+	description: "Mark conversation messages as read up to message_id when supported.",
+	inputSchema: messagingReadInputSchema,
+	outputSchema: messagingOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await MessagingClient.fromContext(ctx).read(input);
+		return { ok: true };
+	}
+});
+const messagingModule = defineModule({
+	id: "messaging",
+	title: "Messaging",
+	description: "Send and edit text, media (single and batch), chat actions, reactions, file download, callback answers, and read on the bound messaging channel.",
+	runtime: "both",
+	auth: {
+		type: "custom",
+		schema: messagingAuthSchema
+	},
+	categories: ["messaging", "chat"],
+	classification: "pii",
+	tags: ["multi-provider"],
+	tools: [
+		messagingSendTextTool,
+		messagingEditTextTool,
+		messagingSendChatActionTool,
+		messagingStopTypingTool,
+		messagingSetReactionTool,
+		messagingClearReactionTool,
+		messagingSendMediaTool,
+		messagingSendMediaBatchTool,
+		messagingDownloadFileTool,
+		messagingAnswerCallbackTool,
+		messagingReadTool
+	]
+});
+//#endregion
+export { MAX_MESSAGING_MEDIA_BATCH, MessagingClient, createLiveMessage, createTypingPulse, isMessagingDefiniteRejection, isMessagingOutcomeUnknown, messagingAnswerCallbackInputSchema, messagingAnswerCallbackTool, messagingAuthSchema, messagingChatActionSchema, messagingClearReactionInputSchema, messagingClearReactionTool, messagingDownloadFileInputSchema, messagingDownloadFileOutputSchema, messagingDownloadFileTool, messagingEditTextInputSchema, messagingEditTextTool, messagingMessageOutputSchema, messagingModule, messagingOkOutputSchema, messagingReactionOutputSchema, messagingReadInputSchema, messagingReadTool, messagingSendChatActionInputSchema, messagingSendChatActionTool, messagingSendMediaBatchInputSchema, messagingSendMediaBatchItemSchema, messagingSendMediaBatchOutputSchema, messagingSendMediaBatchTool, messagingSendMediaInputSchema, messagingSendMediaTool, messagingSendTextInputSchema, messagingSendTextTool, messagingSetReactionInputSchema, messagingSetReactionTool, messagingStopTypingInputSchema, messagingStopTypingTool };
+
+//# sourceMappingURL=index.js.map