@ozaiya/openclaw-channel 0.7.0 → 0.7.2

package/dist/index.d.ts

@@ -32,6 +32,25 @@ declare const plugin: {
             readonly webhookPath: {
                 readonly type: "string";
             };
+            readonly webhookBase: {
+                readonly type: "string";
+            };
+            readonly botWebhookBases: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+            };
+            readonly userToken: {
+                readonly type: "string";
+            };
+            readonly gatewayName: {
+                readonly type: "string";
+            };
+            readonly dmPolicy: {
+                readonly type: "string";
+                readonly enum: readonly ["allow", "deny", "allowlist"];
+            };
             readonly accounts: {
                 readonly type: "object";
                 readonly additionalProperties: {
@@ -53,9 +72,6 @@ declare const plugin: {
                         readonly webhookPath: {
                             readonly type: "string";
                         };
-                        readonly stt: {
-                            readonly $ref: "#/$defs/stt";
-                        };
                     };
                 };
             };
@@ -70,7 +86,10 @@ declare const plugin: {
                 readonly properties: {
                     readonly mode: {
                         readonly type: "string";
-                        readonly enum: readonly ["disabled", "openai", "local-command"];
+                        readonly enum: readonly ["disabled", "enabled"];
+                    };
+                    readonly url: {
+                        readonly type: "string";
                     };
                     readonly timeoutMs: {
                         readonly type: "integer";
@@ -80,51 +99,6 @@ declare const plugin: {
                         readonly type: "integer";
                         readonly minimum: 1;
                     };
-                    readonly openai: {
-                        readonly type: "object";
-                        readonly additionalProperties: false;
-                        readonly properties: {
-                            readonly apiKey: {
-                                readonly type: "string";
-                            };
-                            readonly baseUrl: {
-                                readonly type: "string";
-                            };
-                            readonly model: {
-                                readonly type: "string";
-                            };
-                            readonly organization: {
-                                readonly type: "string";
-                            };
-                            readonly project: {
-                                readonly type: "string";
-                            };
-                        };
-                    };
-                    readonly localCommand: {
-                        readonly type: "object";
-                        readonly additionalProperties: false;
-                        readonly properties: {
-                            readonly command: {
-                                readonly type: "string";
-                            };
-                            readonly args: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "string";
-                                };
-                            };
-                            readonly cwd: {
-                                readonly type: "string";
-                            };
-                            readonly env: {
-                                readonly type: "object";
-                                readonly additionalProperties: {
-                                    readonly type: "string";
-                                };
-                            };
-                        };
-                    };
                 };
             };
         };

package/dist/src/channel.js

@@ -7,7 +7,7 @@
  */
 import fs from "node:fs/promises";
 import path from "node:path";
-import { registerPluginHttpRoute } from "openclaw/plugin-sdk";
+import { registerPluginHttpRoute } from "openclaw/plugin-sdk/webhook-ingress";
 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";
@@ -116,7 +116,7 @@ function resolveAccount(cfg, accountId) {
             webhookSecret: accountConfig.webhookSecret ?? "",
             apiBaseUrl,
             webhookPath: accountConfig.webhookPath ?? `${DEFAULT_WEBHOOK_PATH}/${id}`,
-            stt: resolveOzaiyaSttConfig(ozaiya, accountConfig),
+            stt: resolveOzaiyaSttConfig(ozaiya),
         };
     }
     // Default account (top-level fields)
