@core-workspace/infoflow-openclaw-plugin 2026.3.9 → 2026.3.27-beta.0

package/src/tools/index.ts

@@ -1,21 +1,40 @@
 /**
  * Infoflow Agent Tools（Agent 工具注册）
  *
- * 向 OpenClaw 注册两个供 LLM function calling 使用的工具：
+ * 向 OpenClaw 注册供 LLM function calling 使用的工具：
  *   - infoflow_send:   主动向用户或群发送消息
  *   - infoflow_recall: 撤回近期发送的消息
+ *   - infoflow_cron:   创建强绑定当前如流会话目标的定时消息
  *
  * 这两个工具封装了 outbound/send.ts 中的底层发送/撤回逻辑，
  * 让 Agent 能够主动发消息，而不仅限于被动回复。
  */
 
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { Type, type Static } from "@sinclair/typebox";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
+import { normalizeInfoflowTarget } from "../adapter/outbound/target-resolver.js";
 import { resolveInfoflowAccount } from "../channel/accounts.js";
+import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "../channel/media.js";
+import {
+  sendInfoflowMessage,
+  recallInfoflowGroupMessage,
+  recallInfoflowPrivateMessage,
+  isLikelyLocalPath,
+} from "../channel/outbound.js";
 import { logVerbose } from "../logging.js";
-import { sendInfoflowMessage, recallInfoflowGroupMessage, recallInfoflowPrivateMessage } from "../channel/outbound.js";
+import type { InfoflowMessageContentItem } from "../types.js";
+import { imBosUpload, imBosGetUrl } from "../utils/bos/im-bos-client.js";
 import { querySentMessages, removeRecalledMessages } from "../utils/store/message-store.js";
-import { normalizeInfoflowTarget } from "../adapter/outbound/target-resolver.js";
+import {
+  encodeInfoflowCronJobDescription,
+  resolveInfoflowTargetFromSessionEntry,
+  resolveInfoflowTargetFromSessionKey,
+  type InfoflowCronJobMetadata,
+} from "./cron/relay.js";
 
 // ---------------------------------------------------------------------------
 // infoflow_send 参数 Schema
@@ -45,6 +64,12 @@ const InfoflowSendSchema = Type.Object({
       description: "多账号模式下指定账号 ID，不填则使用默认账号。",
     }),
   ),
+  imageUrl: Type.Optional(
+    Type.String({
+      description:
+        "要发送的图片 URL 或本地文件路径。提供此参数时会发送图片消息；可与 message 同时使用（先发文字再发图片）。",
+    }),
+  ),
 });
 
 type InfoflowSendParams = Static<typeof InfoflowSendSchema>;
