@patimweb/pi-teams 1.0.0

package/src/tools/teams-delete-message.ts

@@ -0,0 +1,114 @@
+/**
+ * teams_delete_message — soft-delete one of the user's own messages.
+ *
+ * Graph only permits this for the sender, which is also the only case that
+ * makes sense here: pi may take back something it said in the user's name, not
+ * edit anyone else's history.
+ */
+
+import { Type } from "typebox";
+import { softDeleteMessage, undoSoftDeleteMessage } from "../graph/messages.ts";
+import { auditWrite } from "../safety/audit.ts";
+import { requireChannel, requireChat } from "./resolve.ts";
+import {
+	AccountParam,
+	TenantParam,
+	connectionFor,
+	currentUser,
+	errorResult,
+	run,
+	textResult,
+	type ToolContext,
+	type ToolResult,
+} from "./shared.ts";
+import type { MessageLocation } from "../types.ts";
+
+export const teamsDeleteMessageTool = {
+	name: "teams_delete_message",
+	description:
+		"Delete a message the signed-in user sent in Microsoft Teams (soft delete, exactly like deleting it in " +
+		"the app). Specify 'chat' or 'channel' (plus 'team') to say where it lives. " +
+		"Set undo: true to restore a message that was soft-deleted. Only the sender's own messages can be deleted.",
+	parameters: Type.Object({
+		messageId: Type.String({ description: "ID of the message to delete" }),
+		chat: Type.Optional(Type.String({ description: "Chat ID or name, when the message is in a chat" })),
+		channel: Type.Optional(
+			Type.String({ description: "Channel name/ID or 'Team/Channel' path, when it is in a channel" }),
+		),
+		team: Type.Optional(Type.String({ description: "Team name or ID" })),
+		replyId: Type.Optional(
+			Type.String({ description: "Reply ID, when deleting a reply inside a channel thread" }),
+		),
+		undo: Type.Optional(Type.Boolean({ description: "Restore a previously deleted message" })),
+		account: AccountParam,
+		tenant: TenantParam,
+	}),
+	promptSnippet: "Delete a message the user sent in Teams",
+
+	async execute(
+		_toolCallId: string,
+		params: {
+			messageId: string;
+			chat?: string;
+			channel?: string;
+			team?: string;
+			replyId?: string;
+			undo?: boolean;
+			account?: string;
+			tenant?: string;
+		},
+		signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		ctx: ToolContext,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const conn = connectionFor(ctx, params.account, params.tenant);
+
+			let location: MessageLocation;
+			let target: string;
+
+			if (params.chat) {
+				const chat = await requireChat(conn, params.chat, "write", signal);
+				location = { kind: "chat", chatId: chat.id };
+				target = `chat:${chat.label}`;
+			} else if (params.channel) {
+				const { team, channel } = await requireChannel(conn, params.team, params.channel, "write", signal);
+				location = {
+					kind: "channel",
+					teamId: team.id,
+					teamName: team.displayName,
+					channelId: channel.id,
+					channelName: channel.displayName,
+				};
+				target = `channel:${team.displayName}/${channel.displayName}`;
+			} else {
+				return errorResult("Specify either 'chat' or 'channel' so pi knows where the message lives.");
+			}
+
+			// Graph needs an explicit user id for the chat form of this action, and
+			// only the sender may delete — so failing here is better than a 403.
+			const me = await currentUser(conn, signal);
+
+			const options = { replyId: params.replyId, signal };
+			if (params.undo) {
+				await undoSoftDeleteMessage(conn, location, params.messageId, me.id, options);
+			} else {
+				await softDeleteMessage(conn, location, params.messageId, me.id, options);
+			}
+
+			auditWrite(conn.audit, {
+				tool: "teams_delete_message",
+				account: conn.account,
+				tenant: conn.tenant,
+				actor: me.upn,
+				target,
+				summary: `${params.undo ? "restored" : "deleted"} message ${params.messageId}`,
+			});
+
+			return textResult(
+				`✅ Message ${params.messageId} ${params.undo ? "restored" : "deleted"} in ${target}.`,
+				{ messageId: params.messageId, undone: !!params.undo },
+			);
+		});
+	},
+};

