@ozaiya/openclaw-channel 0.10.35 → 0.10.37

package/dist/src/channel.js

@@ -117,6 +117,7 @@ function buildTaskProgressContent(dispatch, completed) {
                 completedAt: s.completedAt,
             })),
             completed,
+            stopped: dispatch.stopped,
             plan: dispatch.plan,
             deliverables: dispatch.deliverables,
             live: !completed,
@@ -1486,21 +1487,26 @@ function buildChannelTools(account, cfg) {
         createMakePhoneCallTool(account, cfg),
         createHangUpCallTool(account),
         createStartInAppCallTool(account, cfg),
+        createRequestUserApprovalTool(account),
     ];
-    const imageTool = createGenerateImageTool(account, cfg, resolveForGroup);
+    // A bot hosted on Ozaiya pays per addon, so its addon-backed tools appear only once the
+    // addon is on; a self-hosted gateway keeps every tool its own config enables.
+    const addonOn = (key) => !account.hosted || !!account.addons?.[key];
+    const imageTool = addonOn("image_gen") ? createGenerateImageTool(account, cfg, resolveForGroup) : null;
     if (imageTool)
         tools.push(imageTool);
-    tools.push(createDesktopTool());
-    const xueqiuTool = createFetchXueqiuTool(cfg);
+    if (addonOn("wechat"))
+        tools.push(createDesktopTool());
+    const xueqiuTool = addonOn("xueqiu") ? createFetchXueqiuTool(cfg) : null;
     if (xueqiuTool)
         tools.push(xueqiuTool);
-    const xueqiuSearchTool = createSearchXueqiuTool(cfg);
+    const xueqiuSearchTool = addonOn("xueqiu") ? createSearchXueqiuTool(cfg) : null;
     if (xueqiuSearchTool)
         tools.push(xueqiuSearchTool);
-    const scrapeTool = createScrapeSocialMediaTool(cfg);
+    const scrapeTool = addonOn("social_media") ? createScrapeSocialMediaTool(cfg) : null;
     if (scrapeTool)
         tools.push(scrapeTool);
-    const summarizeTool = createSummarizeUrlTool(cfg);
+    const summarizeTool = addonOn("web_research") ? createSummarizeUrlTool(cfg) : null;
     if (summarizeTool)
         tools.push(summarizeTool);
     // Plan tool: lets the agent declare + maintain a high-level task plan that the
@@ -1781,9 +1787,10 @@ export const ozaiyaPlugin = {
         resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
         defaultAccountId: () => DEFAULT_ACCOUNT_ID,
         isConfigured: (account) => {
-            // Gateway sentinel is configured if userToken is present
+            // The gateway sentinel is only listed when a userToken (user gateway) or a provisionSecret
+            // (fleet node, whose account has no botToken) is set, so being listed means configured.
             if (account.accountId === GATEWAY_ACCOUNT_ID) {
-                return Boolean(account.botToken?.trim());
+                return true;
             }
             // Gateway-loaded bot accounts are always configured
             if (gatewayBotAccounts.has(account.accountId)) {
@@ -1795,7 +1802,7 @@ export const ozaiyaPlugin = {
             accountId: account.accountId,
             enabled: account.enabled,
             configured: account.accountId === GATEWAY_ACCOUNT_ID
-                ? Boolean(account.botToken?.trim())
+                ? true
                 : Boolean(account.botToken?.trim() && account.botPrivateKey?.trim()),
             webhookPath: account.webhookPath,
             baseUrl: account.apiBaseUrl,
@@ -3060,6 +3067,45 @@ function createStartInAppCallTool(account, cfg) {
         },
     };
 }
+/**
+ * Ask the user before an action that can't be undone — paying, placing an order, submitting a
+ * form with their details, posting or sending something in their name. Shows an Approve/Reject
+ * card in the chat and waits for the answer (or the confirmation timeout).
+ */
+function createRequestUserApprovalTool(account) {
+    return {
+        label: "Request User Approval",
+        name: "request_user_approval",
+        ownerOnly: false,
+        description: "Ask the user to approve an action BEFORE doing it. Required before paying or placing an order, " +
+            "submitting a form with their personal details, or sending a message, email or post on their behalf. " +
+            "Shows Approve/Reject buttons in the chat and waits up to 5 minutes. Returns APPROVED or REJECTED; " +
+            "only go ahead on APPROVED.",
+        parameters: {
+            type: "object",
+            properties: {
+                groupId: { type: "string", description: "The chat to ask in (the current conversation)." },
+                action: { type: "string", description: "Short name of the action, e.g. \"Pay ¥128 for 2 movie tickets\"." },
+                details: {
+                    type: "object",
+                    description: "Key facts the user should check, as short label → value pairs (amount, recipient, item, date…).",
+                    additionalProperties: { type: "string" },
+                },
+            },
+            required: ["groupId", "action"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            const args = rawArgs;
+            const params = {};
+            for (const [key, value] of Object.entries(args.details ?? {})) {
+                if (value !== undefined && value !== null && value !== "")
+                    params[key] = String(value).slice(0, 200);
+            }
+            const approved = await requestConfirmation(makeConfirmationDeps(account), args.groupId, "request_user_approval", params, String(args.action ?? "").slice(0, 120) || undefined);
+            return { content: [{ type: "text", text: approved ? "APPROVED" : "REJECTED (or no answer in time) — do not do it." }] };
+        },
+    };
+}
 function createMakePhoneCallTool(account, cfg) {
     return {
         label: "Make Phone Call",
@@ -3406,6 +3452,7 @@ async function handlePhoneAutoTranscript(text, session, account, cfg, groupId) {
     const bodyForAgent = `${voicePrompt}\n\n${text}`;
     const body = `[ozaiya] from: phone caller | at: ${new Date().toISOString()}\n---\n${text}`;
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: bodyForAgent,
         RawBody: text,
@@ -3819,6 +3866,7 @@ ctx) {
     });
     // Build finalized context for dispatch
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: effectiveAgentInput,
         RawBody: agentInput,
@@ -3880,6 +3928,7 @@ ctx) {
         agentId: route.agentId,
         title: deriveTaskTitle(effectiveMessageText ?? agentInput),
         replyTexts: [],
+        abortController: new AbortController(),
     };
     activeDispatches.set(account.accountId, dispatch);
     // Start screen recording for replay (best-effort; null if nothing recordable).
@@ -4033,9 +4082,23 @@ ctx) {
                     ctx.log?.warn?.(`ozaiya: reply dispatch error: ${String(err)}`);
                 },
             },
-            replyOptions: account.model ? { isHeartbeat: true, heartbeatModelOverride: account.model } : undefined,
+            // The abortSignal lets a "stop" callback interrupt the running turn mid-flight.
+            replyOptions: {
+                abortSignal: dispatch.abortController.signal,
+                ...(account.model ? { isHeartbeat: true, heartbeatModelOverride: account.model } : {}),
+            },
         });
     }
