@ozaiya/openclaw-channel 0.5.0 → 0.7.0

package/dist/src/channel.js

@@ -8,9 +8,9 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { registerPluginHttpRoute } from "openclaw/plugin-sdk";
-import { unwrapGroupKey, decryptMessage, encryptMessage } from "./crypto.js";
-import { sendMessage, probeApi, fetchGroups, toggleReaction, editMessage, deleteMessage, pinMessage, unpinMessage, uploadFile, searchUsers, fetchLinkPreview, } from "./api.js";
-import { botCreateDirect } from "./botActions.js";
+import { unwrapGroupKey, decryptMessage, encryptMessage, wrapGroupKey } from "./crypto.js";
+import { sendMessage, probeApi, fetchGroups, addMember, getUserPublicKeys, toggleReaction, editMessage, deleteMessage, pinMessage, unpinMessage, uploadFile, searchUsers, fetchLinkPreview, joinCall, leaveCall, } from "./api.js";
+import { botCreateDirect, botCreateGroup } from "./botActions.js";
 import { buildInlineKeyboardSummary, buildLinkPreviewSummary, normalizeMessageText, normalizeToolInlineKeyboardRows, } from "./richContent.js";
 import { normalizeCallbackQueryPayload } from "./callbackQuery.js";
 import { enrichOutgoingMessageContent } from "./messageEnrichment.js";
@@ -18,6 +18,7 @@ import { createOzaiyaWebhookHandler } from "./webhook.js";
 import { getOzaiyaRuntime } from "./runtime.js";
 import { maybeTranscribeInboundAudio, prependVoiceTranscriptToAgentInput, resolveOzaiyaSttConfig, } from "./transcribeAudio.js";
 import { startGatewayMode } from "./gateway.js";
+import { VoiceCallSession } from "./voiceCall.js";
 const DEFAULT_API_BASE_URL = "https://api.ozai.dev";
 const DEFAULT_WEBHOOK_PATH = "/ozaiya/webhook";
 const DEFAULT_ACCOUNT_ID = "default";
@@ -29,6 +30,8 @@ const RICH_MESSAGE_GUIDANCE = "Prefer plain text for normal prose, code, markdow
     "and attachments when sending generated files. Standalone media/file URLs, markdown images, and markdown attachment links in plain text replies are auto-uploaded.";
 // In-memory cache of unwrapped group keys (groupId → Uint8Array)
 const unwrappedKeys = new Map();
+// Active voice call sessions keyed by callId
+const activeVoiceCalls = new Map();
 // Runtime state tracking
 const runtimeState = new Map();
 function recordState(accountId, patch) {
@@ -614,6 +617,14 @@ export const ozaiyaPlugin = {
             createScheduleMessageTool(account),
             createSendDirectMessageTool(account),
             createSendRichMessageTool(account),
+            createCreateGroupTool(account),
+            createInviteMemberTool(account),
+            createReactTool(account),
+            createEditMessageTool(account),
+            createDeleteMessageTool(account),
+            createPinMessageTool(account),
+            createSearchUsersTool(account),
+            createListGroupsTool(account),
         ];
     }),
     gateway: {
@@ -654,6 +665,12 @@ export const ozaiyaPlugin = {
                                 else if (payload.event === "session.reset") {
                                     await handleSessionReset(payload, botCtx);
                                 }
+                                else if (payload.event === "call.started") {
+                                    await handleCallStarted(payload, botCtx);
+                                }
+                                else if (payload.event === "call.ended") {
+                                    await handleCallEnded(payload, botCtx);
+                                }
                             },
                         }),
                     });
@@ -689,6 +706,37 @@ export const ozaiyaPlugin = {
                             startBotHandler(botAccount);
                         }
                     },