package/src/tools/teams-doctor.ts

@@ -0,0 +1,182 @@
+/**
+ * teams_doctor — diagnose configuration, sign-in, consent and connectivity.
+ *
+ * Written to be the first thing anyone runs when something does not work, and
+ * to answer the question a 403 never answers: *which* permission is missing,
+ * and who has to grant it.
+ */
+
+import { Type } from "typebox";
+import {
+	getConfigPath,
+	resolveAllConnections,
+	DEFAULT_SCOPES,
+	type TeamsConnection,
+} from "../config/index.ts";
+import { getToken, getTokenPath, isFresh } from "../auth/token-store.ts";
+import { tokenScopes } from "../auth/jwt.ts";
+import { getAccessToken } from "../auth/index.ts";
+import { getMe } from "../graph/me.ts";
+import { listJoinedTeams } from "../graph/teams.ts";
+import { formatGraphError, describeScope } from "../utils/errors.ts";
+import { formatPermissions } from "../config/scope.ts";
+import { getAuditPath } from "../safety/audit.ts";
+import { run, textResult, type ToolResult } from "./shared.ts";
+
+interface DoctorParams {
+	account?: string;
+	/** Skip the live Graph calls */
+	offline?: boolean;
+}
+
+async function checkConnection(
+	conn: TeamsConnection,
+	offline: boolean,
+	signal?: AbortSignal,
+): Promise<string[]> {
+	const label = conn.tenant === conn.account ? conn.account : `${conn.account}/${conn.tenant}`;
+	const lines = [`### ${label}`, ""];
+
+	lines.push(`- tenant: \`${conn.tenantId}\``);
+	lines.push(`- client: \`${conn.clientId}\``);
+	lines.push(`- auth mode: ${conn.authMode}`);
+	lines.push(`- safety level: ${conn.safetyLevel}`);
+
+	if (conn.authMode === "client-credentials") {
+		lines.push(
+			"- ⚠️ app-only: pi cannot post messages as a person with this mode " +
+				"(Microsoft Graph restricts app-only message writes to migration scenarios)",
+		);
+	}
+
+	const token = getToken(conn.account, conn.tenantId);
+	if (!token) {
+		lines.push("- ❌ not signed in — run `teams_login`");
+		return lines;
+	}
+
+	lines.push(
+		isFresh(token)
+			? `- ✅ token valid until ${new Date(token.expiresAt).toLocaleString()}`
+			: token.refreshToken
+				? "- ⚠️ access token expired, refresh token present (will renew on the next call)"
+				: "- ❌ token expired and no refresh token — run `teams_login`",
+	);
+
+	// Consent check works offline: the scopes are inside the token.
+	const granted = tokenScopes(token.accessToken);
+	if (granted.length > 0) {
+		const wanted = (conn.scopes.length > 0 ? conn.scopes : DEFAULT_SCOPES).filter(
+			(scope) => !["openid", "profile", "offline_access"].includes(scope),
+		);
+		const missing = wanted.filter(
+			(scope) => !granted.some((g) => g.toLowerCase() === scope.toLowerCase()),
+		);
+		if (missing.length === 0) {
+			lines.push(`- ✅ all ${wanted.length} requested scopes granted`);
+		} else {
+			lines.push("- ⚠️ missing consent:");
+			for (const scope of missing) {
+				const purpose = describeScope(scope);
+				lines.push(`  - \`${scope}\`${purpose ? ` — needed for ${purpose}` : ""}`);
+			}
+			lines.push(
+				"  Sign in again after an admin grants consent, or remove the unused scopes from the account's `scopes`.",
+			);
+		}
+	}
+
+	if (offline) return lines;
+
+	try {
+		await getAccessToken(conn, signal);
+	} catch (err) {
+		lines.push(`- ❌ could not obtain a token: ${formatGraphError(err)}`);
+		return lines;
+	}
+
+	try {
+		const me = await getMe(conn, signal);
+		lines.push(`- ✅ acting as **${me.displayName}** <${me.upn}>`);
+	} catch (err) {
+		lines.push(`- ❌ /me failed: ${formatGraphError(err)}`);
+		return lines;
+	}
+
+	try {
+		const teams = await listJoinedTeams(conn, 5, signal);
+		lines.push(`- ✅ can list teams (${teams.length === 5 ? "5+" : teams.length} visible)`);
+	} catch (err) {
+		lines.push(`- ⚠️ listing teams failed: ${formatGraphError(err)}`);
+	}
+
+	return lines;
+}
+
+export const teamsDoctorTool = {
+	name: "teams_doctor",
+	description:
+		"Diagnose the Microsoft Teams setup: configuration, sign-in state, which Graph scopes were actually " +
+		"granted, and whether live calls succeed — for every configured account and tenant. " +
+		"Run this first whenever a Teams tool fails.",
+	parameters: Type.Object({
+		account: Type.Optional(Type.String({ description: "Check only this account" })),
+		offline: Type.Optional(
+			Type.Boolean({ description: "Skip live Graph calls and only check config and cached tokens" }),
+		),
+	}),
+	promptSnippet: "Check the Teams configuration and sign-in health",
+	promptGuidelines: [
+		"Run teams_doctor when any Teams tool returns an auth, permission or configuration error.",
+		"Report the missing scopes verbatim — the user may need an admin to consent to them.",
+	],
+
+	async execute(
+		_toolCallId: string,
+		params: DoctorParams,
+		signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		_ctx: unknown,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const { connections, errors } = resolveAllConnections();
+			const selected = params.account
+				? connections.filter((c) => c.account.toLowerCase() === params.account!.toLowerCase())
+				: connections;
+
+			const lines = ["## Teams doctor", ""];
+			lines.push(`- config: \`${getConfigPath()}\``);
+			lines.push(`- tokens: \`${getTokenPath()}\``);
+			lines.push(`- audit log: \`${getAuditPath()}\``);
+			lines.push("");
+
+			if (errors.length > 0) {
+				lines.push("### Configuration problems", "");
+				for (const error of errors) lines.push(`- ❌ ${error}`);
+				lines.push("");
+			}
+
+			if (selected.length === 0) {
+				lines.push(
+					params.account
+						? `No connection found for account "${params.account}".`
+						: "No usable connections configured. Run `teams_setup` to add one.",
+				);
+				return textResult(lines.join("\n"), { ok: false });
+			}
+
+			for (const conn of selected) {
+				lines.push(...(await checkConnection(conn, params.offline === true, signal)));
+				lines.push("");
+			}
+
+			const first = selected[0]!;
+			lines.push("### Scope rules of the default connection", "", formatPermissions(first.permissions));
+
+			return textResult(lines.join("\n"), {
+				accounts: selected.map((c) => `${c.account}/${c.tenant}`),
+				configErrors: errors,
+			});
+		});
+	},
+};