+    catch (err) {
+        // A user-initiated stop aborts the running turn — that rejection is expected,
+        // so don't surface it as a dispatch error (the card is finalized as "stopped" below).
+        if (dispatch.stopped || dispatch.abortController.signal.aborted) {
+            ctx.log?.info?.(`ozaiya: task ${dispatch.taskId} stopped by user`);
+        }
+        else {
+            ctx.log?.warn?.(`ozaiya: reply dispatch threw: ${String(err)}`);
+        }
+    }
     finally {
         // Recover an inline table the model forgot to publish_artifact, BEFORE finalizing
         // so the final progress card includes the deliverable.
@@ -4183,6 +4246,52 @@ ctx) {
         if (resolved)
             return; // intercepted — don't dispatch to agent
     }
+    // Intercept task-control callbacks from the chat task card.
+    //   oz_stop:<taskId>     → abort the running dispatch mid-flight (interrupts the LLM turn)
+    //   oz_continue:<taskId> → resume the task with a fresh, fully-tracked dispatch
+    if (callbackData.startsWith("oz_stop:")) {
+        const taskId = callbackData.slice("oz_stop:".length);
+        const dispatch = activeDispatches.get(account.accountId);
+        if (dispatch && dispatch.taskId === taskId && !dispatch.abortController.signal.aborted) {
+            dispatch.stopped = true; // makes finalizeTaskProgress emit a "stopped" card
+            ctx.log?.info?.(`ozaiya: stop requested for task ${taskId} — aborting dispatch`);
+            dispatch.abortController.abort();
+        }
+        else {
+            ctx.log?.info?.(`ozaiya: stop requested for task ${taskId} but no matching live dispatch`);
+        }
+        return; // intercepted — don't dispatch to agent
+    }
+    if (callbackData.startsWith("oz_continue:")) {
+        // Resume by feeding a synthetic "continue" message through the normal inbound
+        // path, so it gets full task-progress tracking + a fresh live card. The agent's
+        // session persists across dispatches, so it picks up with the task's full context.
+        const continueText = "继续之前的任务，从你上次停下的地方接着做。\nContinue the previous task from where you stopped.";
+        try {
+            const groupKey = await getGroupKeyOrThrow(account, groupId);
+            const synthetic = {
+                event: "message.new",
+                groupId,
+                groupType: "group",
+                replyAllowed: true,
+                message: {
+                    id: `continue-${Date.now()}`,
+                    senderId: from,
+                    senderName: from,
+                    seq: 0,
+                    content: encryptMessage({ text: continueText }, groupKey),
+                    replyToId: null,
+                    createdAt: Date.now(),
+                },
+            };
+            ctx.log?.info?.(`ozaiya: continue requested for task ${callbackData.slice("oz_continue:".length)} — re-dispatching`);
+            await handleInboundMessage(synthetic, ctx);
+        }
+        catch (err) {
+            ctx.log?.warn?.(`ozaiya: continue dispatch failed: ${String(err)}`);
+        }
+        return; // intercepted — don't run the lightweight callback dispatch
+    }
     const runtime = getOzaiyaRuntime();
     const ch = runtime.channel;
     const { callbackBody, callbackCommand, callbackLabel, callbackOptionIndex } = normalizeCallbackQueryPayload({
@@ -4225,6 +4334,7 @@ ctx) {
         body: callbackBody,
     });
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: callbackBody,
         RawBody: callbackBody,
@@ -4401,6 +4511,7 @@ ctx) {
         body: bodyForAgent,
     });
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: bodyForAgent,
         RawBody: text,
@@ -4485,6 +4596,7 @@ ctx) {
         body: bodyForAgent,
     });
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: bodyForAgent,
         RawBody: lastUserMessage,