@ozaiya/openclaw-channel 0.10.35 → 0.10.36

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,
@@ -1487,20 +1488,24 @@ function buildChannelTools(account, cfg) {
         createHangUpCallTool(account),
         createStartInAppCallTool(account, cfg),
     ];
-    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
@@ -3406,6 +3411,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 +3825,7 @@ ctx) {
     });
     // Build finalized context for dispatch
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: effectiveAgentInput,
         RawBody: agentInput,
@@ -3880,6 +3887,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 +4041,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 +4205,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 +4293,7 @@ ctx) {
         body: callbackBody,
     });
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: callbackBody,
         RawBody: callbackBody,
@@ -4401,6 +4470,7 @@ ctx) {
         body: bodyForAgent,
     });
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: bodyForAgent,
         RawBody: text,
@@ -4485,6 +4555,7 @@ ctx) {
         body: bodyForAgent,
     });
     const msgCtx = ch.reply.finalizeInboundContext({
+        GroupSystemPrompt: account.persona,
         Body: body,
         BodyForAgent: bodyForAgent,
         RawBody: lastUserMessage,