package/src/tools/teams-find-user.ts

@@ -0,0 +1,64 @@
+/**
+ * teams_find_user — look someone up in the directory.
+ */
+
+import { Type } from "typebox";
+import { findUsers } from "../graph/me.ts";
+import { hasAccess } from "../safety/index.ts";
+import {
+	AccountParam,
+	LimitParam,
+	TenantParam,
+	connectionFor,
+	run,
+	textResult,
+	type ToolContext,
+	type ToolResult,
+} from "./shared.ts";
+
+export const teamsFindUserTool = {
+	name: "teams_find_user",
+	description:
+		"Find people in the organization's directory by name, e-mail or user principal name. " +
+		"Use this to get the exact identity before starting a chat, @-mentioning someone, or " +
+		"inviting them to a meeting.",
+	parameters: Type.Object({
+		query: Type.String({ description: "Name, e-mail or UPN to search for" }),
+		account: AccountParam,
+		tenant: TenantParam,
+		limit: LimitParam,
+	}),
+	promptSnippet: "Find a person in the Teams directory",
+	promptGuidelines: [
+		"Use teams_find_user when the user refers to a colleague by first name only and an exact identity is needed.",
+	],
+
+	async execute(
+		_toolCallId: string,
+		params: { query: string; account?: string; tenant?: string; limit?: number },
+		signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		ctx: ToolContext,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const conn = connectionFor(ctx, params.account, params.tenant);
+			const people = await findUsers(conn, params.query, params.limit ?? 15, signal);
+
+			const visible = people.filter((person) =>
+				hasAccess(conn, "read", "people", [person.displayName, person.upn, person.mail, person.id]),
+			);
+
+			if (visible.length === 0) {
+				return textResult(`No directory match for "${params.query}".`, { count: 0 });
+			}
+
+			const lines = [`Found ${visible.length} person(s) for "${params.query}":`, ""];
+			for (const person of visible) {
+				lines.push(`- **${person.displayName}**${person.upn ? ` <${person.upn}>` : ""}`);
+				if (person.id) lines.push(`  userId: ${person.id}`);
+			}
+
+			return textResult(lines.join("\n"), { count: visible.length, people: visible });
+		});
+	},
+};