+                    onWebhookEvent: (botId, payload) => {
+                        const botAccount = gatewayBotAccounts.get(botId);
+                        if (!botAccount)
+                            return;
+                        const botCtx = { ...ctx, account: botAccount };
+                        if (payload.event === "message.new") {
+                            handleInboundMessage(payload, botCtx).catch((err) => {
+                                ctx.log?.warn?.(`[${botId}] Socket.io webhook error: ${String(err)}`);
+                            });
+                        }
+                        else if (payload.event === "callback_query") {
+                            handleCallbackQuery(payload, botCtx).catch((err) => {
+                                ctx.log?.warn?.(`[${botId}] Socket.io callback_query error: ${String(err)}`);
+                            });
+                        }
+                        else if (payload.event === "session.reset") {
+                            handleSessionReset(payload, botCtx).catch((err) => {
+                                ctx.log?.warn?.(`[${botId}] Socket.io session.reset error: ${String(err)}`);
+                            });
+                        }
+                        else if (payload.event === "call.started") {
+                            handleCallStarted(payload, botCtx).catch((err) => {
+                                ctx.log?.warn?.(`[${botId}] Socket.io call.started error: ${String(err)}`);
+                            });
+                        }
+                        else if (payload.event === "call.ended") {
+                            handleCallEnded(payload, botCtx).catch((err) => {
+                                ctx.log?.warn?.(`[${botId}] Socket.io call.ended error: ${String(err)}`);
+                            });
+                        }
+                    },
                     log: {
                         info: (msg) => ctx.log?.info(msg),
                         warn: (msg) => ctx.log?.warn?.(msg),
@@ -698,6 +746,11 @@ export const ozaiyaPlugin = {
                 for (const unregister of botUnregisters.values())
                     unregister();
                 botUnregisters.clear();
+                // Disconnect all active voice call sessions
+                for (const [callId, session] of activeVoiceCalls) {
+                    session.disconnect().catch(() => { });
+                    activeVoiceCalls.delete(callId);
+                }
                 for (const id of gatewayBotAccounts.keys()) {
                     recordState(id, { running: false, lastStopAt: Date.now() });
                 }
@@ -1079,6 +1132,299 @@ function createSendRichMessageTool(account) {
         },
     };
 }