@@ -78,6 +103,217 @@ const InfoflowRecallSchema = Type.Object({
 
 type InfoflowRecallParams = Static<typeof InfoflowRecallSchema>;
 
+// ---------------------------------------------------------------------------
+// infoflow_cron 参数 Schema
+// ---------------------------------------------------------------------------
+
+const InfoflowCronSchema = Type.Object({
+  name: Type.String({
+    description: "定时任务名称，建议简短明确，例如“日报提醒”。",
+  }),
+  message: Type.String({
+    description: "定时发送的消息内容，支持 Markdown。",
+  }),
+  atAll: Type.Optional(
+    Type.Boolean({
+      description: "群聊定时消息是否 @全体成员。仅群聊生效，单聊忽略。",
+    }),
+  ),
+  mentionUserIds: Type.Optional(
+    Type.String({
+      description:
+        '群聊定时消息需要 @ 的成员列表，逗号分隔的 uuapName（例如 "zhangsan,lisi"）。仅群聊生效，atAll 为 true 时忽略。',
+    }),
+  ),
+  at: Type.Optional(
+    Type.String({
+      description: '一次性任务的触发时间。支持 ISO 时间，例如 "2026-03-17T18:00:00+08:00"。',
+    }),
+  ),
+  every: Type.Optional(
+    Type.String({
+      description: '按固定间隔重复执行，例如 "30m"、"1h"。',
+    }),
+  ),
+  cron: Type.Optional(
+    Type.String({
+      description: 'Cron 表达式，例如 "0 9 * * 1-5"。',
+    }),
+  ),
+  tz: Type.Optional(
+    Type.String({
+      description: 'Cron 表达式对应的 IANA 时区，例如 "Asia/Shanghai"。',
+    }),
+  ),
+  description: Type.Optional(
+    Type.String({
+      description: "可选的任务备注。",
+    }),
+  ),
+  keepAfterRun: Type.Optional(
+    Type.Boolean({
+      description: "一次性任务执行后是否保留。默认执行后删除。",
+    }),
+  ),
+});
+
+type InfoflowCronParams = Static<typeof InfoflowCronSchema>;
+type InfoflowToolExecutionContext = {
+  messageChannel?: string;
+  requesterSenderId?: string;
+  sessionKey?: string;
+  agentDir?: string;
+  agentId?: string;
+  workspaceDir?: string;
+};
+
+function json(payload: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(payload) }],
+    details: payload,
+  };
+}
+
+function expandHomePrefix(filePath: string): string {
+  if (filePath === "~") {
+    return process.env.HOME ?? "~";
+  }
+  if (filePath.startsWith("~/")) {
+    return path.join(process.env.HOME ?? "~", filePath.slice(2));
+  }
+  return filePath;
+}
+
+function toObject(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function toTrimmedString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function buildInfoflowCronSessionKey(): string {
+  return `agent:main:cron:infoflow:${randomUUID()}`;
+}
+
+function resolveToolSessionStorePath(
+  api: OpenClawPluginApi,
+  ctx: InfoflowToolExecutionContext,
+): string | null {
+  const configured = toObject(api.config.session)?.store;
+  if (typeof configured === "string" && configured.trim()) {
+    const agentId = ctx.agentId?.trim() || "main";
+    return path.resolve(expandHomePrefix(configured.trim().replaceAll("{agentId}", agentId)));
+  }
+  if (ctx.agentDir?.trim()) {
+    return path.join(ctx.agentDir, "sessions", "sessions.json");
+  }
+  return null;
+}
+
+async function resolveInfoflowCronTargetForTool(
+  api: OpenClawPluginApi,
+  ctx: InfoflowToolExecutionContext,
+): Promise<{ target: string; creatorSenderId?: string } | null> {
+  if (ctx.messageChannel !== "infoflow") {
+    return null;
+  }
+
+  const requesterSenderId = ctx.requesterSenderId?.trim() || undefined;
+  const storePath = resolveToolSessionStorePath(api, ctx);
+  if (storePath && ctx.sessionKey?.trim()) {
+    try {
+      const raw = await fs.readFile(storePath, "utf8");
+      const parsed = toObject(JSON.parse(raw));
+      const sessionTarget = resolveInfoflowTargetFromSessionEntry({
+        entry: parsed?.[ctx.sessionKey],
+        sessionKey: ctx.sessionKey,
+      });
+      if (sessionTarget) {
+        return {
+          target: sessionTarget,
+          creatorSenderId: requesterSenderId,
+        };
+      }
+    } catch {
+      // Ignore session store read errors and fall through to sessionKey / FromUserId resolution.
+    }
+  }
+
+  const sessionTarget = resolveInfoflowTargetFromSessionKey(ctx.sessionKey);
+  if (sessionTarget) {
+    return {
+      target: sessionTarget,
+      creatorSenderId: requesterSenderId,
+    };
+  }
+
+  if (requesterSenderId && !ctx.sessionKey?.toLowerCase().includes(":group:")) {
+    return {
+      target: `infoflow:${requesterSenderId}`,
+      creatorSenderId: requesterSenderId,
+    };
+  }
+
+  return null;
+}
+
+async function runOpenClaw(
+  args: string[],
+  cwd: string | undefined,
+): Promise<{
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}> {
+  return await new Promise((resolve, reject) => {
+    const child = spawn("openclaw", args, {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (exitCode) => {
+      resolve({
+        exitCode: exitCode ?? 1,
+        stdout,
+        stderr,
+      });
+    });
+  });
+}
+
+function parseJsonFromMixedOutput(raw: string): unknown {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const objectStart = trimmed.indexOf("{");
+    if (objectStart >= 0) {
+      try {
+        return JSON.parse(trimmed.slice(objectStart));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // 注册函数
 // ---------------------------------------------------------------------------
@@ -96,22 +332,23 @@ export function registerInfoflowTools(api: OpenClawPluginApi): void {
   api.registerTool(
     {
       name: "infoflow_send",
+      label: "Infoflow Send",
       description:
-        "向如流（Infoflow）的用户或群发送消息。支持纯文本和 Markdown 格式。" +
+        "向如流（Infoflow）的用户或群发送消息。支持纯文本、Markdown 格式和图片（URL 或本地路径）。" +
         "群消息可以 @指定成员 或 @全体成员。" +
-        "当需要主动发送通知、提醒或消息时使用此工具。",
+        "当需要主动发送通知、提醒、消息或图片时使用此工具。",
       parameters: InfoflowSendSchema,
       async execute(_toolCallId, rawParams) {
         const params = rawParams as InfoflowSendParams;
-        const { to: rawTo, message, atAll, mentionUserIds, accountId } = params;
+        const { to: rawTo, message, atAll, mentionUserIds, accountId, imageUrl } = params;
 
         // 标准化目标格式（去掉可能多余的前缀）
         const to = normalizeInfoflowTarget(rawTo) ?? rawTo;
         const isGroup = /^group:\d+$/i.test(to);
 
-        logVerbose(`[infoflow_send] to=${to}, isGroup=${isGroup}`);
+        logVerbose(`[infoflow_send] to=${to}, isGroup=${isGroup}, imageUrl=${imageUrl ?? "none"}`);
 
-        const contents: Array<{ type: string; content: string }> = [];
+        const contents: InfoflowMessageContentItem[] = [];
 
         // 群消息：先拼 @mention 块，再拼正文
         if (isGroup) {
@@ -128,13 +365,80 @@ export function registerInfoflowTools(api: OpenClawPluginApi): void {
           }
         }
 
-        if (message.trim()) {
+        if (message?.trim()) {
           contents.push({ type: "markdown", content: message });
         }
 
+        // 有图片时：先发文字（如有），再发图片
+        if (imageUrl?.trim()) {
+          // 先发文字+@
+          if (contents.length > 0) {
+            await sendInfoflowMessage({
+              cfg: api.config!,
+              to,
+              contents,
+              accountId: accountId ?? undefined,
+            });
+          }
+
+          // 尝试原生图片发送，失败则降级为链接
+          try {
+            const localRoots = isLikelyLocalPath(imageUrl) ? [imageUrl] : undefined;
+            const prepared = await prepareInfoflowImageBase64({
+              mediaUrl: imageUrl,
+              mediaLocalRoots: localRoots,
+            });
+            if (prepared.isImage) {
+              const imgResult = await sendInfoflowImageMessage({
+                cfg: api.config!,
+                to,
+                base64Image: prepared.base64,
+                accountId: accountId ?? undefined,
+              });
+              const payload = {
+                ok: imgResult.ok,
+                channel: "infoflow",
+                to,
+                ...(imgResult.messageId ? { messageId: imgResult.messageId } : {}),
+                ...(imgResult.error ? { error: imgResult.error } : {}),
+              };
+              return {
+                content: [{ type: "text" as const, text: JSON.stringify(payload) }],
+                details: payload,
+              };
+            }
+          } catch (e) {
+            logVerbose(`[infoflow_send] prepareInfoflowImageBase64 error: ${e}`);
+          }
+
+          // 降级：发链接
+          const linkResult = await sendInfoflowMessage({
+            cfg: api.config!,
+            to,
+            contents: [{ type: "link", content: imageUrl }],
+            accountId: accountId ?? undefined,
+          });
+          const payload = {
+            ok: linkResult.ok,
+            channel: "infoflow",
+            to,
+            ...(linkResult.messageId ? { messageId: linkResult.messageId } : {}),
+            ...(linkResult.error ? { error: linkResult.error } : {}),
+          };
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify(payload) }],
+            details: payload,
+          };
+        }
+
         if (contents.length === 0) {
           return {
-            content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "message is empty" }) }],
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({ ok: false, error: "message is empty" }),
+              },
+            ],
             details: { ok: false, error: "message is empty" },
           };
         }
@@ -167,6 +471,7 @@ export function registerInfoflowTools(api: OpenClawPluginApi): void {
   api.registerTool(
     {
       name: "infoflow_recall",
+      label: "Infoflow Recall",
       description:
         "撤回机器人在如流（Infoflow）发送的消息。" +
         "可按消息 ID 撤回指定消息，也可按数量撤回最近 N 条（默认 1 条）。" +
@@ -180,7 +485,10 @@ export function registerInfoflowTools(api: OpenClawPluginApi): void {
         const target = to.replace(/^infoflow:/i, "");
 
         // 校验账号配置
-        const account = resolveInfoflowAccount({ cfg: api.config!, accountId: accountId ?? undefined });
+        const account = resolveInfoflowAccount({
+          cfg: api.config!,
+          accountId: accountId ?? undefined,
+        });
         if (!account.config.appKey || !account.config.appSecret) {
           const err = { ok: false, error: "Infoflow appKey/appSecret not configured." };
           return {
@@ -203,35 +511,67 @@ export function registerInfoflowTools(api: OpenClawPluginApi): void {
           // 模式 A：按 messageId 撤回单条
           if (messageId) {
             // 群消息撤回需要同时提供 messageid + msgseqid，从本地消息记录中查找 msgseqid
-            const stored = querySentMessages(account.accountId, { target: `group:${groupId}`, count: 1 })
-              .find((r) => r.messageid === messageId);
+            const stored = querySentMessages(account.accountId, {
+              target: `group:${groupId}`,
+              count: 1,
+            }).find((r) => r.messageid === messageId);
             const msgseqid = stored?.msgseqid ?? "";
             if (!msgseqid) {
-              return json({ ok: false, error: "msgseqid not found for this messageId. It may have already been recalled or not found in the message store." });
+              return json({
+                ok: false,
+                error:
+                  "msgseqid not found for this messageId. It may have already been recalled or not found in the message store.",
+              });
             }
-            const result = await recallInfoflowGroupMessage({ account, groupId, messageid: messageId, msgseqid });
+            const result = await recallInfoflowGroupMessage({
+              account,
+              groupId,
+              messageid: messageId,
+              msgseqid,
+            });
             if (result.ok) {
-              try { removeRecalledMessages(account.accountId, [messageId]); } catch { /* ignore */ }
+              try {
+                removeRecalledMessages(account.accountId, [messageId]);
+              } catch {
+                /* ignore */
+              }
             }
             return json({ ok: result.ok, to, ...(result.error ? { error: result.error } : {}) });
           }
 
           // 模式 B：按 count 批量撤回最近 N 条
-          const records = querySentMessages(account.accountId, { target: `group:${groupId}`, count })
-            .filter((r) => r.msgseqid); // 只撤回有 msgseqid 的记录
+          const records = querySentMessages(account.accountId, {
+            target: `group:${groupId}`,
+            count,
+          }).filter((r) => r.msgseqid); // 只撤回有 msgseqid 的记录
 
           if (records.length === 0) {
             return json({ ok: true, to, recalled: 0, message: "No recallable messages found." });
           }
 
-          let succeeded = 0, failed = 0;
+          let succeeded = 0,
+            failed = 0;
           const recalledIds: string[] = [];
           for (const r of records) {
-            const res = await recallInfoflowGroupMessage({ account, groupId, messageid: r.messageid, msgseqid: r.msgseqid });
-            if (res.ok) { succeeded++; recalledIds.push(r.messageid); } else { failed++; }
+            const res = await recallInfoflowGroupMessage({
+              account,
+              groupId,
+              messageid: r.messageid,
+              msgseqid: r.msgseqid,
+            });
+            if (res.ok) {
+              succeeded++;
+              recalledIds.push(r.messageid);
+            } else {
+              failed++;
+            }
           }
           if (recalledIds.length > 0) {
-            try { removeRecalledMessages(account.accountId, recalledIds); } catch { /* ignore */ }
+            try {
+              removeRecalledMessages(account.accountId, recalledIds);
+            } catch {
+              /* ignore */
+            }
           }
           return json({ ok: failed === 0, to, recalled: succeeded, failed, total: records.length });
         }
@@ -240,32 +580,59 @@ export function registerInfoflowTools(api: OpenClawPluginApi): void {
         // 私聊撤回需要 appAgentId（企业后台的应用 ID）
         const appAgentId = account.config.appAgentId;
         if (!appAgentId) {
-          return json({ ok: false, error: "Private message recall requires appAgentId configuration." });
+          return json({
+            ok: false,
+            error: "Private message recall requires appAgentId configuration.",
+          });
         }
 
         // 模式 A：按 messageId（即 msgkey）撤回单条
         if (messageId) {
-          const result = await recallInfoflowPrivateMessage({ account, msgkey: messageId, appAgentId });
+          const result = await recallInfoflowPrivateMessage({
+            account,
+            msgkey: messageId,
+            appAgentId,
+          });
           if (result.ok) {
-            try { removeRecalledMessages(account.accountId, [messageId]); } catch { /* ignore */ }
+            try {
+              removeRecalledMessages(account.accountId, [messageId]);
+            } catch {
+              /* ignore */
+            }
           }
           return json({ ok: result.ok, to, ...(result.error ? { error: result.error } : {}) });
         }
 
         // 模式 B：批量撤回最近 N 条
-        const records = querySentMessages(account.accountId, { target, count }).filter((r) => r.messageid);
+        const records = querySentMessages(account.accountId, { target, count }).filter(
+          (r) => r.messageid,
+        );
         if (records.length === 0) {
           return json({ ok: true, to, recalled: 0, message: "No recallable messages found." });
         }
 
-        let succeeded = 0, failed = 0;
+        let succeeded = 0,
+          failed = 0;
         const recalledIds: string[] = [];
         for (const r of records) {
-          const res = await recallInfoflowPrivateMessage({ account, msgkey: r.messageid, appAgentId });
-          if (res.ok) { succeeded++; recalledIds.push(r.messageid); } else { failed++; }
+          const res = await recallInfoflowPrivateMessage({
+            account,
+            msgkey: r.messageid,
+            appAgentId,
+          });
+          if (res.ok) {
+            succeeded++;
+            recalledIds.push(r.messageid);
+          } else {
+            failed++;
+          }
         }
         if (recalledIds.length > 0) {
-          try { removeRecalledMessages(account.accountId, recalledIds); } catch { /* ignore */ }
+          try {
+            removeRecalledMessages(account.accountId, recalledIds);
+          } catch {
+            /* ignore */
+          }
         }
         return json({ ok: failed === 0, to, recalled: succeeded, failed, total: records.length });
       },
@@ -273,5 +640,320 @@ export function registerInfoflowTools(api: OpenClawPluginApi): void {
     { name: "infoflow_recall" },
   );
 
-  api.logger.info?.("infoflow_tools: Registered infoflow_send and infoflow_recall tools");
+  api.registerTool(
+    (ctx) => {
+      if (ctx.messageChannel !== "infoflow") {
+        return null;
+      }
+
+      return {
+        name: "infoflow_cron",
+        label: "Infoflow Cron",
+        description:
+          "在当前如流会话里创建定时消息。目标会从可信的 FromUserId / groupId 上下文自动绑定，不允许模型自行猜测收件人。",
+        parameters: InfoflowCronSchema,
+        async execute(_toolCallId, rawParams) {
+          const params = rawParams as InfoflowCronParams;
+          const scheduleCount = [params.at, params.every, params.cron].filter(
+            (value) => typeof value === "string" && value.trim(),
+          ).length;
+          if (scheduleCount !== 1) {
+            return json({
+              ok: false,
+              error: "Exactly one of at / every / cron must be provided.",
+            });
+          }
+
+          const message = params.message.trim();
+          const name = params.name.trim();
+          if (!name || !message) {
+            return json({
+              ok: false,
+              error: "name and message are required.",
+            });
+          }
+
+          const targetContext = await resolveInfoflowCronTargetForTool(api, ctx);
+          if (!targetContext) {
+            return json({
+              ok: false,
+              error:
+                "Unable to resolve the current Infoflow target from trusted session context. In private chat this requires FromUserId; in group chat this requires current groupId/session routing.",
+            });
+          }
+          const isGroupTarget = /^group:\d+$/i.test(targetContext.target);
+          const mentionUserIds = isGroupTarget
+            ? (params.mentionUserIds ?? "")
+                .split(",")
+                .map((value) => value.trim())
+                .filter(Boolean)
+            : [];
+
+          const metadata: InfoflowCronJobMetadata = {
+            version: 1,
+            mode: "direct",
+            target: targetContext.target,
+            creatorSenderId: targetContext.creatorSenderId,
+            channel: "infoflow",
+            source: "infoflow_cron",
+            atAll: isGroupTarget ? params.atAll === true : undefined,
+            mentionUserIds:
+              isGroupTarget && params.atAll !== true && mentionUserIds.length > 0
+                ? mentionUserIds
+                : undefined,
+          };
+          const description = encodeInfoflowCronJobDescription({
+            metadata,
+            userDescription: params.description,
+          });
+          const sessionKey = buildInfoflowCronSessionKey();
+
+          const args = [
+            "cron",
+            "add",
+            "--json",
+            "--name",
+            name,
+            "--session",
+            "main",
+            "--session-key",
+            sessionKey,
+            "--wake",
+            "now",
+            "--system-event",
+            message,
+            "--description",
+            description,
+          ];
+
+          if (params.at?.trim()) {
+            args.push("--at", params.at.trim());
+            if (params.keepAfterRun) {
+              args.push("--keep-after-run");
+            } else {
+              args.push("--delete-after-run");
+            }
+          }
+          if (params.every?.trim()) {
+            args.push("--every", params.every.trim());
+          }
+          if (params.cron?.trim()) {
+            args.push("--cron", params.cron.trim());
+          }
+          if (params.tz?.trim()) {
+            args.push("--tz", params.tz.trim());
+          }
+
+          const result = await runOpenClaw(args, ctx.workspaceDir);
+          const parsed = parseJsonFromMixedOutput(`${result.stdout}\n${result.stderr}`);
+          const parsedObject = toObject(parsed);
+          const jobObject = toObject(parsedObject?.job);
+          const jobId = toTrimmedString(parsedObject?.id) ?? toTrimmedString(jobObject?.id);
+          const account = resolveInfoflowAccount({ cfg: api.config! });
+          if (result.exitCode !== 0) {
+            return json({
+              ok: false,
+              error: result.stderr.trim() || result.stdout.trim() || "openclaw cron add failed",
+              target: targetContext.target,
+            });
+          }
+
+          return json({
+            ok: true,
+            target: targetContext.target,
+            creatorSenderId: targetContext.creatorSenderId,
+            observe: {
+              channel: "infoflow",
+              jobId,
+              sessionKey,
+              jobsPath: "~/.openclaw/cron/jobs.json",
+              runsPath: jobId
+                ? `~/.openclaw/cron/runs/${jobId}.jsonl`
+                : "~/.openclaw/cron/runs/<jobId>.jsonl",
+              relayStatusPath: `<OpenClaw stateDir>/${account.config.privateDataDir}/cron-relay-status.md`,
+              relayStatePath: `<OpenClaw stateDir>/${account.config.privateDataDir}/cron-relay-state.json`,
+            },
+            job: parsed ?? result.stdout.trim(),
+          });
+        },
+      };
+    },
+    { name: "infoflow_cron" },
+  );
+
+  // ---- infoflow_bos_upload：上传文件到 BOS 并返回下载链接 ----
+
+  const InfoflowBosUploadSchema = Type.Object({
+    content: Type.String({
+      description: "要上传的文件内容（文本）。对于纯文本文件直接传入内容；对于代码文件传入源代码。",
+    }),
+    fileName: Type.String({
+      description: '文件名（含扩展名），例如 "report.md"、"data.csv"、"script.py"。',
+    }),
+    objectKey: Type.Optional(
+      Type.String({
+        description:
+          '可选的完整存储路径（目录 + 文件名 + 扩展名），例如 "reports/2026/Q1.md"、"exports/data.csv"，系统会自动添加 openclaw/ 前缀。不填则自动生成唯一路径（格式：openclaw/uploads/{yyyyMMdd}/{uuid}-{fileName}），避免不同用户上传同名文件时互相覆盖。仅在需要固定路径或主动覆盖更新时才填此字段。',
+      }),
+    ),
+    accountId: Type.Optional(
+      Type.String({
+        description: "多账号模式下指定账号 ID，不填则使用默认账号。",
+      }),
+    ),
+  });
+
+  type InfoflowBosUploadParams = Static<typeof InfoflowBosUploadSchema>;
+
+  api.registerTool(
+    {
+      name: "infoflow_bos_upload",
+      label: "Infoflow BOS Upload",
+      description:
+        "将生成的文件内容（文本、代码、CSV、Markdown 等）上传到 BOS 云存储，并自动返回带有效期的预签名下载链接。" +
+        "当用户请求生成文件、导出数据、保存代码等场景时使用此工具。" +
+        "上传成功后会同时返回 objectKey 和可直接点击的下载 URL。",
+      parameters: InfoflowBosUploadSchema,
+      async execute(_toolCallId, rawParams) {
+        const params = rawParams as InfoflowBosUploadParams;
+        const { content, fileName, objectKey, accountId } = params;
+
+        if (!content?.trim()) {
+          return json({ ok: false, error: "content is empty" });
+        }
+        if (!fileName?.trim()) {
+          return json({ ok: false, error: "fileName is required" });
+        }
+
+        const account = resolveInfoflowAccount({
+          cfg: api.config!,
+          accountId: accountId ?? undefined,
+        });
+        const { apiHost, appKey, appSecret } = account.config;
+        if (!appKey || !appSecret) {
+          return json({ ok: false, error: "Infoflow appKey/appSecret not configured." });
+        }
+
+        // 若调用方未指定 objectKey，则自动生成唯一路径，防止不同用户/会话上传同名文件时互相覆盖。
+        // 格式：openclaw/uploads/{yyyyMMdd}/{uuid}-{fileName}
+        const resolvedObjectKey = objectKey?.trim()
+          ? `openclaw/${objectKey.trim()}`
+          : (() => {
+              const today = new Date().toISOString().slice(0, 10).replace(/-/g, "");
+              return `openclaw/uploads/${today}/${randomUUID()}-${fileName.trim()}`;
+            })();
+
+        logVerbose(
+          `[infoflow_bos_upload] fileName=${fileName}, objectKey=${resolvedObjectKey}, contentLen=${content.length}`,
+        );
+
+        // 上传文件
+        const fileBuffer = Buffer.from(content, "utf-8");
+        const uploadResult = await imBosUpload({
+          apiHost,
+          appKey,
+          appSecret,
+          fileContent: fileBuffer,
+          fileName: fileName.trim(),
+          objectKey: resolvedObjectKey,
+        });
+
+        if (!uploadResult.ok) {
+          return json({ ok: false, error: uploadResult.error ?? "upload failed" });
+        }
+
+        // 上传成功后自动获取预签名下载 URL
+        const resultObjectKey = uploadResult.objectKey ?? resolvedObjectKey;
+        const urlResult = await imBosGetUrl({
+          apiHost,
+          appKey,
+          appSecret,
+          objectKey: resultObjectKey,
+        });
+
+        return json({
+          ok: true,
+          objectKey: resultObjectKey,
+          eTag: uploadResult.eTag,
+          downloadUrl: urlResult.ok ? urlResult.url : undefined,
+          expirationSeconds: urlResult.ok ? urlResult.expirationSeconds : undefined,
+          ...(urlResult.ok ? {} : { urlError: urlResult.error }),
+        });
+      },
+    },
+    { name: "infoflow_bos_upload" },
+  );
+
+  // ---- infoflow_bos_get_url：获取/刷新 BOS 文件预签名下载 URL ----
+
+  const InfoflowBosGetUrlSchema = Type.Object({
+    objectKey: Type.String({
+      description: "BOS 对象的存储路径（object_key），由上传时返回。",
+    }),
+    expirationSeconds: Type.Optional(
+      Type.Number({
+        description: "预签名 URL 的有效期（秒），默认 3600（1 小时），最大 86400（24 小时）。",
+      }),
+    ),
+    accountId: Type.Optional(
+      Type.String({
+        description: "多账号模式下指定账号 ID，不填则使用默认账号。",
+      }),
+    ),
+  });
+
+  type InfoflowBosGetUrlParams = Static<typeof InfoflowBosGetUrlSchema>;
+
+  api.registerTool(
+    {
+      name: "infoflow_bos_get_url",
+      label: "Infoflow BOS Get URL",
+      description:
+        "为已存在的 BOS 文件获取或刷新预签名下载 URL。" +
+        "当用户需要重新获取之前上传文件的下载链接（例如链接已过期）时使用此工具。" +
+        "需要提供上传时返回的 objectKey。",
+      parameters: InfoflowBosGetUrlSchema,
+      async execute(_toolCallId, rawParams) {
+        const params = rawParams as InfoflowBosGetUrlParams;
+        const { objectKey, expirationSeconds, accountId } = params;
+
+        if (!objectKey?.trim()) {
+          return json({ ok: false, error: "objectKey is required" });
+        }
+
+        const account = resolveInfoflowAccount({
+          cfg: api.config!,
+          accountId: accountId ?? undefined,
+        });
+        const { apiHost, appKey, appSecret } = account.config;
+        if (!appKey || !appSecret) {
+          return json({ ok: false, error: "Infoflow appKey/appSecret not configured." });
+        }
+
+        logVerbose(
+          `[infoflow_bos_get_url] objectKey=${objectKey}, expirationSeconds=${expirationSeconds ?? 3600}`,
+        );
+
+        const urlResult = await imBosGetUrl({
+          apiHost,
+          appKey,
+          appSecret,
+          objectKey: objectKey.trim(),
+          expirationSeconds: expirationSeconds ?? undefined,
+        });
+
+        return json({
+          ok: urlResult.ok,
+          url: urlResult.url,
+          expirationSeconds: urlResult.expirationSeconds,
+          ...(urlResult.error ? { error: urlResult.error } : {}),
+        });
+      },
+    },
+    { name: "infoflow_bos_get_url" },
+  );
+
+  api.logger.info?.(
+    "infoflow_tools: Registered infoflow_send, infoflow_recall, infoflow_cron, infoflow_bos_upload and infoflow_bos_get_url tools",
+  );
 }