package/src/tools/teams-inbox.ts

@@ -0,0 +1,142 @@
+/**
+ * teams_inbox — what needs the user's attention right now.
+ *
+ * Teams has no single "unread" endpoint a delegated token can rely on, so this
+ * composes the two signals that are reliable: recent chat activity (with the
+ * last message and who sent it) and a search for mentions of the user. It
+ * deliberately answers "what changed since you last looked", not "list
+ * everything".
+ */
+
+import { Type } from "typebox";
+import { listChats } from "../graph/chats.ts";
+import { searchMessages } from "../graph/search.ts";
+import { chatCandidates } from "../graph/mappers.ts";
+import { hasAccess } from "../safety/index.ts";
+import { formatRelative, truncate } from "../utils/formatting.ts";
+import {
+	AccountParam,
+	LimitParam,
+	TenantParam,
+	connectionFor,
+	currentUser,
+	run,
+	textResult,
+	type ToolContext,
+	type ToolResult,
+} from "./shared.ts";
+
+export const teamsInboxTool = {
+	name: "teams_inbox",
+	description:
+		"Show what needs the user's attention in Microsoft Teams: chats with recent activity where the last " +
+		"message came from someone else, plus recent @-mentions of the user across chats and channels. " +
+		"Use this for 'what did I miss', 'anything new in Teams', or a morning catch-up.",
+	parameters: Type.Object({
+		account: AccountParam,
+		tenant: TenantParam,
+		limit: LimitParam,
+		hours: Type.Optional(
+			Type.Number({ description: "Only consider activity from the last N hours (default 24)" }),
+		),
+		includeMentions: Type.Optional(
+			Type.Boolean({ description: "Also search for @-mentions of the user (default true)" }),
+		),
+	}),
+	promptSnippet: "Show new Teams activity and mentions",
+	promptGuidelines: [
+		"Use teams_inbox for open-ended catch-up questions about Teams.",
+		"Summarize what is waiting and who is waiting on it; do not reply to anything unless the user asks.",
+	],
+
+	async execute(
+		_toolCallId: string,
+		params: {
+			account?: string;
+			tenant?: string;
+			limit?: number;
+			hours?: number;
+			includeMentions?: boolean;
+		},
+		signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		ctx: ToolContext,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const conn = connectionFor(ctx, params.account, params.tenant);
+			const me = await currentUser(conn, signal).catch(() => undefined);
+			const cutoff = Date.now() - (params.hours ?? 24) * 3600 * 1000;
+			const limit = params.limit ?? 15;
+
+			const chats = await listChats(conn, { max: 50, meId: me?.id, signal });
+
+			const active = chats
+				.filter((chat) => hasAccess(conn, "read", "chats", chatCandidates(chat)))
+				.filter((chat) => {
+					if (!chat.lastUpdated) return false;
+					if (new Date(chat.lastUpdated).getTime() < cutoff) return false;
+					// Something the user themselves said last is not waiting on them.
+					if (me && chat.lastMessageFrom && chat.lastMessageFrom === me.displayName) return false;
+					return true;
+				})
+				.slice(0, limit);
+
+			const lines = [`## Teams inbox — last ${params.hours ?? 24} h`, ""];
+
+			if (active.length === 0) {
+				lines.push("No chat activity waiting for you.", "");
+			} else {
+				lines.push(`### ${active.length} chat(s) with new messages`, "");
+				for (const chat of active) {
+					lines.push(`- **${chat.label}** · ${formatRelative(chat.lastUpdated)}`);
+					if (chat.lastMessagePreview) {
+						const who = chat.lastMessageFrom ? `${chat.lastMessageFrom}: ` : "";
+						lines.push(`  ${who}${truncate(chat.lastMessagePreview, 140)}`);
+					}
+					lines.push(`  chatId: ${chat.id}`);
+				}
+				lines.push("");
+			}
+
+			if (params.includeMentions !== false && me) {
+				try {
+					const hits = await searchMessages(conn, `"${me.displayName}"`, { max: 15, signal });
+					const recent = hits.filter((hit) => {
+						const created = hit.message.createdDateTime;
+						if (!created || new Date(created).getTime() < cutoff) return false;
+						// Only real mentions, not every message containing the name.
+						return hit.message.mentions.some(
+							(mention) => mention.id === me.id || mention.displayName === me.displayName,
+						);
+					});
+
+					if (recent.length > 0) {
+						lines.push(`### ${recent.length} mention(s) of you`, "");
+						for (const hit of recent) {
+							const where = hit.channelIdentity?.channelId
+								? `channel ${hit.channelIdentity.channelId}`
+								: hit.chatId
+									? `chat ${hit.chatId}`
+									: "unknown";
+							lines.push(
+								`- **${hit.message.from?.displayName ?? "(unknown)"}** · ${formatRelative(hit.message.createdDateTime)} · ${where}`,
+							);
+							lines.push(`  ${truncate(hit.message.text, 160)}`);
+							lines.push(`  messageId: ${hit.message.id}`);
+						}
+						lines.push("");
+					}
+				} catch {
+					// Search needs its own consent and is not granted everywhere; the
+					// chat half of the answer is still worth returning.
+					lines.push("_Mention search unavailable (Microsoft Search may not be consented)._", "");
+				}
+			}
+
+			return textResult(lines.join("\n").trimEnd(), {
+				chats: active.length,
+				account: conn.account,
+			});
+		});
+	},
+};

