@5ss/ai-tools 2.11.1

package/dist/teams-DYAHNb39.js

@@ -0,0 +1,835 @@
+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 { n as bytesToBase64, t as base64ToBytes } from "./bytes-BxpimpQx.js";
+import { isPlainObject, isString, trimEnd } from "es-toolkit";
+import { z } from "zod";
+//#region src/vendors/teams/contracts.ts
+/** Practical upper bound for data-URI attachments (small files only). */
+const MAX_MEDIA_BYTES = 4 * 1024 * 1024;
+const teamsChatActionSchema = 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 teamsAuthSchema = z.object({
+	app_id: z.string().min(1).describe("Microsoft Bot Framework application (client) id"),
+	app_password: z.string().min(1).describe("Microsoft Bot Framework application credential"),
+	tenant_id: z.string().min(1).optional().describe("Azure AD tenant id; omit for multi-tenant botframework.com token endpoint")
+});
+const serviceUrlField = z.string().min(1).describe("Bot Framework service URL for this conversation (from inbound activity.serviceUrl)");
+const teamsSendTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Teams conversation id"),
+	text: z.string().min(1).max(28e3).describe("Message text"),
+	reply_to_message_id: z.string().min(1).optional().describe("Optional activity id to reply to"),
+	service_url: serviceUrlField,
+	reply_markup: z.unknown().optional().describe("Optional Bot Framework attachments array or channel-native markup")
+});
+const teamsMessageOutputSchema = z.object({ message_id: z.string().describe("Bot Framework activity id as string") });
+const teamsEditTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Teams conversation id"),
+	message_id: z.string().min(1).describe("Activity id to edit"),
+	text: z.string().min(1).max(28e3).describe("Replacement text"),
+	service_url: serviceUrlField,
+	reply_markup: z.unknown().optional().describe("Optional Bot Framework attachments array or channel-native markup")
+});
+const teamsSendChatActionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Teams conversation id"),
+	action: teamsChatActionSchema.describe("Chat action; Teams maps all values to a typing activity"),
+	service_url: serviceUrlField
+});
+const teamsSetReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Teams chat or conversation id (Graph chat id when using Graph reactions)"),
+	message_id: z.string().min(1).describe("Message / activity id"),
+	emoji: z.string().min(1).max(32).describe("Emoji or short name (like, heart, …); Graph setReaction when tenant_id is bound"),
+	team_id: z.string().min(1).optional().describe("Team id for channel-message Graph path"),
+	channel_id: z.string().min(1).optional().describe("Channel id for channel-message Graph path")
+});
+const teamsClearReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Teams chat or conversation id"),
+	message_id: z.string().min(1).describe("Message / activity id"),
+	emoji: z.string().min(1).max(32).optional().describe("Same emoji/short name as setReaction; required for Graph unsetReaction"),
+	team_id: z.string().min(1).optional().describe("Team id for channel-message Graph path"),
+	channel_id: z.string().min(1).optional().describe("Channel id for channel-message Graph path")
+});
+const teamsSendMediaInputSchema = z.object({
+	chat_id: z.string().min(1).describe("Teams 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(4e3).optional().describe("Optional caption text"),
+	content_type: z.string().optional().describe("Optional content type for the attachment"),
+	service_url: serviceUrlField,
+	reply_to_message_id: z.string().min(1).optional().describe("Optional activity id to reply to")
+});
+const teamsDownloadFileInputSchema = z.object({
+	file_id: z.string().min(1).describe("Content URL of the file to download"),
+	file_name: z.string().min(1).optional().describe("Preferred file name for the download result"),
+	service_url: z.string().min(1).optional().describe("Optional service URL (unused when file_id is an absolute content URL)")
+});
+const teamsDownloadFileOutputSchema = z.object({
+	file_name: z.string(),
+	file_size: z.number().optional(),
+	body_base64: z.string().describe("Downloaded file body as base64")
+});
+const teamsAnswerCallbackInputSchema = z.object({
+	callback_query_id: z.string().min(1).describe("Invoke reply path (absolute URL) or invoke activity id; non-URL values no-op"),
+	text: z.string().max(200).optional().describe("Optional notification text"),
+	show_alert: z.boolean().optional().describe("When true, prefer an alert-style presentation when supported"),
+	service_url: z.string().min(1).optional().describe("Optional service URL when replying via connector path")
+});
+const teamsGetBotOutputSchema = z.object({
+	bot_id: z.string(),
+	username: z.string(),
+	display_name: z.string()
+});
+const teamsOkOutputSchema = z.object({ ok: z.boolean() });
+//#endregion
+//#region src/vendors/teams/domain.ts
+/**
+* Microsoft Teams / Bot Framework payload shaping + parse.
+* No HTTP — client owns transport.
+*
+* Reactions: Microsoft Graph setReaction / unsetReaction when host binds tenant_id
+* (app-only Graph token). Without tenant_id the client keeps successful no-ops so
+* seam presentation paths do not hard-fail.
+*/
+var TeamsClientError = 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
+			}
+		});
+		this.name = "TeamsClientError";
+		this.failureKind = input.failureKind;
+	}
+};
+function isTeamsDefiniteRejection(error) {
+	return error instanceof TeamsClientError && error.failureKind === "definite_rejection";
+}
+function isTeamsOutcomeUnknown(error) {
+	return error instanceof TeamsClientError && error.failureKind === "outcome_unknown";
+}
+/** Network / abort / transport failures (and non-classified ToolError) before a parseable response. */
+function throwTeamsTransportError(method, error) {
+	if (error instanceof TeamsClientError) throw error;
+	if (error instanceof ToolError) {
+		const status = error.details?.["status"];
+		if (typeof status === "number" && isDefiniteStatus(status)) throw new TeamsClientError({
+			message: error.message,
+			failureKind: "definite_rejection",
+			method,
+			status,
+			cause: error
+		});
+	}
+	throw new TeamsClientError({
+		message: error instanceof Error ? error.message : `${method} request failed`,
+		failureKind: "outcome_unknown",
+		method,
+		cause: error
+	});
+}
+function isDefiniteStatus(status) {
+	return status === 400 || status === 401 || status === 403 || status === 404;
+}
+function botframeworkTokenUrl(tenantId) {
+	const tenant = tenantId && tenantId.length > 0 ? tenantId : "botframework.com";
+	return `https://login.microsoftonline.com/${encodeURIComponent(tenant)}/oauth2/v2.0/token`;
+}
+function botframeworkTokenBody(auth) {
+	return new URLSearchParams({
+		grant_type: "client_credentials",
+		client_id: auth.app_id,
+		client_secret: auth.app_password,
+		scope: "https://api.botframework.com/.default"
+	}).toString();
+}
+/** App-only Graph token (same client credentials; requires a real Azure AD tenant_id). */
+function graphTokenBody(auth) {
+	return new URLSearchParams({
+		grant_type: "client_credentials",
+		client_id: auth.app_id,
+		client_secret: auth.app_password,
+		scope: "https://graph.microsoft.com/.default"
+	}).toString();
+}
+/**
+* Graph reaction URL.
+* Channel path when team_id + channel_id are set; otherwise chat path using chat_id.
+*/
+function graphReactionUrl(input) {
+	const messageId = encodeURIComponent(input.message_id);
+	if (input.team_id && input.channel_id) return `https://graph.microsoft.com/v1.0/teams/${encodeURIComponent(input.team_id)}/channels/${encodeURIComponent(input.channel_id)}/messages/${messageId}/${input.op}`;
+	return `https://graph.microsoft.com/v1.0/chats/${encodeURIComponent(input.chat_id)}/messages/${messageId}/${input.op}`;
+}
+/** Map free-form emoji / short name to a Graph reactionType string (unicode preferred). */
+function toGraphReactionType(emoji) {
+	const trimmed = emoji.trim();
+	switch (trimmed.toLowerCase().replace(/^:|:$/g, "")) {
+		case "like":
+		case "thumbsup":
+		case "+1": return "👍";
+		case "heart":
+		case "love": return "❤️";
+		case "laugh":
+		case "joy": return "😂";
+		case "surprised":
+		case "open_mouth": return "😲";
+		case "sad":
+		case "cry": return "😢";
+		case "angry": return "😠";
+		default: return trimmed;
+	}
+}
+function parseAccessToken(data) {
+	if (!isPlainObject(data) || !isString(data["access_token"]) || data["access_token"].length === 0) throw new ToolError("Teams token endpoint did not return an access_token", { code: "bad_auth" });
+	const expiresIn = typeof data["expires_in"] === "number" && Number.isFinite(data["expires_in"]) && data["expires_in"] > 0 ? data["expires_in"] : 3600;
+	return {
+		access_token: data["access_token"],
+		expires_in: expiresIn
+	};
+}
+/** Absolute connector path under a conversation service URL. */
+function connectorPath(serviceUrl, path) {
+	return `${trimEnd(serviceUrl, "/")}${path.startsWith("/") ? path : `/${path}`}`;
+}
+function conversationActivitiesPath(serviceUrl, chatId) {
+	return connectorPath(serviceUrl, `/v3/conversations/${encodeURIComponent(chatId)}/activities`);
+}
+function conversationActivityPath(serviceUrl, chatId, messageId) {
+	return connectorPath(serviceUrl, `/v3/conversations/${encodeURIComponent(chatId)}/activities/${encodeURIComponent(messageId)}`);
+}
+/** Map non-2xx connector responses into TeamsClientError. */
+function throwForStatus(label, status, data) {
+	let message = `${label} failed with HTTP ${status}`;
+	if (isPlainObject(data)) {
+		const error = data["error"];
+		if (isPlainObject(error) && isString(error["message"]) && error["message"].length > 0) message = error["message"];
+		else if (isString(data["message"]) && data["message"].length > 0) message = data["message"];
+	}
+	throw new TeamsClientError({
+		message,
+		failureKind: isDefiniteStatus(status) ? "definite_rejection" : "outcome_unknown",
+		method: label,
+		status
+	});
+}
+function parseActivityId(value) {
+	if (isPlainObject(value) && isString(value["id"]) && value["id"].length > 0) return { message_id: value["id"] };
+	if (isString(value) && value.length > 0) return { message_id: value };
+	throw new ToolError("Teams connector returned an invalid activity id", { code: "upstream" });
+}
+function attachmentsFromReplyMarkup(replyMarkup) {
+	if (Array.isArray(replyMarkup)) return replyMarkup;
+}
+function buildMessageActivity(input) {
+	const fromMarkup = attachmentsFromReplyMarkup(input.reply_markup);
+	const attachments = input.attachments ?? fromMarkup;
+	return {
+		type: "message",
+		...input.text && { text: input.text },
+		...input.reply_to_message_id && { replyToId: input.reply_to_message_id },
+		...attachments && attachments.length > 0 && { attachments }
+	};
+}
+function buildTypingActivity() {
+	return { type: "typing" };
+}
+function buildMediaActivity(input) {
+	const contentType = input.content_type ?? "application/octet-stream";
+	let bytes;
+	try {
+		bytes = base64ToBytes(input.body_base64);
+	} catch (error) {
+		throw new ToolError("Invalid base64 body", {
+			code: "bad_input",
+			cause: error
+		});
+	}
+	if (bytes.byteLength === 0) throw new ToolError("Media body must not be empty", { code: "bad_input" });
+	if (bytes.byteLength > 4194304) throw new ToolError("Media exceeds 4 MiB data-URI limit", {
+		code: "too_large",
+		details: {
+			max_bytes: MAX_MEDIA_BYTES,
+			content_length: bytes.byteLength
+		}
+	});
+	return {
+		type: "message",
+		...input.caption && { text: input.caption },
+		...input.reply_to_message_id && { replyToId: input.reply_to_message_id },
+		attachments: [{
+			contentType,
+			contentUrl: `data:${contentType};base64,${input.body_base64}`,
+			name: input.file_name
+		}]
+	};
+}
+function parseDownload(input, bytes) {
+	const fromUrl = (() => {
+		try {
+			const last = new URL(input.file_id).pathname.split("/").filter(Boolean).pop();
+			return last && last.length > 0 ? decodeURIComponent(last) : void 0;
+		} catch {
+			return;
+		}
+	})();
+	return {
+		file_name: input.file_name ?? fromUrl ?? "download",
+		file_size: bytes.byteLength,
+		body_base64: bytesToBase64(bytes)
+	};
+}
+function botIdentityFromAuth(appId) {
+	return {
+		bot_id: appId,
+		username: "teams-bot",
+		display_name: "Teams Bot"
+	};
+}
+function isAbsoluteHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+/** Optional invoke-response body when answering via a reply path. */
+function buildInvokeResponseBody(input) {
+	return {
+		type: "invokeResponse",
+		value: {
+			status: 200,
+			body: {
+				...input.text && { text: input.text },
+				...input.show_alert !== void 0 && { showAlert: input.show_alert }
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vendors/teams/client.ts
+/**
+* Microsoft Teams / Bot Framework vendor client.
+* Host: `new TeamsClient(auth)`. Agent tools: `fromContext(ctx)`.
+*
+* Connector base is per-conversation (`service_url` on method input).
+* Access tokens are cached on the instance with ~60s skew.
+*/
+var TeamsClient = class TeamsClient {
+	#auth;
+	#http;
+	#accessToken;
+	#accessTokenExpiresAt = 0;
+	#graphToken;
+	#graphTokenExpiresAt = 0;
+	constructor(auth, options = {}) {
+		const parsed = teamsAuthSchema.safeParse(auth);
+		if (!parsed.success) throw new ToolError("Invalid Teams auth credentials", {
+			code: "bad_auth",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		this.#auth = parsed.data;
+		this.#http = new HttpService({
+			...options,
+			label: "Teams"
+		});
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, teamsAuthSchema);
+		return new TeamsClient(auth, {
+			...ctx.fetch && { fetch: ctx.fetch },
+			...ctx.signal && { signal: ctx.signal }
+		});
+	}
+	async #ensureAccessToken() {
+		const now = Date.now();
+		if (this.#accessToken && now < this.#accessTokenExpiresAt - 6e4) return this.#accessToken;
+		try {
+			const { data } = await this.#http.post(botframeworkTokenUrl(this.#auth.tenant_id), botframeworkTokenBody(this.#auth), {
+				label: "Teams token",
+				headers: { "Content-Type": "application/x-www-form-urlencoded" }
+			});
+			const token = parseAccessToken(data);
+			this.#accessToken = token.access_token;
+			this.#accessTokenExpiresAt = now + token.expires_in * 1e3;
+			return token.access_token;
+		} catch (error) {
+			throwTeamsTransportError("Teams token", error);
+		}
+	}
+	async #postActivity(label, url, body, headers) {
+		try {
+			return await this.#http.post(url, body, {
+				label,
+				headers,
+				noThrow: true
+			});
+		} catch (error) {
+			throwTeamsTransportError(label, error);
+		}
+	}
+	async #putActivity(label, url, body, headers) {
+		try {
+			return await this.#http.put(url, body, {
+				label,
+				headers,
+				noThrow: true
+			});
+		} catch (error) {
+			throwTeamsTransportError(label, error);
+		}
+	}
+	async #authHeaders() {
+		return {
+			Authorization: `Bearer ${await this.#ensureAccessToken()}`,
+			"Content-Type": "application/json"
+		};
+	}
+	/** POST {service_url}/v3/conversations/{chat_id}/activities — type message */
+	async sendText(input) {
+		const headers = await this.#authHeaders();
+		const url = conversationActivitiesPath(input.service_url, input.chat_id);
+		const body = buildMessageActivity({
+			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 }
+		});
+		const res = await this.#postActivity("Teams sendText", url, body, headers);
+		if (!res.ok) throwForStatus("Teams sendText", res.status, res.data);
+		return parseActivityId(res.data);
+	}
+	/** PUT {service_url}/v3/conversations/{chat_id}/activities/{message_id} */
+	async editText(input) {
+		const headers = await this.#authHeaders();
+		const url = conversationActivityPath(input.service_url, input.chat_id, input.message_id);
+		const body = buildMessageActivity({
+			text: input.text,
+			...input.reply_markup !== void 0 && { reply_markup: input.reply_markup }
+		});
+		const res = await this.#putActivity("Teams editText", url, body, headers);
+		if (!res.ok) throwForStatus("Teams editText", res.status, res.data);
+		if (res.data === void 0 || res.data === null || res.data === "") return { message_id: input.message_id };
+		try {
+			return parseActivityId(res.data);
+		} catch {
+			return { message_id: input.message_id };
+		}
+	}
+	/** POST typing activity (all ChannelTransport actions map to typing). */
+	async sendChatAction(input) {
+		const headers = await this.#authHeaders();
+		const url = conversationActivitiesPath(input.service_url, input.chat_id);
+		const res = await this.#postActivity("Teams sendChatAction", url, buildTypingActivity(), headers);
+		if (!res.ok) throwForStatus("Teams sendChatAction", res.status, res.data);
+	}
+	/**
+	* Add a reaction via Microsoft Graph when `tenant_id` is bound on auth.
+	* Without `tenant_id`, succeeds as a no-op (Bot Framework has no reaction write).
+	* Channel messages: pass `team_id` + `channel_id`; otherwise uses chat path with `chat_id`.
+	*/
+	async setReaction(input) {
+		if (!this.#auth.tenant_id) return;
+		await this.#graphReaction("setReaction", input);
+	}
+	/**
+	* Remove a reaction via Graph when `tenant_id` is bound. Requires `emoji` matching setReaction.
+	* Without `tenant_id`, succeeds as a no-op.
+	*/
+	async clearReaction(input) {
+		if (!this.#auth.tenant_id) return;
+		if (!input.emoji) throw new ToolError("Teams clearReaction requires emoji when using Graph reactions (tenant_id bound)", { code: "bad_input" });
+		await this.#graphReaction("unsetReaction", {
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			emoji: input.emoji,
+			...input.team_id && { team_id: input.team_id },
+			...input.channel_id && { channel_id: input.channel_id }
+		});
+	}
+	async #ensureGraphToken() {
+		const tenantId = this.#auth.tenant_id;
+		if (!tenantId) throw new ToolError("Teams Graph reactions require tenant_id on auth", { code: "bad_auth" });
+		const now = Date.now();
+		if (this.#graphToken && now < this.#graphTokenExpiresAt - 6e4) return this.#graphToken;
+		try {
+			const { data } = await this.#http.post(botframeworkTokenUrl(tenantId), graphTokenBody(this.#auth), {
+				label: "Teams Graph token",
+				headers: { "Content-Type": "application/x-www-form-urlencoded" }
+			});
+			const token = parseAccessToken(data);
+			this.#graphToken = token.access_token;
+			this.#graphTokenExpiresAt = now + token.expires_in * 1e3;
+			return token.access_token;
+		} catch (error) {
+			throwTeamsTransportError("Teams Graph token", error);
+		}
+	}
+	async #graphReaction(op, input) {
+		const token = await this.#ensureGraphToken();
+		const url = graphReactionUrl({
+			chat_id: input.chat_id,
+			message_id: input.message_id,
+			op,
+			...input.team_id && { team_id: input.team_id },
+			...input.channel_id && { channel_id: input.channel_id }
+		});
+		const label = op === "setReaction" ? "Teams Graph setReaction" : "Teams Graph unsetReaction";
+		let res;
+		try {
+			res = await this.#http.post(url, { reactionType: toGraphReactionType(input.emoji) }, {
+				label,
+				noThrow: true,
+				headers: {
+					Authorization: `Bearer ${token}`,
+					"Content-Type": "application/json; charset=utf-8"
+				}
+			});
+		} catch (error) {
+			throwTeamsTransportError(label, error);
+		}
+		if (!res.ok) throwForStatus(label, res.status, res.data);
+	}
+	/** POST message with data-URI attachment (small files). */
+	async sendMedia(input) {
+		const headers = await this.#authHeaders();
+		const url = conversationActivitiesPath(input.service_url, input.chat_id);
+		const body = buildMediaActivity(input);
+		const res = await this.#postActivity("Teams sendMedia", url, body, headers);
+		if (!res.ok) throwForStatus("Teams sendMedia", res.status, res.data);
+		return parseActivityId(res.data);
+	}
+	/** GET content URL (file_id) with bearer token; return body_base64. */
+	async downloadFile(input) {
+		const token = await this.#ensureAccessToken();
+		let res;
+		try {
+			res = await this.#http.bytes("GET", input.file_id, {
+				label: "Teams downloadFile",
+				headers: { Authorization: `Bearer ${token}` },
+				noThrow: true
+			});
+		} catch (error) {
+			throwTeamsTransportError("Teams downloadFile", error);
+		}
+		if (!res.ok) throw new TeamsClientError({
+			message: `Teams downloadFile failed with HTTP ${res.status}`,
+			failureKind: res.status === 400 || res.status === 401 || res.status === 403 || res.status === 404 ? "definite_rejection" : "outcome_unknown",
+			method: "Teams downloadFile",
+			status: res.status
+		});
+		return parseDownload(input, res.bytes);
+	}
+	/**
+	* Answer an invoke callback. When `callback_query_id` is an absolute HTTP(S)
+	* reply path, POST an invokeResponse there. Otherwise succeed as a no-op
+	* (host may have already completed the HTTP invoke response).
+	*/
+	async answerCallback(input) {
+		if (!isAbsoluteHttpUrl(input.callback_query_id)) return;
+		const headers = await this.#authHeaders();
+		const body = buildInvokeResponseBody({
+			...input.text && { text: input.text },
+			...input.show_alert !== void 0 && { show_alert: input.show_alert }
+		});
+		const res = await this.#postActivity("Teams answerCallback", input.callback_query_id, body, headers);
+		if (!res.ok) throwForStatus("Teams answerCallback", res.status, res.data);
+	}
+	/** Identity from bound auth (no connector call). */
+	async getBot() {
+		return botIdentityFromAuth(this.#auth.app_id);
+	}
+};
+//#endregion
+//#region src/vendors/teams/module.ts
+const emptyInputSchema = z.object({}).describe("No input fields");
+const teamsSendTextTool = defineTool({
+	id: "teams-send-text",
+	name: "teamsSendText",
+	description: "Send a text message to a Microsoft Teams conversation via Bot Framework. Requires service_url from the inbound activity. Returns the new activity message_id.",
+	inputSchema: teamsSendTextInputSchema,
+	outputSchema: teamsMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => TeamsClient.fromContext(ctx).sendText(input)
+});
+const teamsEditTextTool = defineTool({
+	id: "teams-edit-text",
+	name: "teamsEditText",
+	description: "Edit the text of an existing Teams activity. Used for progressive live updates and corrections. Requires service_url.",
+	inputSchema: teamsEditTextInputSchema,
+	outputSchema: teamsMessageOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => TeamsClient.fromContext(ctx).editText(input)
+});
+const teamsSendChatActionTool = defineTool({
+	id: "teams-send-chat-action",
+	name: "teamsSendChatAction",
+	description: "Show a typing indicator in a Teams conversation (Bot Framework typing activity). All action values map to typing. Requires service_url.",
+	inputSchema: teamsSendChatActionInputSchema,
+	outputSchema: teamsOkOutputSchema,
+	sideEffect: "none",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TeamsClient.fromContext(ctx).sendChatAction(input);
+		return { ok: true };
+	}
+});
+const teamsSetReactionTool = defineTool({
+	id: "teams-set-reaction",
+	name: "teamsSetReaction",
+	description: "Set a reaction on a Teams message. Bot Framework reaction support is limited; this call succeeds as a presentation no-op so channel seams stay uniform.",
+	inputSchema: teamsSetReactionInputSchema,
+	outputSchema: teamsOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TeamsClient.fromContext(ctx).setReaction(input);
+		return { ok: true };
+	}
+});
+const teamsClearReactionTool = defineTool({
+	id: "teams-clear-reaction",
+	name: "teamsClearReaction",
+	description: "Clear reactions on a Teams message. Bot Framework reaction support is limited; this call succeeds as a presentation no-op.",
+	inputSchema: teamsClearReactionInputSchema,
+	outputSchema: teamsOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TeamsClient.fromContext(ctx).clearReaction(input);
+		return { ok: true };
+	}
+});
+const teamsSendMediaTool = defineTool({
+	id: "teams-send-media",
+	name: "teamsSendMedia",
+	description: "Send one photo or document to a Teams conversation as a Bot Framework data-URI attachment (small files). Requires service_url.",
+	inputSchema: teamsSendMediaInputSchema,
+	outputSchema: teamsMessageOutputSchema,
+	sideEffect: "send",
+	runtime: "both",
+	execute: async (input, ctx) => TeamsClient.fromContext(ctx).sendMedia(input)
+});
+const teamsDownloadFileTool = defineTool({
+	id: "teams-download-file",
+	name: "teamsDownloadFile",
+	description: "Download a Teams/Bot Framework file by content URL (file_id) and return the body as base64 with optional size and name.",
+	inputSchema: teamsDownloadFileInputSchema,
+	outputSchema: teamsDownloadFileOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (input, ctx) => TeamsClient.fromContext(ctx).downloadFile(input)
+});
+const teamsAnswerCallbackTool = defineTool({
+	id: "teams-answer-callback",
+	name: "teamsAnswerCallback",
+	description: "Acknowledge a Teams invoke. When callback_query_id is an absolute reply URL, POSTs an invokeResponse; otherwise succeeds as a no-op.",
+	inputSchema: teamsAnswerCallbackInputSchema,
+	outputSchema: teamsOkOutputSchema,
+	sideEffect: "write",
+	runtime: "both",
+	execute: async (input, ctx) => {
+		await TeamsClient.fromContext(ctx).answerCallback(input);
+		return { ok: true };
+	}
+});
+const teamsGetBotTool = defineTool({
+	id: "teams-get-bot",
+	name: "teamsGetBot",
+	description: "Return the current Microsoft Teams bot identity, including bot_id, username, and display_name.",
+	inputSchema: emptyInputSchema,
+	outputSchema: teamsGetBotOutputSchema,
+	sideEffect: "read",
+	runtime: "both",
+	execute: async (_input, ctx) => TeamsClient.fromContext(ctx).getBot()
+});
+const teamsModule = defineModule({
+	id: "teams",
+	title: "Microsoft Teams",
+	description: "Microsoft Teams tools for text, media, typing, file download, invoke callbacks, and bot identity. Conversation actions require service_url from the active conversation; reaction actions report unsupported behavior.",
+	runtime: "both",
+	auth: {
+		type: "custom",
+		schema: teamsAuthSchema
+	},
+	categories: ["messaging", "chat"],
+	classification: "pii",
+	tags: ["teams", "bot-framework"],
+	tools: [
+		teamsSendTextTool,
+		teamsEditTextTool,
+		teamsSendChatActionTool,
+		teamsSetReactionTool,
+		teamsClearReactionTool,
+		teamsSendMediaTool,
+		teamsDownloadFileTool,
+		teamsAnswerCallbackTool,
+		teamsGetBotTool
+	]
+});
+//#endregion
+//#region src/vendors/teams/webhook.ts
+/**
+* Host-owned Bot Framework JWT validation is authoritative.
+* This helper only checks that an Authorization Bearer token is present
+* (length > 0 after the scheme). Do not treat a true result as cryptographic
+* authenticity.
+*/
+function verifyTeamsAuthHeader(headerValue) {
+	if (!headerValue) return false;
+	const match = /^Bearer\s+(\S+)$/i.exec(headerValue.trim());
+	return Boolean(match?.[1] && match[1].length > 0);
+}
+/** True when value looks like a Bot Framework activity object. */
+function isTeamsActivity(value) {
+	if (!isPlainObject(value)) return false;
+	if (!isString(value["type"]) || value["type"].length === 0) return false;
+	const conversation = value["conversation"];
+	return isPlainObject(conversation) && isString(conversation["id"]) && conversation["id"].length > 0;
+}
+/**
+* Parse one raw Bot Framework Activity into a normalized inbound event.
+* Returns ok:false for payloads the pack does not surface.
+*/
+function parseTeamsActivity(body, options) {
+	if (!isPlainObject(body)) return {
+		ok: false,
+		reason: "activity_not_object"
+	};
+	if (!isString(body["type"]) || body["type"].length === 0) return {
+		ok: false,
+		reason: "missing_type"
+	};
+	const conversation = body["conversation"];
+	if (!isPlainObject(conversation) || !isString(conversation["id"]) || conversation["id"].length === 0) return {
+		ok: false,
+		reason: "missing_conversation"
+	};
+	const receivedAt = options?.received_at ?? (/* @__PURE__ */ new Date()).toISOString();
+	const rawType = body["type"];
+	const activityId = isString(body["id"]) && body["id"].length > 0 ? body["id"] : void 0;
+	const eventId = activityId ?? `${rawType}:${conversation["id"]}:${receivedAt}`;
+	const serviceUrl = isString(body["serviceUrl"]) && body["serviceUrl"].length > 0 ? body["serviceUrl"] : void 0;
+	const from = body["from"];
+	const userId = isPlainObject(from) && isString(from["id"]) ? from["id"] : void 0;
+	const username = isPlainObject(from) && isString(from["name"]) ? from["name"] : void 0;
+	const text = firstString(body["text"], body["summary"]);
+	const replyTo = isString(body["replyToId"]) && body["replyToId"].length > 0 ? body["replyToId"] : void 0;
+	const media = collectMedia(body);
+	const conversationType = isString(conversation["conversationType"]) && conversation["conversationType"].length > 0 ? conversation["conversationType"] : void 0;
+	if (rawType === "invoke") {
+		const callbackData = encodeCallbackData(body["value"]);
+		return {
+			ok: true,
+			event: {
+				channel: "teams",
+				event_id: eventId,
+				chat_id: conversation["id"],
+				raw_type: "invoke",
+				received_at: receivedAt,
+				callback_query_id: activityId ?? eventId,
+				...userId && { user_id: userId },
+				...username && { username },
+				...activityId && { message_id: activityId },
+				...callbackData && { callback_data: callbackData },
+				...serviceUrl && { service_url: serviceUrl },
+				...conversationType && { chat_type: conversationType }
+			}
+		};
+	}
+	if (rawType === "message" || rawType === "messageUpdate") {
+		if (!text && media.length === 0) return {
+			ok: false,
+			reason: "empty_message"
+		};
+		return {
+			ok: true,
+			event: {
+				channel: "teams",
+				event_id: eventId,
+				chat_id: conversation["id"],
+				raw_type: rawType,
+				received_at: receivedAt,
+				...userId && { user_id: userId },
+				...username && { username },
+				...activityId && { message_id: activityId },
+				...text && { text },
+				...media.length > 0 && { media },
+				...replyTo && { reply_to: replyTo },
+				...serviceUrl && { service_url: serviceUrl },
+				...conversationType && { chat_type: conversationType }
+			}
+		};
+	}
+	return {
+		ok: true,
+		event: {
+			channel: "teams",
+			event_id: eventId,
+			chat_id: conversation["id"],
+			raw_type: rawType,
+			received_at: receivedAt,
+			...userId && { user_id: userId },
+			...username && { username },
+			...activityId && { message_id: activityId },
+			...text && { text },
+			...serviceUrl && { service_url: serviceUrl },
+			...conversationType && { chat_type: conversationType }
+		}
+	};
+}
+function firstString(...values) {
+	for (const value of values) if (isString(value) && value.length > 0) return value;
+}
+function encodeCallbackData(value) {
+	if (isString(value) && value.length > 0) return value;
+	if (isPlainObject(value)) try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+function collectMedia(activity) {
+	const out = [];
+	const attachments = activity["attachments"];
+	if (!Array.isArray(attachments)) return out;
+	for (const item of attachments) {
+		if (!isPlainObject(item)) continue;
+		const contentType = isString(item["contentType"]) ? item["contentType"] : void 0;
+		const contentUrl = isString(item["contentUrl"]) ? item["contentUrl"] : void 0;
+		const name = isString(item["name"]) ? item["name"] : void 0;
+		if (!contentUrl && !contentType && !name) continue;
+		const kind = contentType && contentType.startsWith("image/") ? "photo" : contentType && contentType.startsWith("audio/") ? "audio" : contentType && contentType.startsWith("video/") ? "video" : "document";
+		out.push({
+			kind,
+			...contentUrl && { ref: contentUrl },
+			...contentType && { media_type: contentType },
+			...name && { file_name: name }
+		});
+	}
+	return out;
+}
+//#endregion
+export { teamsSendTextInputSchema as A, teamsDownloadFileOutputSchema as C, teamsOkOutputSchema as D, teamsMessageOutputSchema as E, teamsSendChatActionInputSchema as O, teamsDownloadFileInputSchema as S, teamsGetBotOutputSchema as T, isTeamsOutcomeUnknown as _, teamsClearReactionTool as a, teamsAuthSchema as b, teamsGetBotTool as c, teamsSendMediaTool as d, teamsSendTextTool as f, isTeamsDefiniteRejection as g, TeamsClientError as h, teamsAnswerCallbackTool as i, teamsSetReactionInputSchema as j, teamsSendMediaInputSchema as k, teamsModule as l, TeamsClient as m, parseTeamsActivity as n, teamsDownloadFileTool as o, teamsSetReactionTool as p, verifyTeamsAuthHeader as r, teamsEditTextTool as s, isTeamsActivity as t, teamsSendChatActionTool as u, MAX_MEDIA_BYTES as v, teamsEditTextInputSchema as w, teamsClearReactionInputSchema as x, teamsAnswerCallbackInputSchema as y };
+
+//# sourceMappingURL=teams-DYAHNb39.js.map