+function createCreateGroupTool(account) {
+    return {
+        label: "Create Group",
+        name: "create_group",
+        ownerOnly: false,
+        description: "Create a new Ozaiya group chat and optionally invite members by their Ozaiya ID or account ID. " +
+            "Returns the groupId and groupCode. The bot is automatically added as the group owner.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "The group name.",
+                },
+                memberIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional list of user Ozaiya IDs or account IDs to invite to the group.",
+                },
+            },
+            required: ["name"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const groupName = args.name?.trim();
+                if (!groupName) {
+                    return { content: [{ type: "text", text: "Error: group name is required." }] };
+                }
+                // Resolve ozaiyaIds to account IDs
+                let accountIds;
+                if (args.memberIds && args.memberIds.length > 0) {
+                    accountIds = [];
+                    for (const id of args.memberIds) {
+                        const users = await searchUsers(account.apiBaseUrl, account.botToken, id).catch(() => []);
+                        const match = users.find((u) => u.ozaiyaId === id) ?? users[0];
+                        accountIds.push(match ? match.id : id);
+                    }
+                }
+                const { groupId, groupCode, groupKey } = await botCreateGroup({
+                    apiBaseUrl: account.apiBaseUrl,
+                    botToken: account.botToken,
+                    botPrivateKey: account.botPrivateKey,
+                    webhookSecret: account.webhookSecret,
+                }, groupName, accountIds);
+                // Cache the group key for immediate message sending
+                unwrappedKeys.set(groupId, groupKey);
+                const memberInfo = accountIds?.length
+                    ? `, invited ${accountIds.length} member(s)`
+                    : "";
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Group "${groupName}" created (groupId: ${groupId}, groupCode: ${groupCode}${memberInfo}).`,
+                        }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
+function createInviteMemberTool(account) {
+    return {
+        label: "Invite Member",
+        name: "invite_member",
+        ownerOnly: false,
+        description: "Invite a user to an existing group chat by their Ozaiya ID or account ID. " +
+            "The bot must be a member of the group and have the group key cached.",
+        parameters: {
+            type: "object",
+            properties: {
+                groupId: { type: "string", description: "The group ID to invite the user to." },
+                userId: { type: "string", description: "The target user's Ozaiya ID or account ID." },
+            },
+            required: ["groupId", "userId"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const groupId = args.groupId?.trim();
+                const userId = args.userId?.trim();
+                if (!groupId || !userId) {
+                    return { content: [{ type: "text", text: "Error: groupId and userId are required." }] };
+                }
+                // Resolve ozaiyaId to account ID
+                let accountId = userId;
+                const users = await searchUsers(account.apiBaseUrl, account.botToken, userId).catch(() => []);
+                const match = users.find((u) => u.ozaiyaId === userId) ?? users[0];
+                if (match)
+                    accountId = match.id;
+                // Get group key and wrap for the new member
+                const groupKey = await getGroupKeyOrThrow(account, groupId);
+                const pubKeys = await getUserPublicKeys(account.apiBaseUrl, account.botToken, [accountId]);
+                if (pubKeys.length === 0) {
+                    return { content: [{ type: "text", text: `Error: user ${userId} not found or has no encryption key.` }] };
+                }
+                const wrappedKey = await wrapGroupKey(groupKey, pubKeys[0].publicKey);
+                await addMember(account.apiBaseUrl, account.botToken, groupId, accountId, wrappedKey);
+                return {
+                    content: [{ type: "text", text: `Invited ${userId} to group ${groupId}.` }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
+function createReactTool(account) {
+    return {
+        label: "React",
+        name: "react",
+        ownerOnly: false,
+        description: "Add or remove an emoji reaction on a message. Toggles: if the reaction already exists, it is removed.",
+        parameters: {
+            type: "object",
+            properties: {
+                messageId: { type: "string", description: "The message ID to react to." },
+                emoji: { type: "string", description: "The emoji to react with (e.g. '👍', '❤️', '🎉')." },
+            },
+            required: ["messageId", "emoji"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const { added } = await toggleReaction(account.apiBaseUrl, account.botToken, args.messageId, args.emoji);
+                return {
+                    content: [{ type: "text", text: added ? `Reacted with ${args.emoji}.` : `Removed ${args.emoji} reaction.` }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
+function createEditMessageTool(account) {
+    return {
+        label: "Edit Message",
+        name: "edit_message",
+        ownerOnly: false,
+        description: "Edit a previously sent message. Only the bot's own messages can be edited.",
+        parameters: {
+            type: "object",
+            properties: {
+                groupId: { type: "string", description: "The group ID containing the message." },
+                messageId: { type: "string", description: "The message ID to edit." },
+                text: { type: "string", description: "The new message text." },
+            },
+            required: ["groupId", "messageId", "text"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const groupKey = await getGroupKeyOrThrow(account, args.groupId);
+                const content = { text: args.text };
+                const encrypted = encryptMessage(content, groupKey);
+                await editMessage(account.apiBaseUrl, account.botToken, args.messageId, encrypted);
+                return {
+                    content: [{ type: "text", text: `Message ${args.messageId} edited.` }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
+function createDeleteMessageTool(account) {
+    return {
+        label: "Delete Message",
+        name: "delete_message",
+        ownerOnly: false,
+        description: "Delete a previously sent message. Only the bot's own messages can be deleted.",
+        parameters: {
+            type: "object",
+            properties: {
+                messageId: { type: "string", description: "The message ID to delete." },
+            },
+            required: ["messageId"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                await deleteMessage(account.apiBaseUrl, account.botToken, args.messageId);
+                return {
+                    content: [{ type: "text", text: `Message ${args.messageId} deleted.` }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
+function createPinMessageTool(account) {
+    return {
+        label: "Pin Message",
+        name: "pin_message",
+        ownerOnly: false,
+        description: "Pin or unpin a message in a group chat.",
+        parameters: {
+            type: "object",
+            properties: {
+                messageId: { type: "string", description: "The message ID to pin or unpin." },
+                unpin: { type: "boolean", description: "Set to true to unpin instead of pin. Default: false." },
+            },
+            required: ["messageId"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                if (args.unpin) {
+                    await unpinMessage(account.apiBaseUrl, account.botToken, args.messageId);
+                    return { content: [{ type: "text", text: `Message ${args.messageId} unpinned.` }] };
+                }
+                await pinMessage(account.apiBaseUrl, account.botToken, args.messageId);
+                return { content: [{ type: "text", text: `Message ${args.messageId} pinned.` }] };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
+function createSearchUsersTool(account) {
+    return {
+        label: "Search Users",
+        name: "search_users",
+        ownerOnly: false,
+        description: "Search for Ozaiya users by name or Ozaiya ID. Returns matching user IDs and display names.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "The search query (name or Ozaiya ID)." },
+            },
+            required: ["query"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const users = await searchUsers(account.apiBaseUrl, account.botToken, args.query);
+                if (users.length === 0) {
+                    return { content: [{ type: "text", text: "No users found." }] };
+                }
+                const lines = users.map((u) => `- ${u.ozaiyaId ?? "(no ID)"} (accountId: ${u.id}, nickname: ${u.nickname ?? "-"})`);
+                return {
+                    content: [{ type: "text", text: `Found ${users.length} user(s):\n${lines.join("\n")}` }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
+function createListGroupsTool(account) {
+    return {
+        label: "List Groups",
+        name: "list_groups",
+        ownerOnly: false,
+        description: "List all group chats the bot is a member of. Returns group IDs and names.",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+        execute: async (_toolCallId, _rawArgs) => {
+            try {
+                const groups = await fetchGroups(account.apiBaseUrl, account.botToken);
+                if (groups.length === 0) {
+                    return { content: [{ type: "text", text: "Not a member of any groups." }] };
+                }
+                const lines = groups.map((g) => `- ${g.name ?? "(unnamed)"} (groupId: ${g.id})`);
+                return {
+                    content: [{ type: "text", text: `Member of ${groups.length} group(s):\n${lines.join("\n")}` }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error: ${msg}` }] };
+            }
+        },
+    };
+}
 /**
  * Handle an inbound webhook message:
  * 1. Decrypt message content
@@ -1462,4 +1808,168 @@ ctx) {
         },
     });
 }
+/**
+ * Handle call.started webhook — bot auto-joins the LiveKit room and starts
+ * listening via Deepgram STT, dispatching transcripts to the agent, and
+ * speaking replies via Deepgram Aura TTS.
+ */
+async function handleCallStarted(payload, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ctx) {
+    const account = ctx.account;
+    const ozaiyaCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+    const voiceCallCfg = ozaiyaCfg.voiceCall;
+    if (!voiceCallCfg?.enabled) {
+        ctx.log?.info?.(`[${account.accountId}] voice call disabled, ignoring call.started`);
+        return;
+    }
+    if (voiceCallCfg.autoJoin === false) {
+        ctx.log?.info?.(`[${account.accountId}] voiceCall.autoJoin=false, ignoring call.started`);
+        return;
+    }
+    const maxConcurrent = voiceCallCfg.maxConcurrentCalls ?? 5;
+    if (activeVoiceCalls.size >= maxConcurrent) {
+        ctx.log?.warn?.(`[${account.accountId}] max concurrent voice calls reached (${maxConcurrent}), ignoring`);
+        return;
+    }
+    if (activeVoiceCalls.has(payload.callId)) {
+        ctx.log?.info?.(`[${account.accountId}] already in call ${payload.callId}`);
+        return;
+    }
+    ctx.log?.info?.(`[${account.accountId}] joining call ${payload.callId} in group ${payload.groupId}`);
+    // Join the call via API to get LiveKit token
+    const joinResult = await joinCall(account.apiBaseUrl, account.botToken, payload.callId);
+    if (!joinResult) {
+        ctx.log?.warn?.(`[${account.accountId}] failed to join call ${payload.callId}`);
+        return;
+    }
+    // Resolve agent route for dispatching voice transcripts
+    const runtime = getOzaiyaRuntime();
+    const ch = runtime.channel;
+    const route = ch.routing.resolveAgentRoute({
+        cfg: ctx.cfg,
+        channel: "ozaiya",
+        accountId: account.accountId,
+        peer: {
+            kind: "group",
+            id: payload.groupId,
+        },
+    });
+    const session = new VoiceCallSession({
+        callId: payload.callId,
+        groupId: payload.groupId,
+        livekitToken: joinResult.token,
+        livekitUrl: joinResult.url,
+        voiceCallConfig: voiceCallCfg,
+        onTranscript: (text) => {
+            // Dispatch transcript to agent and speak the reply
+            void handleVoiceTranscript(text, session, route, account, ctx);
+        },
+        log: ctx.log,
+    });
+    activeVoiceCalls.set(payload.callId, session);
+    try {
+        await session.connect();
+    }
+    catch (err) {
+        ctx.log?.warn?.(`[${account.accountId}] voice call connect error: ${String(err)}`);
+        activeVoiceCalls.delete(payload.callId);
+        await session.disconnect();
+        // Leave the call via API
+        await leaveCall(account.apiBaseUrl, account.botToken, payload.callId).catch(() => { });
+    }
+}
+/**
+ * Dispatch a voice transcript to the agent and speak the reply via TTS.
+ */
+async function handleVoiceTranscript(text, session, route, account, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ctx) {
+    const runtime = getOzaiyaRuntime();
+    const ch = runtime.channel;
+    const fromAddress = `ozaiya:group:${session.groupId}`;
+    const conversationLabel = `group:${session.groupId}`;
+    const storePath = ch.session.resolveStorePath(undefined, {
+        agentId: route.agentId,
+    });
+    const previousTimestamp = ch.session.readSessionUpdatedAt({
+        storePath,
+        sessionKey: route.sessionKey,
+    });
+    const envelopeOptions = ch.reply.resolveEnvelopeFormatOptions(ctx.cfg);
+    // Voice-specific agent prompt — tells the agent to respond in spoken-friendly style
+    const ozaiyaChannelCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+    const voicePrompt = ozaiyaChannelCfg.voiceCall?.agentPrompt ??
+        "[Voice Call] You are in a live voice call. Your response will be spoken aloud via TTS. " +
+            "Rules: respond concisely (1-3 sentences), use natural spoken language, " +
+            "never use markdown/code blocks/bullet lists/URLs/emojis. " +
+            "Do not say \"sure\" or \"of course\" — just answer directly.";
+    const bodyForAgent = `${voicePrompt}\n\n${text}`;
+    const body = ch.reply.formatAgentEnvelope({
+        channel: "Ozaiya",
+        from: `Voice (${conversationLabel})`,
+        timestamp: Date.now(),
+        previousTimestamp,
+        envelope: envelopeOptions,
+        body: bodyForAgent,
+    });
+    const msgCtx = ch.reply.finalizeInboundContext({
+        Body: body,
+        BodyForAgent: bodyForAgent,
+        RawBody: text,
+        CommandBody: text,
+        From: fromAddress,
+        To: fromAddress,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: "group",
+        ConversationLabel: conversationLabel,
+        GroupSubject: session.groupId,
+        SenderId: "voice-caller",
+        SenderName: "Voice Caller",
+        Provider: "ozaiya",
+        Surface: "ozaiya-voice",
+        MessageSid: `voice-${Date.now()}`,
+        Timestamp: Date.now(),
+        NumFiles: 0,
+        NumMedia: 0,
+        HasFiles: false,
+        CommandAuthorized: true,
+        OriginatingChannel: "ozaiya",
+        OriginatingTo: fromAddress,
+    });
+    // Collect the full reply text, then speak it sentence-by-sentence
+    await ch.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: msgCtx,
+        cfg: ctx.cfg,
+        dispatcherOptions: {
+            deliver: async (replyPayload, _info) => {
+                const replyText = replyPayload.text;
+                if (!replyText?.trim())
+                    return;
+                // Speak via TTS (sentence-level streaming handled inside speakReply)
+                await session.speakReply(replyText);
+            },
+            onError: (err) => {
+                ctx.log?.warn?.(`ozaiya: voice reply dispatch error: ${String(err)}`);
+            },
+        },
+    });
+}
+/**
+ * Handle call.ended webhook — disconnect the bot's VoiceCallSession.
+ */
+async function handleCallEnded(payload, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ctx) {
+    const account = ctx.account;
+    const session = activeVoiceCalls.get(payload.callId);
+    if (!session)
+        return;
+    ctx.log?.info?.(`[${account.accountId}] call ended ${payload.callId}, disconnecting voice session`);
+    activeVoiceCalls.delete(payload.callId);
+    await session.disconnect();
+    // Leave the call via API (fire-and-forget)
+    await leaveCall(account.apiBaseUrl, account.botToken, payload.callId).catch(() => { });
+}
 //# sourceMappingURL=channel.js.map