@@ -644,36 +644,46 @@ export const ozaiyaPlugin = {
                     // Stop existing handler if re-registering
                     botUnregisters.get(botAccount.accountId)?.();
                     recordState(botAccount.accountId, { running: true, lastStartAt: Date.now() });
-                    const unregisterHttp = registerPluginHttpRoute({
-                        path: botAccount.webhookPath,
-                        auth: "plugin",
-                        replaceExisting: true,
-                        pluginId: "ozaiya",
-                        source: "ozaiya-gateway",
+                    const webhookHandler = createOzaiyaWebhookHandler({
+                        webhookSecret: botAccount.webhookSecret,
                         log: (msg) => ctx.log?.info(msg),
-                        handler: createOzaiyaWebhookHandler({
-                            webhookSecret: botAccount.webhookSecret,
-                            log: (msg) => ctx.log?.info(msg),
-                            onEvent: async (payload) => {
-                                const botCtx = { ...ctx, account: botAccount };
-                                if (payload.event === "message.new") {
-                                    await handleInboundMessage(payload, botCtx);
-                                }
-                                else if (payload.event === "callback_query") {
-                                    await handleCallbackQuery(payload, botCtx);
-                                }
-                                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);
-                                }
-                            },
-                        }),
+                        onEvent: async (payload) => {
+                            const botCtx = { ...ctx, account: botAccount };
+                            if (payload.event === "message.new") {
+                                await handleInboundMessage(payload, botCtx);
+                            }
+                            else if (payload.event === "callback_query") {
+                                await handleCallbackQuery(payload, botCtx);
+                            }
+                            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);
+                            }
+                            else if (payload.event === "voice.llm_request") {
+                                return handleVoiceLlmRequest(payload, botCtx);
+                            }
+                        },
                     });
+                    let unregisterHttp = () => { };
+                    if (typeof registerPluginHttpRoute === "function") {
+                        unregisterHttp = registerPluginHttpRoute({
+                            path: botAccount.webhookPath,
+                            auth: "plugin",
+                            replaceExisting: true,
+                            pluginId: "ozaiya",
+                            source: "ozaiya-gateway",
+                            log: (msg) => ctx.log?.info(msg),
+                            handler: webhookHandler,
+                        });
+                    }
+                    else {
+                        ctx.log?.info(`[${botAccount.accountId}] registerPluginHttpRoute not available — webhook at ${botAccount.webhookPath} uses fallback`);
+                    }
                     // Pre-fetch group keys for this bot
                     void fetchAndUnwrapGroupKeys(botAccount).then((count) => {
                         ctx.log?.info(`[${botAccount.accountId}] unwrapped ${count} group key(s)`);
@@ -736,6 +746,10 @@ export const ozaiyaPlugin = {
                                 ctx.log?.warn?.(`[${botId}] Socket.io call.ended error: ${String(err)}`);
                             });
                         }
