@inline-openclaw/inline 0.0.5 → 0.0.7

package/dist/inline/actions.js

@@ -1,19 +1,43 @@
-import { jsonResult, readReactionParams, readNumberParam, readStringParam, } from "openclaw/plugin-sdk";
-import { InlineSdkClient, Method } from "@inline-chat/realtime-sdk";
+import { createActionGate, jsonResult, readReactionParams, readNumberParam, readStringParam, } from "openclaw/plugin-sdk";
+import { InlineSdkClient, Method, Member_Role, } from "@inline-chat/realtime-sdk";
 import { resolveInlineAccount, resolveInlineToken } from "./accounts.js";
 import { normalizeInlineTarget } from "./normalize.js";
-const ACTIONS = [
-    "reply",
-    "react",
-    "reactions",
-    "read",
-    "search",
-    "edit",
-    "channel-info",
-    "channel-edit",
-    "addParticipant",
-    "member-info",
+const ACTION_GROUPS = [
+    { key: "reply", defaultEnabled: true, actions: ["reply"] },
+    { key: "reactions", defaultEnabled: true, actions: ["react", "reactions"] },
+    { key: "read", defaultEnabled: true, actions: ["read"] },
+    { key: "search", defaultEnabled: true, actions: ["search"] },
+    { key: "edit", defaultEnabled: true, actions: ["edit"] },
+    {
+        key: "channels",
+        defaultEnabled: true,
+        actions: [
+            "channel-info",
+            "channel-edit",
+            "channel-list",
+            "channel-create",
+            "channel-delete",
+            "channel-move",
+            "thread-list",
+            "thread-create",
+        ],
+    },
+    {
+        key: "participants",
+        defaultEnabled: true,
+        actions: ["addParticipant", "removeParticipant", "leaveGroup", "member-info"],
+    },
+    { key: "delete", defaultEnabled: true, actions: ["delete", "unsend"] },
+    { key: "pins", defaultEnabled: true, actions: ["pin", "unpin", "list-pins"] },
+    { key: "permissions", defaultEnabled: true, actions: ["permissions"] },
 ];
+const ACTION_TO_GATE_KEY = new Map();
+for (const group of ACTION_GROUPS) {
+    for (const action of group.actions) {
+        ACTION_TO_GATE_KEY.set(action, group.key);
+    }
+}
+const SUPPORTED_ACTIONS = Array.from(ACTION_TO_GATE_KEY.keys());
 function normalizeChatId(raw) {
     const normalized = normalizeInlineTarget(raw) ?? raw.trim();
     if (!/^[0-9]+$/.test(normalized)) {
@@ -36,11 +60,28 @@ function readFlexibleId(params, key) {
     }
     return undefined;
 }
+function readBooleanParam(params, key) {
+    const value = params[key];
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        const trimmed = value.trim().toLowerCase();
+        if (trimmed === "true")
+            return true;
+        if (trimmed === "false")
+            return false;
+    }
+    return undefined;
+}
 function parseInlineId(raw, label) {
-    if (typeof raw === "bigint")
+    if (typeof raw === "bigint") {
+        if (raw < 0n) {
+            throw new Error(`inline action: invalid ${label} "${raw.toString()}"`);
+        }
         return raw;
+    }
     if (typeof raw === "number") {
-        if (!Number.isFinite(raw) || !Number.isInteger(raw)) {
+        if (!Number.isFinite(raw) || !Number.isInteger(raw) || raw < 0) {
             throw new Error(`inline action: invalid ${label} "${String(raw)}"`);
         }
         return BigInt(raw);
@@ -62,6 +103,149 @@ function parseOptionalInlineId(raw, label) {
         return undefined;
     return parseInlineId(raw, label);
 }
+function parseInlineIdList(raw, label) {
+    if (raw == null)
+        return [];
+    if (Array.isArray(raw)) {
+        return raw.map((item) => parseInlineId(item, label));
+    }
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return [];
+        const chunks = trimmed
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+        if (chunks.length <= 1) {
+            return [parseInlineId(trimmed, label)];
+        }
+        return chunks.map((item) => parseInlineId(item, label));
+    }
+    return [parseInlineId(raw, label)];
+}
+function parseInlineIdListFromParams(params, key) {
+    const direct = params[key];
+    if (direct != null) {
+        return parseInlineIdList(direct, key);
+    }
+    return [];
+}
+function parseInlineListValue(raw, label) {
+    if (raw == null)
+        return [];
+    if (Array.isArray(raw)) {
+        return raw.flatMap((entry) => parseInlineListValue(entry, label));
+    }
+    if (typeof raw === "bigint")
+        return [raw.toString()];
+    if (typeof raw === "number") {
+        if (!Number.isFinite(raw) || !Number.isInteger(raw) || raw < 0) {
+            throw new Error(`inline action: invalid ${label} "${String(raw)}"`);
+        }
+        return [String(raw)];
+    }
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return [];
+        return trimmed
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    throw new Error(`inline action: invalid ${label}`);
+}
+function parseInlineListValuesFromParams(params, keys) {
+    const entries = keys.flatMap((key) => parseInlineListValue(params[key], key));
+    return Array.from(new Set(entries.map((entry) => entry.trim()).filter(Boolean)));
+}
+function normalizeInlineUserLookupToken(raw) {
+    return raw
+        .trim()
+        .replace(/^inline:/i, "")
+        .replace(/^user:/i, "")
+        .replace(/^@/, "")
+        .trim();
+}
+function parseInlineIdIfNumericToken(raw) {
+    const normalized = normalizeInlineUserLookupToken(raw);
+    if (!/^[0-9]+$/.test(normalized))
+        return undefined;
+    return BigInt(normalized);
+}
+function buildInlineUserHaystack(user) {
+    return [
+        String(user.id),
+        buildInlineUserDisplayName(user),
+        user.firstName ?? "",
+        user.lastName ?? "",
+        user.username ?? "",
+    ]
+        .join("\n")
+        .toLowerCase();
+}
+function resolveInlineUsersByToken(params) {
+    const normalized = normalizeInlineUserLookupToken(params.token);
+    if (!normalized)
+        return [];
+    const lowered = normalized.toLowerCase();
+    const numericId = parseInlineIdIfNumericToken(normalized);
+    if (numericId != null) {
+        return params.users.filter((user) => user.id === numericId);
+    }
+    const byUsername = params.users.filter((user) => (user.username ?? "").trim().toLowerCase() === lowered);
+    if (byUsername.length > 0) {
+        return byUsername;
+    }
+    const byExactName = params.users.filter((user) => buildInlineUserDisplayName(user).trim().toLowerCase() === lowered);
+    if (byExactName.length > 0) {
+        return byExactName;
+    }
+    return params.users.filter((user) => buildInlineUserHaystack(user).includes(lowered));
+}
+async function fetchInlineUsersForResolution(client) {
+    const result = await client.invokeRaw(Method.GET_CHATS, {
+        oneofKind: "getChats",
+        getChats: {},
+    });
+    if (result.oneofKind !== "getChats") {
+        throw new Error(`inline action: expected getChats result, got ${String(result.oneofKind)}`);
+    }
+    return result.getChats.users ?? [];
+}
+async function resolveInlineUserIdsFromParams(params) {
+    if (params.values.length === 0)
+        return [];
+    const resolved = [];
+    const unresolved = [];
+    for (const value of params.values) {
+        const numericId = parseInlineIdIfNumericToken(value);
+        if (numericId != null) {
+            resolved.push(numericId);
+            continue;
+        }
+        unresolved.push(value);
+    }
+    if (unresolved.length > 0) {
+        const users = await fetchInlineUsersForResolution(params.client);
+        for (const token of unresolved) {
+            const matches = resolveInlineUsersByToken({ users, token });
+            if (matches.length === 0) {
+                throw new Error(`inline action: could not resolve ${params.label} "${token}"`);
+            }
+            if (matches.length > 1) {
+                throw new Error(`inline action: ambiguous ${params.label} "${token}"`);
+            }
+            const match = matches[0];
+            if (!match) {
+                throw new Error(`inline action: could not resolve ${params.label} "${token}"`);
+            }
+            resolved.push(match.id);
+        }
+    }
+    return Array.from(new Set(resolved.map((id) => id.toString()))).map((id) => BigInt(id));
+}
 function resolveChatIdFromParams(params) {
     const raw = readFlexibleId(params, "chatId") ??
         readFlexibleId(params, "channelId") ??
@@ -80,6 +264,15 @@ function buildChatPeer(chatId) {
         },
     };
 }
+function buildInlineUserDisplayName(user) {
+    const explicit = [user.firstName?.trim(), user.lastName?.trim()].filter(Boolean).join(" ");
+    if (explicit)
+        return explicit;
+    const username = user.username?.trim();
+    if (username)
+        return `@${username}`;
+    return "Unknown";
+}
 function mapMessage(message) {
     const reactions = (message.reactions?.reactions ?? []).map((reaction) => ({
         emoji: reaction.emoji ?? "",
@@ -98,19 +291,52 @@ function mapMessage(message) {
         reactions,
     };
 }
+function mapChatEntry(params) {
+    const dialog = params.dialogByChatId.get(String(params.chat.id));
+    const peer = params.chat.peerId?.type;
+    let peerUser = null;
+    if (peer?.oneofKind === "user") {
+        peerUser = params.usersById.get(String(peer.user.userId)) ?? null;
+    }
+    return {
+        id: String(params.chat.id),
+        title: params.chat.title,
+        spaceId: params.chat.spaceId != null ? String(params.chat.spaceId) : null,
+        isPublic: params.chat.isPublic ?? false,
+        createdBy: params.chat.createdBy != null ? String(params.chat.createdBy) : null,
+        date: params.chat.date != null ? Number(params.chat.date) * 1000 : null,
+        unreadCount: dialog?.unreadCount ?? 0,
+        archived: Boolean(dialog?.archived),
+        pinned: Boolean(dialog?.pinned),
+        peer: peer?.oneofKind === "user"
+            ? {
+                kind: "user",
+                id: String(peer.user.userId),
+                username: peerUser?.username ?? null,
+                name: peerUser ? buildInlineUserDisplayName(peerUser) : null,
+            }
+            : peer?.oneofKind === "chat"
+                ? { kind: "chat", id: String(peer.chat.chatId) }
+                : null,
+    };
+}
+function mapSpaceMemberRole(role) {
+    if (role == null)
+        return null;
+    if (role === Member_Role.OWNER)
+        return "owner";
+    if (role === Member_Role.ADMIN)
+        return "admin";
+    if (role === Member_Role.MEMBER)
+        return "member";
+    return null;
+}
 async function loadMessageReactions(params) {
-    const result = await params.client.invokeRaw(Method.GET_CHAT_HISTORY, {
-        oneofKind: "getChatHistory",
-        getChatHistory: {
-            peerId: buildChatPeer(params.chatId),
-            offsetId: params.messageId + 1n,
-            limit: 8,
-        },
+    const target = await findMessageById({
+        client: params.client,
+        chatId: params.chatId,
+        messageId: params.messageId,
     });
-    if (result.oneofKind !== "getChatHistory") {
-        throw new Error(`inline action: expected getChatHistory result, got ${String(result.oneofKind)}`);
-    }
-    const target = (result.getChatHistory.messages ?? []).find((message) => message.id === params.messageId) ?? null;
     if (!target) {
         return [];
     }
@@ -133,6 +359,32 @@ async function loadMessageReactions(params) {
     }
     return Array.from(byEmoji.values());
 }
+async function findMessageById(params) {
+    const directResult = await params.client
+        .invokeRaw(Method.GET_MESSAGES, {
+        oneofKind: "getMessages",
+        getMessages: {
+            peerId: buildChatPeer(params.chatId),
+            messageIds: [params.messageId],
+        },
+    })
+        .catch(() => null);
+    if (directResult?.oneofKind === "getMessages") {
+        return (directResult.getMessages.messages ?? []).find((message) => message.id === params.messageId) ?? null;
+    }
+    const result = await params.client.invokeRaw(Method.GET_CHAT_HISTORY, {
+        oneofKind: "getChatHistory",
+        getChatHistory: {
+            peerId: buildChatPeer(params.chatId),
+            offsetId: params.messageId + 1n,
+            limit: 8,
+        },
+    });
+    if (result.oneofKind !== "getChatHistory") {
+        throw new Error(`inline action: expected getChatHistory result, got ${String(result.oneofKind)}`);
+    }
+    return (result.getChatHistory.messages ?? []).find((message) => message.id === params.messageId) ?? null;
+}
 async function withInlineClient(params) {
     const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
     if (!account.configured || !account.baseUrl) {
@@ -165,14 +417,68 @@ function toJsonSafe(value) {
     }
     return value;
 }
+function buildDialogMap(dialogs) {
+    const map = new Map();
+    for (const dialog of dialogs) {
+        const chatId = dialog.chatId;
+        if (chatId != null) {
+            map.set(String(chatId), dialog);
+            continue;
+        }
+        const peer = dialog.peer?.type;
+        if (peer?.oneofKind === "chat") {
+            map.set(String(peer.chat.chatId), dialog);
+        }
+    }
+    return map;
+}
+function buildUserMap(users) {
+    const map = new Map();
+    for (const user of users) {
+        map.set(String(user.id), user);
+    }
+    return map;
+}
+function listAllActions() {
+    const out = new Set();
+    for (const group of ACTION_GROUPS) {
+        for (const action of group.actions) {
+            out.add(action);
+        }
+    }
+    return Array.from(out);
+}
+function isActionEnabled(params) {
+    const key = ACTION_TO_GATE_KEY.get(params.action);
+    if (!key)
+        return false;
+    const group = ACTION_GROUPS.find((item) => item.key === key);
+    if (!group)
+        return false;
+    const account = resolveInlineAccount({
+        cfg: params.cfg,
+        accountId: params.accountId ?? null,
+    });
+    const gate = createActionGate((account.config.actions ?? {}));
+    return gate(key, group.defaultEnabled);
+}
 export const inlineMessageActions = {
     listActions: ({ cfg }) => {
         const account = resolveInlineAccount({ cfg, accountId: null });
         if (!account.enabled || !account.configured)
             return [];
-        return [...ACTIONS];
+        const gate = createActionGate((account.config.actions ?? {}));
+        const actions = new Set();
+        for (const group of ACTION_GROUPS) {
+            if (!gate(group.key, group.defaultEnabled))
+                continue;
+            for (const action of group.actions) {
+                actions.add(action);
+            }
+        }
+        return Array.from(actions);
     },
-    supportsAction: ({ action }) => ACTIONS.includes(action),
+    supportsAction: ({ action }) => SUPPORTED_ACTIONS.includes(action),
     extractToolSend: ({ args }) => {
         const action = typeof args.action === "string" ? args.action.trim() : "";
         if (action !== "sendMessage")
@@ -186,7 +492,14 @@ export const inlineMessageActions = {
         return { to: normalized };
     },
     handleAction: async ({ action, params, cfg, accountId }) => {
-        if (action === "reply") {
+        if (!SUPPORTED_ACTIONS.includes(action)) {
+            throw new Error(`Action ${action} is not supported for provider inline.`);
+        }
+        if (!isActionEnabled({ cfg, accountId: accountId ?? null, action })) {
+            throw new Error(`inline action: ${action} is disabled by channels.inline.actions`);
+        }
+        const normalizedAction = action;
+        if (normalizedAction === "reply") {
             const parseMarkdown = resolveInlineAccount({ cfg, accountId: accountId ?? null }).config.parseMarkdown ?? true;
             return await withInlineClient({
                 cfg,
@@ -216,13 +529,14 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "react") {
+        if (normalizedAction === "react") {
             return await withInlineClient({
                 cfg,
                 accountId,
                 fn: async (client) => {
                     const chatId = resolveChatIdFromParams(params);
-                    const messageId = parseInlineId(readFlexibleId(params, "messageId") ?? readStringParam(params, "messageId", { required: true }), "messageId");
+                    const messageId = parseInlineId(readFlexibleId(params, "messageId") ??
+                        readStringParam(params, "messageId", { required: true }), "messageId");
                     const { emoji, remove, isEmpty } = readReactionParams(params, {
                         removeErrorMessage: "Emoji is required to remove an Inline reaction.",
                     });
@@ -265,13 +579,14 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "reactions") {
+        if (normalizedAction === "reactions") {
             return await withInlineClient({
                 cfg,
                 accountId,
                 fn: async (client) => {
                     const chatId = resolveChatIdFromParams(params);
-                    const messageId = parseInlineId(readFlexibleId(params, "messageId") ?? readStringParam(params, "messageId", { required: true }), "messageId");
+                    const messageId = parseInlineId(readFlexibleId(params, "messageId") ??
+                        readStringParam(params, "messageId", { required: true }), "messageId");
                     const reactions = await loadMessageReactions({
                         client,
                         chatId,
@@ -286,7 +601,7 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "read") {
+        if (normalizedAction === "read") {
             return await withInlineClient({
                 cfg,
                 accountId,
@@ -313,7 +628,7 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "search") {
+        if (normalizedAction === "search") {
             return await withInlineClient({
                 cfg,
                 accountId,
@@ -345,13 +660,14 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "edit") {
+        if (normalizedAction === "edit") {
             return await withInlineClient({
                 cfg,
                 accountId,
                 fn: async (client) => {
                     const chatId = resolveChatIdFromParams(params);
-                    const messageId = parseInlineId(readFlexibleId(params, "messageId") ?? readStringParam(params, "messageId", { required: true }), "messageId");
+                    const messageId = parseInlineId(readFlexibleId(params, "messageId") ??
+                        readStringParam(params, "messageId", { required: true }), "messageId");
                     const text = readStringParam(params, "message", { required: true, allowEmpty: true });
                     const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
                         oneofKind: "editMessage",
@@ -368,7 +684,7 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "channel-info") {
+        if (normalizedAction === "channel-info") {
             return await withInlineClient({
                 cfg,
                 accountId,
@@ -391,7 +707,7 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "channel-edit") {
+        if (normalizedAction === "channel-edit") {
             return await withInlineClient({
                 cfg,
                 accountId,
@@ -399,6 +715,7 @@ export const inlineMessageActions = {
                     const chatId = resolveChatIdFromParams(params);
                     const title = readStringParam(params, "title") ??
                         readStringParam(params, "name") ??
+                        readStringParam(params, "threadName") ??
                         readStringParam(params, "message", { required: true });
                     const result = await client.invokeRaw(Method.UPDATE_CHAT_INFO, {
                         oneofKind: "updateChatInfo",
@@ -419,16 +736,186 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "addParticipant") {
+        if (normalizedAction === "channel-list" || normalizedAction === "thread-list") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const query = readStringParam(params, "query") ??
+                        readStringParam(params, "q") ??
+                        undefined;
+                    const limit = Math.max(1, Math.min(200, readNumberParam(params, "limit", { integer: true }) ?? 50));
+                    const result = await client.invokeRaw(Method.GET_CHATS, {
+                        oneofKind: "getChats",
+                        getChats: {},
+                    });
+                    if (result.oneofKind !== "getChats") {
+                        throw new Error(`inline action: expected getChats result, got ${String(result.oneofKind)}`);
+                    }
+                    const dialogByChatId = buildDialogMap(result.getChats.dialogs ?? []);
+                    const usersById = buildUserMap(result.getChats.users ?? []);
+                    const entries = (result.getChats.chats ?? []).map((chat) => mapChatEntry({ chat, dialogByChatId, usersById }));
+                    const normalizedQuery = query?.trim().toLowerCase() ?? "";
+                    const filtered = normalizedQuery
+                        ? entries.filter((entry) => {
+                            const haystack = [
+                                entry.id,
+                                entry.title,
+                                entry.peer?.kind === "user" ? entry.peer.username ?? "" : "",
+                                entry.peer?.kind === "user" ? entry.peer.name ?? "" : "",
+                            ]
+                                .join("\n")
+                                .toLowerCase();
+                            return haystack.includes(normalizedQuery);
+                        })
+                        : entries;
+                    return jsonResult(toJsonSafe({
+                        ok: true,
+                        query: query ?? null,
+                        count: filtered.length,
+                        chats: filtered.slice(0, limit),
+                    }));
+                },
+            });
+        }
+        if (normalizedAction === "channel-create" || normalizedAction === "thread-create") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const title = readStringParam(params, "title") ??
+                        readStringParam(params, "name") ??
+                        readStringParam(params, "threadName") ??
+                        readStringParam(params, "message", { required: true });
+                    const description = readStringParam(params, "description");
+                    const emoji = readStringParam(params, "emoji");
+                    const spaceId = parseOptionalInlineId(readFlexibleId(params, "spaceId") ?? readFlexibleId(params, "space"), "spaceId");
+                    const isPublic = readBooleanParam(params, "isPublic") ?? false;
+                    const participantRefs = parseInlineListValuesFromParams(params, [
+                        "participants",
+                        "participantIds",
+                        "participantId",
+                        "participant",
+                        "userIds",
+                        "userId",
+                    ]);
+                    const dedupedParticipants = await resolveInlineUserIdsFromParams({
+                        client,
+                        values: participantRefs,
+                        label: "participant",
+                    });
+                    const result = await client.invokeRaw(Method.CREATE_CHAT, {
+                        oneofKind: "createChat",
+                        createChat: {
+                            title,
+                            ...(spaceId != null ? { spaceId } : {}),
+                            ...(description ? { description } : {}),
+                            ...(emoji ? { emoji } : {}),
+                            isPublic,
+                            participants: isPublic ? [] : dedupedParticipants.map((userId) => ({ userId })),
+                        },
+                    });
+                    if (result.oneofKind !== "createChat") {
+                        throw new Error(`inline action: expected createChat result, got ${String(result.oneofKind)}`);
+                    }
+                    return jsonResult(toJsonSafe({
+                        ok: true,
+                        title,
+                        spaceId: spaceId != null ? String(spaceId) : null,
+                        isPublic,
+                        participants: dedupedParticipants.map((id) => String(id)),
+                        chat: result.createChat.chat ?? null,
+                        dialog: result.createChat.dialog ?? null,
+                    }));
+                },
+            });
+        }
+        if (normalizedAction === "channel-delete") {
             return await withInlineClient({
                 cfg,
                 accountId,
                 fn: async (client) => {
                     const chatId = resolveChatIdFromParams(params);
-                    const userId = parseInlineId(readFlexibleId(params, "userId") ??
-                        readFlexibleId(params, "participant") ??
-                        readFlexibleId(params, "memberId") ??
-                        readStringParam(params, "userId", { required: true }), "userId");
+                    const result = await client.invokeRaw(Method.DELETE_CHAT, {
+                        oneofKind: "deleteChat",
+                        deleteChat: {
+                            peerId: buildChatPeer(chatId),
+                        },
+                    });
+                    if (result.oneofKind !== "deleteChat") {
+                        throw new Error(`inline action: expected deleteChat result, got ${String(result.oneofKind)}`);
+                    }
+                    return jsonResult({
+                        ok: true,
+                        chatId: String(chatId),
+                    });
+                },
+            });
+        }
+        if (normalizedAction === "channel-move") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const rawSpace = readStringParam(params, "spaceId") ?? readStringParam(params, "toSpaceId");
+                    const normalizedSpace = rawSpace?.trim().toLowerCase();
+                    const moveToHome = normalizedSpace === "" ||
+                        normalizedSpace === "home" ||
+                        normalizedSpace === "none" ||
+                        normalizedSpace === "null";
+                    const parsedSpace = moveToHome
+                        ? undefined
+                        : parseOptionalInlineId(readFlexibleId(params, "spaceId") ?? readFlexibleId(params, "toSpaceId"), "spaceId");
+                    const result = await client.invokeRaw(Method.MOVE_THREAD, {
+                        oneofKind: "moveThread",
+                        moveThread: {
+                            chatId,
+                            ...(parsedSpace != null ? { spaceId: parsedSpace } : {}),
+                        },
+                    });
+                    if (result.oneofKind !== "moveThread") {
+                        throw new Error(`inline action: expected moveThread result, got ${String(result.oneofKind)}`);
+                    }
+                    return jsonResult(toJsonSafe({
+                        ok: true,
+                        chatId: String(chatId),
+                        spaceId: parsedSpace != null ? String(parsedSpace) : null,
+                        chat: result.moveThread.chat ?? null,
+                    }));
+                },
+            });
+        }
+        if (normalizedAction === "addParticipant") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const participantRefs = parseInlineListValuesFromParams(params, [
+                        "userId",
+                        "participant",
+                        "participantId",
+                        "memberId",
+                    ]);
+                    if (participantRefs.length === 0) {
+                        readStringParam(params, "userId", { required: true });
+                    }
+                    const participantIds = await resolveInlineUserIdsFromParams({
+                        client,
+                        values: participantRefs,
+                        label: "user",
+                    });
+                    if (participantIds.length === 0) {
+                        throw new Error("inline action: missing user");
+                    }
+                    if (participantIds.length > 1) {
+                        throw new Error("inline action: addParticipant accepts exactly one user");
+                    }
+                    const userId = participantIds[0];
+                    if (!userId) {
+                        throw new Error("inline action: missing user");
+                    }
                     const result = await client.invokeRaw(Method.ADD_CHAT_PARTICIPANT, {
                         oneofKind: "addChatParticipant",
                         addChatParticipant: {
@@ -448,13 +935,89 @@ export const inlineMessageActions = {
                 },
             });
         }
-        if (action === "member-info") {
+        if (normalizedAction === "removeParticipant") {
             return await withInlineClient({
                 cfg,
                 accountId,
                 fn: async (client) => {
                     const chatId = resolveChatIdFromParams(params);
-                    const userId = parseInlineId(readFlexibleId(params, "userId") ?? readStringParam(params, "userId", { required: true }), "userId");
+                    const participantRefs = parseInlineListValuesFromParams(params, [
+                        "userId",
+                        "participant",
+                        "participantId",
+                        "memberId",
+                    ]);
+                    if (participantRefs.length === 0) {
+                        readStringParam(params, "userId", { required: true });
+                    }
+                    const participantIds = await resolveInlineUserIdsFromParams({
+                        client,
+                        values: participantRefs,
+                        label: "user",
+                    });
+                    if (participantIds.length === 0) {
+                        throw new Error("inline action: missing user");
+                    }
+                    if (participantIds.length > 1) {
+                        throw new Error("inline action: removeParticipant accepts exactly one user");
+                    }
+                    const userId = participantIds[0];
+                    if (!userId) {
+                        throw new Error("inline action: missing user");
+                    }
+                    const result = await client.invokeRaw(Method.REMOVE_CHAT_PARTICIPANT, {
+                        oneofKind: "removeChatParticipant",
+                        removeChatParticipant: {
+                            chatId,
+                            userId,
+                        },
+                    });
+                    if (result.oneofKind !== "removeChatParticipant") {
+                        throw new Error(`inline action: expected removeChatParticipant result, got ${String(result.oneofKind)}`);
+                    }
+                    return jsonResult({
+                        ok: true,
+                        chatId: String(chatId),
+                        userId: String(userId),
+                    });
+                },
+            });
+        }
+        if (normalizedAction === "leaveGroup") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const me = await client.getMe();
+                    const userId = me.userId;
+                    const result = await client.invokeRaw(Method.REMOVE_CHAT_PARTICIPANT, {
+                        oneofKind: "removeChatParticipant",
+                        removeChatParticipant: {
+                            chatId,
+                            userId,
+                        },
+                    });
+                    if (result.oneofKind !== "removeChatParticipant") {
+                        throw new Error(`inline action: expected removeChatParticipant result, got ${String(result.oneofKind)}`);
+                    }
+                    return jsonResult({
+                        ok: true,
+                        chatId: String(chatId),
+                        userId: String(userId),
+                        left: true,
+                    });
+                },
+            });
+        }
+        if (normalizedAction === "member-info") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const userId = parseInlineId(readFlexibleId(params, "userId") ??
+                        readStringParam(params, "userId", { required: true }), "userId");
                     const result = await client.invokeRaw(Method.GET_CHAT_PARTICIPANTS, {
                         oneofKind: "getChatParticipants",
                         getChatParticipants: { chatId },
@@ -474,7 +1037,180 @@ export const inlineMessageActions = {
                 },
             });
         }
+        if (normalizedAction === "delete" || normalizedAction === "unsend") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const messageIds = [
+                        ...parseInlineIdListFromParams(params, "messageIds"),
+                        ...parseInlineIdListFromParams(params, "messages"),
+                        ...parseInlineIdListFromParams(params, "ids"),
+                    ];
+                    if (messageIds.length === 0) {
+                        messageIds.push(parseInlineId(readFlexibleId(params, "messageId") ??
+                            readStringParam(params, "messageId", { required: true }), "messageId"));
+                    }
+                    const deduped = Array.from(new Set(messageIds.map((id) => id.toString()))).map((id) => BigInt(id));
+                    const result = await client.invokeRaw(Method.DELETE_MESSAGES, {
+                        oneofKind: "deleteMessages",
+                        deleteMessages: {
+                            peerId: buildChatPeer(chatId),
+                            messageIds: deduped,
+                        },
+                    });
+                    if (result.oneofKind !== "deleteMessages") {
+                        throw new Error(`inline action: expected deleteMessages result, got ${String(result.oneofKind)}`);
+                    }
+                    return jsonResult({
+                        ok: true,
+                        chatId: String(chatId),
+                        messageIds: deduped.map((id) => String(id)),
+                    });
+                },
+            });
+        }
+        if (normalizedAction === "pin" || normalizedAction === "unpin") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const messageId = parseInlineId(readFlexibleId(params, "messageId") ??
+                        readStringParam(params, "messageId", { required: true }), "messageId");
+                    const unpin = normalizedAction === "unpin" || readBooleanParam(params, "unpin") === true;
+                    const result = await client.invokeRaw(Method.PIN_MESSAGE, {
+                        oneofKind: "pinMessage",
+                        pinMessage: {
+                            peerId: buildChatPeer(chatId),
+                            messageId,
+                            unpin,
+                        },
+                    });
+                    if (result.oneofKind !== "pinMessage") {
+                        throw new Error(`inline action: expected pinMessage result, got ${String(result.oneofKind)}`);
+                    }
+                    return jsonResult({
+                        ok: true,
+                        chatId: String(chatId),
+                        messageId: String(messageId),
+                        unpin,
+                    });
+                },
+            });
+        }
+        if (normalizedAction === "list-pins") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const result = await client.invokeRaw(Method.GET_CHAT, {
+                        oneofKind: "getChat",
+                        getChat: { peerId: buildChatPeer(chatId) },
+                    });
+                    if (result.oneofKind !== "getChat") {
+                        throw new Error(`inline action: expected getChat result, got ${String(result.oneofKind)}`);
+                    }
+                    const pinnedMessageIds = (result.getChat.pinnedMessageIds ?? []).map((id) => String(id));
+                    return jsonResult({
+                        ok: true,
+                        chatId: String(chatId),
+                        pinnedMessageIds,
+                    });
+                },
+            });
+        }
+        if (normalizedAction === "permissions") {
+            return await withInlineClient({
+                cfg,
+                accountId,
+                fn: async (client) => {
+                    const chatId = resolveChatIdFromParams(params);
+                    const chatResult = await client.invokeRaw(Method.GET_CHAT, {
+                        oneofKind: "getChat",
+                        getChat: { peerId: buildChatPeer(chatId) },
+                    });
+                    if (chatResult.oneofKind !== "getChat") {
+                        throw new Error(`inline action: expected getChat result, got ${String(chatResult.oneofKind)}`);
+                    }
+                    const spaceId = chatResult.getChat.chat?.spaceId ?? chatResult.getChat.dialog?.spaceId;
+                    if (spaceId == null) {
+                        throw new Error("inline action: permissions requires a chat that belongs to a space");
+                    }
+                    const userIdRaw = readFlexibleId(params, "userId") ??
+                        readFlexibleId(params, "memberId") ??
+                        readStringParam(params, "userId");
+                    const userId = userIdRaw ? parseInlineId(userIdRaw, "userId") : undefined;
+                    const roleValue = readStringParam(params, "role")?.trim().toLowerCase();
+                    const canAccessPublicChats = readBooleanParam(params, "canAccessPublicChats");
+                    if (userId != null && roleValue) {
+                        const role = roleValue === "admin"
+                            ? { role: { oneofKind: "admin", admin: {} } }
+                            : roleValue === "member"
+                                ? {
+                                    role: {
+                                        oneofKind: "member",
+                                        member: {
+                                            canAccessPublicChats: canAccessPublicChats ?? true,
+                                        },
+                                    },
+                                }
+                                : null;
+                        if (!role) {
+                            throw new Error("inline action: role must be \"admin\" or \"member\"");
+                        }
+                        const updateResult = await client.invokeRaw(Method.UPDATE_MEMBER_ACCESS, {
+                            oneofKind: "updateMemberAccess",
+                            updateMemberAccess: {
+                                spaceId,
+                                userId,
+                                role,
+                            },
+                        });
+                        if (updateResult.oneofKind !== "updateMemberAccess") {
+                            throw new Error(`inline action: expected updateMemberAccess result, got ${String(updateResult.oneofKind)}`);
+                        }
+                    }
+                    const membersResult = await client.invokeRaw(Method.GET_SPACE_MEMBERS, {
+                        oneofKind: "getSpaceMembers",
+                        getSpaceMembers: {
+                            spaceId,
+                        },
+                    });
+                    if (membersResult.oneofKind !== "getSpaceMembers") {
+                        throw new Error(`inline action: expected getSpaceMembers result, got ${String(membersResult.oneofKind)}`);
+                    }
+                    const usersById = buildUserMap(membersResult.getSpaceMembers.users ?? []);
+                    const members = (membersResult.getSpaceMembers.members ?? []).map((member) => {
+                        const linkedUser = usersById.get(String(member.userId));
+                        return {
+                            userId: String(member.userId),
+                            role: mapSpaceMemberRole(member.role),
+                            canAccessPublicChats: member.canAccessPublicChats,
+                            date: Number(member.date) * 1000,
+                            user: linkedUser
+                                ? {
+                                    id: String(linkedUser.id),
+                                    name: buildInlineUserDisplayName(linkedUser),
+                                    username: linkedUser.username ?? null,
+                                }
+                                : null,
+                        };
+                    });
+                    const filteredMembers = userId != null ? members.filter((member) => member.userId === String(userId)) : members;
+                    return jsonResult(toJsonSafe({
+                        ok: true,
+                        chatId: String(chatId),
+                        spaceId: String(spaceId),
+                        members: filteredMembers,
+                    }));
+                },
+            });
+        }
         throw new Error(`Action ${action} is not supported for provider inline.`);
     },
 };
+export const inlineSupportedActions = listAllActions();
 //# sourceMappingURL=actions.js.map