package/src/tools/teams-list-channels.ts

@@ -0,0 +1,62 @@
+/**
+ * teams_list_channels — channels of a team, filtered by the read rules.
+ */
+
+import { Type } from "typebox";
+import { listChannels } from "../graph/teams.ts";
+import { channelCandidates } from "../graph/mappers.ts";
+import { hasAccess } from "../safety/index.ts";
+import { formatChannelList } from "../utils/formatting.ts";
+import { requireTeam } from "./resolve.ts";
+import {
+	AccountParam,
+	LimitParam,
+	TenantParam,
+	connectionFor,
+	run,
+	textResult,
+	type ToolContext,
+	type ToolResult,
+} from "./shared.ts";
+
+export const teamsListChannelsTool = {
+	name: "teams_list_channels",
+	description:
+		"List the channels of a Microsoft Teams team. Accepts the team's display name or ID. " +
+		"Channels excluded by the configured read rules are not shown.",
+	parameters: Type.Object({
+		team: Type.String({ description: "Team display name or ID" }),
+		account: AccountParam,
+		tenant: TenantParam,
+		limit: LimitParam,
+	}),
+	promptSnippet: "List the channels of a Teams team",
+
+	async execute(
+		_toolCallId: string,
+		params: { team: string; account?: string; tenant?: string; limit?: number },
+		signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		ctx: ToolContext,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const conn = connectionFor(ctx, params.account, params.tenant);
+			const team = await requireTeam(conn, params.team, "read", signal);
+
+			const all = await listChannels(conn, team, params.limit ?? 100, signal);
+			const visible = all.filter((channel) =>
+				hasAccess(conn, "read", "channels", channelCandidates(channel)),
+			);
+
+			const hidden = all.length - visible.length;
+			const note = hidden > 0 ? `\n\n_${hidden} channel(s) hidden by your scope rules._` : "";
+
+			return textResult(`${formatChannelList(visible)}${note}`, {
+				team: team.displayName,
+				teamId: team.id,
+				count: visible.length,
+				hidden,
+			});
+		});
+	},
+};

package/src/tools/teams-list-chats.ts