+                        else if (payload.event === "voice.llm_request") {
+                            // voice.llm_request requires HTTP streaming — not supported via socket.io fast-path
+                            ctx.log?.warn?.(`[${botId}] voice.llm_request received via socket.io, ignoring (requires HTTP)`);
+                        }
                     },
                     log: {
                         info: (msg) => ctx.log?.info(msg),
@@ -776,31 +790,38 @@ export const ozaiyaPlugin = {
             const keyCount = await fetchAndUnwrapGroupKeys(account);
             ctx.log?.info(`[${account.accountId}] unwrapped ${keyCount} group key(s)`);
             // Register webhook HTTP handler
-            const unregisterHttp = registerPluginHttpRoute({
-                path: account.webhookPath,
-                auth: "plugin",
-                replaceExisting: true,
-                pluginId: "ozaiya",
-                source: "ozaiya-channel",
+            const staticWebhookHandler = createOzaiyaWebhookHandler({
+                webhookSecret: account.webhookSecret,
                 log: (msg) => ctx.log?.info(msg),
-                handler: createOzaiyaWebhookHandler({
-                    webhookSecret: account.webhookSecret,
-                    log: (msg) => ctx.log?.info(msg),
-                    onEvent: async (payload) => {
-                        if (payload.event === "message.new") {
-                            await handleInboundMessage(payload, ctx);
-                            return;
-                        }
-                        if (payload.event === "callback_query") {
-                            await handleCallbackQuery(payload, ctx);
-                            return;
-                        }
-                        if (payload.event === "session.reset") {
-                            await handleSessionReset(payload, ctx);
-                        }
-                    },
-                }),
+                onEvent: async (payload) => {
+                    if (payload.event === "message.new") {
+                        await handleInboundMessage(payload, ctx);
+                        return;
+                    }
+                    if (payload.event === "callback_query") {
+                        await handleCallbackQuery(payload, ctx);
+                        return;
+                    }
+                    if (payload.event === "session.reset") {
+                        await handleSessionReset(payload, ctx);
+                    }
+                },
             });
+            let unregisterHttp = () => { };
+            if (typeof registerPluginHttpRoute === "function") {
+                unregisterHttp = registerPluginHttpRoute({
+                    path: account.webhookPath,
+                    auth: "plugin",
+                    replaceExisting: true,
+                    pluginId: "ozaiya",
+                    source: "ozaiya-channel",
+                    log: (msg) => ctx.log?.info(msg),
+                    handler: staticWebhookHandler,
+                });
+            }
+            else {
+                ctx.log?.info(`[${account.accountId}] registerPluginHttpRoute not available — webhook at ${account.webhookPath} uses fallback`);
+            }
             ctx.log?.info(`[${account.accountId}] registered webhook at ${account.webhookPath}`);
             // Block until abort
             const stopHandler = () => {
@@ -1956,6 +1977,115 @@ ctx) {
         },
     });
 }
+/**
+ * Handle voice.llm_request — Volcengine CustomLLM callback routed through Ozaiya server.
+ * Dispatches the user's speech transcript to the OpenClaw agent and streams back
+ * an OpenAI-compatible SSE response for Volcengine TTS.
+ */
+async function handleVoiceLlmRequest(payload, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ctx) {
+    const account = ctx.account;
+    const runtime = getOzaiyaRuntime();
+    const ch = runtime.channel;
+    const lastUserMessage = payload.messages
+        .filter((m) => m.role === "user")
+        .pop()?.content ?? "";
+    ctx.log?.info?.(`[${account.accountId}] voice.llm_request for call ${payload.callId}: "${lastUserMessage.slice(0, 80)}"`);
+    // Resolve agent route
+    const route = ch.routing.resolveAgentRoute({
+        cfg: ctx.cfg,
+        channel: "ozaiya",
+        accountId: account.accountId,
+        peer: { kind: "group", id: payload.groupId },
+    });
+    const fromAddress = `ozaiya:group:${payload.groupId}`;
+    const conversationLabel = `group:${payload.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);
+    const voicePrompt = "[Voice Call — Doubao Engine] 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${lastUserMessage}`;
+    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: lastUserMessage,
+        CommandBody: lastUserMessage,
+        From: fromAddress,
+        To: fromAddress,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: "group",
+        ConversationLabel: conversationLabel,
+        GroupSubject: payload.groupId,
+        SenderId: "voice-caller",
+        SenderName: "Voice Caller",
+        Provider: "ozaiya",
+        Surface: "ozaiya-voice",
+        MessageSid: `voice-llm-${Date.now()}`,
+        Timestamp: Date.now(),
+        NumFiles: 0,
+        NumMedia: 0,
+        HasFiles: false,
+        CommandAuthorized: true,
+        OriginatingChannel: "ozaiya",
+        OriginatingTo: fromAddress,
+    });
+    // Create a ReadableStream that produces OpenAI SSE chunks
+    const responseId = `chatcmpl-${Date.now()}`;
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                await ch.reply.dispatchReplyWithBufferedBlockDispatcher({
+                    ctx: msgCtx,
+                    cfg: ctx.cfg,
+                    dispatcherOptions: {
+                        deliver: async (replyPayload, _info) => {
+                            const text = replyPayload.text?.trim();
+                            if (!text)
+                                return;
+                            const chunk = JSON.stringify({
+                                id: responseId,
+                                object: "chat.completion.chunk",
+                                choices: [{ index: 0, delta: { content: text }, finish_reason: null }],
+                            });
+                            controller.enqueue(encoder.encode(`data: ${chunk}\n\n`));
+                        },
+                        onError: (err) => {
+                            ctx.log?.warn?.(`ozaiya: voice.llm_request dispatch error: ${String(err)}`);
+                        },
+                    },
+                });
+                // Send finish chunk
+                const finishChunk = JSON.stringify({
+                    id: responseId,
+                    object: "chat.completion.chunk",
+                    choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+                });
+                controller.enqueue(encoder.encode(`data: ${finishChunk}\n\n`));
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                controller.close();
+            }
+            catch (err) {
+                ctx.log?.warn?.(`ozaiya: voice.llm_request stream error: ${String(err)}`);
+                controller.close();
+            }
+        },
+    });
+    return { contentType: "text/event-stream", body: stream };
+}
 /**
  * Handle call.ended webhook — disconnect the bot's VoiceCallSession.
  */