@@ -0,0 +1,74 @@
+/**
+ * teams_list_chats — recent chats with a preview of the last message.
+ */
+
+import { Type } from "typebox";
+import { listChats } from "../graph/chats.ts";
+import { chatCandidates } from "../graph/mappers.ts";
+import { hasAccess } from "../safety/index.ts";
+import { formatChatList } from "../utils/formatting.ts";
+import {
+	AccountParam,
+	LimitParam,
+	TenantParam,
+	connectionFor,
+	currentUser,
+	run,
+	textResult,
+	type ToolContext,
+	type ToolResult,
+} from "./shared.ts";
+
+export const teamsListChatsTool = {
+	name: "teams_list_chats",
+	description:
+		"List the signed-in user's Microsoft Teams chats, most recent activity first, each with a preview of " +
+		"the last message. Chats excluded by the configured read rules are not shown. " +
+		"Use this to find a chat ID before reading or replying.",
+	parameters: Type.Object({
+		account: AccountParam,
+		tenant: TenantParam,
+		limit: LimitParam,
+		filter: Type.Optional(
+			Type.String({ description: "Only show chats whose label or participants contain this text" }),
+		),
+	}),
+	promptSnippet: "List the user's recent Teams chats",
+
+	async execute(
+		_toolCallId: string,
+		params: { account?: string; tenant?: string; limit?: number; filter?: string },
+		signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		ctx: ToolContext,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const conn = connectionFor(ctx, params.account, params.tenant);
+			const me = await currentUser(conn, signal).catch(() => undefined);
+
+			const all = await listChats(conn, {
+				max: params.limit ?? conn.maxMessages,
+				meId: me?.id,
+				signal,
+			});
+
+			const visible = all.filter((chat) => hasAccess(conn, "read", "chats", chatCandidates(chat)));
+			const filtered = params.filter
+				? visible.filter((chat) =>
+						`${chat.label} ${chat.members.map((m) => m.displayName).join(" ")}`
+							.toLowerCase()
+							.includes(params.filter!.toLowerCase()),
+					)
+				: visible;
+
+			const hidden = all.length - visible.length;
+			const note = hidden > 0 ? `\n\n_${hidden} chat(s) hidden by your scope rules._` : "";
+
+			return textResult(`${formatChatList(filtered)}${note}`, {
+				count: filtered.length,
+				hidden,
+				account: conn.account,
+			});
+		});
+	},
+};

package/src/tools/teams-list-files.ts

@@ -0,0 +1,54 @@
+/**
+ * teams_list_files — files in a channel's SharePoint folder.
+ */
+
+import { Type } from "typebox";
+import { listChannelFiles } from "../graph/teams.ts";
+import { formatFileList } from "../utils/formatting.ts";
+import { requireChannel } from "./resolve.ts";
+import {
+	AccountParam,
+	LimitParam,
+	TenantParam,
+	connectionFor,
+	run,
+	textResult,
+	type ToolContext,
+	type ToolResult,
+} from "./shared.ts";
+
+export const teamsListFilesTool = {
+	name: "teams_list_files",
+	description:
+		"List the files stored in a Microsoft Teams channel (its SharePoint folder). Returns names, sizes, " +
+		"last-modified times and web links. Use the link to open or download a file — this tool does not " +
+		"download file contents.",
+	parameters: Type.Object({
+		channel: Type.String({ description: "Channel name or ID, or a 'Team/Channel' path" }),
+		team: Type.Optional(Type.String({ description: "Team name or ID (omit when using a path)" })),
+		account: AccountParam,
+		tenant: TenantParam,
+		limit: LimitParam,
+	}),
+	promptSnippet: "List files in a Teams channel",
+
+	async execute(
+		_toolCallId: string,
+		params: { channel: string; team?: string; account?: string; tenant?: string; limit?: number },
+		signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		ctx: ToolContext,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const conn = connectionFor(ctx, params.account, params.tenant);
+			const { team, channel } = await requireChannel(conn, params.team, params.channel, "read", signal);
+
+			const files = await listChannelFiles(conn, team.id, channel.id, params.limit ?? 50, signal);
+
+			return textResult(
+				formatFileList(files, `Files in ${team.displayName}/${channel.displayName}`),
+				{ teamId: team.id, channelId: channel.id, count: files.length },
+			);
+		});
+	},
+};