fix(cron): route topic targets through plugins

steipete · steipete · commit 645b9c018362 · 2026-05-23T12:23:10.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -55,6 +55,7 @@ Docs: https://docs.openclaw.ai
 
 - CLI/tasks: reject partially numeric `openclaw tasks audit --limit` values so audit limits must be real positive integers instead of accepting strings like `5abc`. (#84901) Thanks @jbetala7.
 - Status/diagnostics: bound deep Docker audit probes so `openclaw status --deep` reports slow container checks instead of hanging behind unbounded inspection. (#85476) Thanks @giodl73-repo.
+- Cron/Telegram: parse forum-topic delivery targets through the Telegram plugin instead of cron core, including `:topic:`, `:topicId`, and legacy slash forms for announce delivery. Thanks @etticat.
 - Twitch: keep stale message-handler cleanup callbacks from removing newer handler registrations for the same account, preserving inbound message delivery after reconnects. Fixes #83888. (#85425) Thanks @alkor2000.
 - Memory/LanceDB: expose public memory artifacts through the active memory provider bridge so memory-wiki imports durable memory files, daily notes, dream reports, and event logs without depending on memory-core internals. Fixes #83604. (#85060) Thanks @brokemac79.
 - Docker setup: stop printing the Gateway bearer token in setup logs and printed follow-up commands.
diff --git a/docs/automation/cron-jobs.md b/docs/automation/cron-jobs.md
@@ -167,7 +167,7 @@ Before an isolated cron run enters the agent runner, OpenClaw checks reachable l
 | `webhook`  | POST finished event payload to a URL                                |
 | `none`     | No runner fallback delivery                                         |
 
-Use `--announce --channel telegram --to "-1001234567890"` for channel delivery. For Telegram forum topics, use `-1001234567890:topic:123`; direct RPC/config callers may also pass `delivery.threadId` as a string or number. Slack/Discord/Mattermost targets should use explicit prefixes (`channel:<id>`, `user:<id>`). Matrix room IDs are case-sensitive; use the exact room ID or `room:!room:server` form from Matrix.
+Use `--announce --channel telegram --to "-1001234567890"` for channel delivery. For Telegram forum topics, use `-1001234567890:topic:123`; OpenClaw also accepts the Telegram-owned `-1001234567890:123` and legacy `-1001234567890/123` topic forms. Direct RPC/config callers may also pass `delivery.threadId` as a string or number. Slack/Discord/Mattermost targets should use explicit prefixes (`channel:<id>`, `user:<id>`). Matrix room IDs are case-sensitive; use the exact room ID or `room:!room:server` form from Matrix.
 
 When announce delivery uses `channel: "last"` or omits `channel`, a provider-prefixed target such as `telegram:123` can select the channel before cron falls back to session history or a single configured channel. Only prefixes advertised by the loaded plugin are provider selectors. If `delivery.channel` is explicit, the target prefix must name the same provider; for example, `channel: "whatsapp"` with `to: "telegram:123"` is rejected instead of letting WhatsApp interpret the Telegram ID as a phone number. Target-kind and service prefixes such as `channel:<id>`, `user:<id>`, `imessage:<handle>`, and `sms:<number>` remain channel-owned target syntax, not provider selectors.
 
diff --git a/extensions/telegram/src/targets.test.ts b/extensions/telegram/src/targets.test.ts
@@ -64,6 +64,14 @@ describe("parseTelegramTarget", () => {
     });
   });
 
+  it("parses legacy chatId/topicId format", () => {
+    expect(parseTelegramTarget("-1001234567890/123")).toEqual({
+      chatId: "-1001234567890",
+      messageThreadId: 123,
+      chatType: "group",
+    });
+  });
+
   it("parses chatId:topic:topicId format", () => {
     expect(parseTelegramTarget("-1001234567890:topic:456")).toEqual({
       chatId: "-1001234567890",
diff --git a/extensions/telegram/src/targets.ts b/extensions/telegram/src/targets.ts
@@ -74,6 +74,7 @@ export function normalizeTelegramLookupTarget(raw: string): string | undefined {
  *
  * Supported formats:
  * - `chatId` (plain chat ID, t.me link, @username, or internal prefixes like `telegram:...`)
+ * - `chatId/topicId` (legacy numeric topic/thread ID)
  * - `chatId:topicId` (numeric topic/thread ID)
  * - `chatId:topic:topicId` (explicit topic marker; preferred)
  */
@@ -100,6 +101,15 @@ export function parseTelegramTarget(to: string): TelegramTarget {
     };
   }
 
+  const slashMatch = /^(-?\d+)\/(\d+)$/.exec(normalized);
+  if (slashMatch) {
+    return {
+      chatId: slashMatch[1],
+      messageThreadId: Number.parseInt(slashMatch[2], 10),
+      chatType: resolveTelegramChatType(slashMatch[1]),
+    };
+  }
+
   const colonMatch = /^(.+):(\d+)$/.exec(normalized);
   if (colonMatch) {
     return {
diff --git a/src/cron/isolated-agent.direct-delivery-core-channels.test.ts b/src/cron/isolated-agent.direct-delivery-core-channels.test.ts
@@ -404,6 +404,18 @@ describe("runCronIsolatedAgentTurn telegram forum-topic direct delivery", () =>
     });
   });
 
+  it("routes legacy slash supergroup topic targets through plugin parsing", async () => {
+    await expectTelegramAnnounceDelivery({
+      to: "-1003774691294/47",
+      payloads: [{ text: "topic 47 completion" }],
+      expected: {
+        chatId: "-1003774691294",
+        text: "topic 47 completion",
+        messageThreadId: 47,
+      },
+    });
+  });
+
   it("delivers only the final assistant-visible text to forum-topic telegram targets", async () => {
     await expectTelegramAnnounceDelivery({
       to: "123:topic:42",
diff --git a/src/cron/isolated-agent.test-setup.ts b/src/cron/isolated-agent.test-setup.ts
@@ -64,6 +64,14 @@ function parseTelegramTargetForTest(raw: string): {
       chatType: "group",
     };
   }
+  const slashPair = /^(-?\d+)\/(\d+)$/i.exec(trimmed);
+  if (slashPair) {
+    return {
+      chatId: slashPair[1],
+      messageThreadId: Number.parseInt(slashPair[2], 10),
+      chatType: slashPair[1].startsWith("-") ? "group" : "direct",
+    };
+  }
   return {
     chatId: trimmed,
     chatType: trimmed.startsWith("-") ? "group" : "unknown",
diff --git a/src/cron/isolated-agent/delivery-target.runtime.ts b/src/cron/isolated-agent/delivery-target.runtime.ts
@@ -1,3 +1,20 @@
+import type { ParsedChannelExplicitTarget } from "../../channels/plugins/target-parsing-loaded.js";
+import type { OpenClawConfig } from "../../config/types.openclaw.js";
+import { resolveOutboundChannelPlugin } from "../../infra/outbound/channel-resolution.js";
 export { getLoadedChannelPluginForRead } from "../../channels/plugins/registry-loaded-read.js";
 export { mapAllowFromEntries } from "../../plugin-sdk/channel-config-helpers.js";
 export { resolveFirstBoundAccountId } from "../../routing/bound-account-read.js";
+
+export function parseExplicitTargetForDelivery(params: {
+  cfg: OpenClawConfig;
+  channel: string;
+  rawTarget: string;
+}): ParsedChannelExplicitTarget | null {
+  return (
+    resolveOutboundChannelPlugin({
+      channel: params.channel,
+      cfg: params.cfg,
+      allowBootstrap: true,
+    })?.messaging?.parseExplicitTarget?.({ raw: params.rawTarget }) ?? null
+  );
+}
diff --git a/src/cron/isolated-agent/delivery-target.test.ts b/src/cron/isolated-agent/delivery-target.test.ts
@@ -917,6 +917,19 @@ describe("resolveDeliveryTarget", () => {
     expect(result.threadId).toBe(1008013);
   });
 
+  it("parses plugin-owned slash topic targets into delivery threadId", async () => {
+    setMainSessionEntry(undefined);
+
+    const result = await resolveDeliveryTarget(makeCfg({ bindings: [] }), AGENT_ID, {
+      channel: "telegram",
+      to: "-100200300/77",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.to).toBe("-100200300");
+    expect(result.threadId).toBe(77);
+  });
+
   it("prefers explicit telegram :topic: targets over session-derived threadId", async () => {
     setLastSessionEntry({
       sessionId: "sess-telegram-topic",
diff --git a/src/cron/isolated-agent/delivery-target.ts b/src/cron/isolated-agent/delivery-target.ts
@@ -9,7 +9,10 @@ import { formatErrorMessage } from "../../infra/errors.js";
 import { maybeResolveIdLikeTarget } from "../../infra/outbound/target-id-resolution.js";
 import { normalizeTargetForProvider } from "../../infra/outbound/target-normalization.js";
 import { tryResolveLoadedOutboundTarget } from "../../infra/outbound/targets-loaded.js";
-import { resolveSessionDeliveryTarget } from "../../infra/outbound/targets-session.js";
+import {
+  resolveSessionDeliveryTarget,
+  type ExplicitTargetParser,
+} from "../../infra/outbound/targets-session.js";
 import type { OutboundChannel } from "../../infra/outbound/targets.js";
 import { normalizeAccountId } from "../../routing/session-key.js";
 import { createLazyImportLoader } from "../../shared/lazy-promise.js";
@@ -64,6 +67,7 @@ async function resolveOutboundTargetWithRuntime(
 function normalizeTargetForThreadCarry(
   channel: Exclude<OutboundChannel, "none"> | undefined,
   to: string | undefined,
+  parseExplicitTarget?: ExplicitTargetParser,
 ): string | undefined {
   if (!channel || !to) {
     return undefined;
@@ -74,7 +78,10 @@ function normalizeTargetForThreadCarry(
     if (!comparable) {
       return undefined;
     }
-    const parsed = parseExplicitTargetForLoadedChannel(channel, comparable);
+    const parsed = (parseExplicitTarget ?? parseExplicitTargetForLoadedChannel)(
+      channel,
+      comparable,
+    );
     const base = parsed?.to ?? comparable;
     return normalizeTargetForProvider(channel, base) ?? base;
   } catch {
@@ -86,15 +93,24 @@ function deliveryTargetsShareThreadRoute(params: {
   channel: Exclude<OutboundChannel, "none"> | undefined;
   to: string | undefined;
   lastTo: string | undefined;
+  parseExplicitTarget?: ExplicitTargetParser;
 }): boolean {
   if (!params.to || !params.lastTo) {
     return false;
   }
   if (params.to === params.lastTo) {
     return true;
   }
-  const normalizedTo = normalizeTargetForThreadCarry(params.channel, params.to);
-  const normalizedLastTo = normalizeTargetForThreadCarry(params.channel, params.lastTo);
+  const normalizedTo = normalizeTargetForThreadCarry(
+    params.channel,
+    params.to,
+    params.parseExplicitTarget,
+  );
+  const normalizedLastTo = normalizeTargetForThreadCarry(
+    params.channel,
+    params.lastTo,
+    params.parseExplicitTarget,
+  );
   return Boolean(normalizedTo && normalizedLastTo && normalizedTo === normalizedLastTo);
 }
 
@@ -128,6 +144,13 @@ export async function resolveDeliveryTarget(
   const requestedChannel = typeof jobPayload.channel === "string" ? jobPayload.channel : "last";
   const explicitTo = typeof jobPayload.to === "string" ? jobPayload.to : undefined;
   const allowMismatchedLastTo = requestedChannel === "last";
+  const deliveryTargetRuntime = await loadDeliveryTargetRuntime();
+  const parseExplicitTarget: ExplicitTargetParser = (channel, rawTarget) =>
+    deliveryTargetRuntime.parseExplicitTargetForDelivery({
+      cfg,
+      channel,
+      rawTarget,
+    });
 
   const sessionCfg = cfg.session;
   const mainSessionKey = resolveAgentMainSessionKey({ cfg, agentId });
@@ -167,6 +190,7 @@ export async function resolveDeliveryTarget(
     explicitTo,
     explicitThreadId: jobPayload.threadId,
     allowMismatchedLastTo,
+    parseExplicitTarget,
   });
 
   let fallbackChannel: Exclude<OutboundChannel, "none"> | undefined;
@@ -197,6 +221,7 @@ export async function resolveDeliveryTarget(
         fallbackChannel,
         allowMismatchedLastTo,
         mode: preliminary.mode,
+        parseExplicitTarget,
       })
     : preliminary;
 
@@ -213,8 +238,11 @@ export async function resolveDeliveryTarget(
       : undefined;
   let accountId = explicitAccountId ?? resolved.accountId;
   if (!accountId && channel) {
-    const { resolveFirstBoundAccountId } = await loadDeliveryTargetRuntime();
-    accountId = resolveFirstBoundAccountId({ cfg, channelId: channel, agentId });
+    accountId = deliveryTargetRuntime.resolveFirstBoundAccountId({
+      cfg,
+      channelId: channel,
+      agentId,
+    });
   }
 
   // job.delivery.accountId takes highest precedence — explicitly set by the job author.
@@ -233,20 +261,11 @@ export async function resolveDeliveryTarget(
         channel,
         to: resolved.to,
         lastTo: resolved.lastTo,
+        parseExplicitTarget,
       }))
       ? resolved.threadId
       : undefined;
 
-  if (channel === "telegram" && typeof toCandidate === "string") {
-    const topicMatch = toCandidate.match(/:topic:(\d+)$/i);
-    if (topicMatch) {
-      if (jobPayload.threadId == null || jobPayload.threadId === "") {
-        threadId = Number(topicMatch[1]);
-      }
-      toCandidate = toCandidate.replace(/:topic:\d+$/i, "");
-    }
-  }
-
   if (!channel) {
     return {
       ok: false,
@@ -263,8 +282,7 @@ export async function resolveDeliveryTarget(
 
   let effectiveAllowFrom: string[] | undefined;
   if (mode === "implicit") {
-    const { getLoadedChannelPluginForRead, mapAllowFromEntries } =
-      await loadDeliveryTargetRuntime();
+    const { getLoadedChannelPluginForRead, mapAllowFromEntries } = deliveryTargetRuntime;
     const channelPlugin = getLoadedChannelPluginForRead(channel);
     const resolvedAccountId = normalizeAccountId(accountId);
     const configuredAllowFromRaw = channelPlugin?.config.resolveAllowFrom?.({
diff --git a/src/infra/outbound/targets-session.ts b/src/infra/outbound/targets-session.ts
@@ -1,10 +1,13 @@
 import {
   parseExplicitTargetForLoadedChannel,
-  resolveRouteTargetForLoadedChannel,
+  type ParsedChannelExplicitTarget,
 } from "../../channels/plugins/target-parsing-loaded.js";
 import type { ChannelOutboundTargetMode } from "../../channels/plugins/types.public.js";
 import type { SessionEntry } from "../../config/sessions.js";
-import { channelRouteTargetsShareConversation } from "../../plugin-sdk/channel-route.js";
+import {
+  channelRouteTargetsShareConversation,
+  resolveChannelRouteTargetWithParser,
+} from "../../plugin-sdk/channel-route.js";
 import { deliveryContextFromSession } from "../../utils/delivery-context.shared.js";
 import {
   isDeliverableMessageChannel,
@@ -30,10 +33,28 @@ export type SessionDeliveryTarget = {
   lastThreadId?: string | number;
 };
 
+export type ExplicitTargetParser = (
+  channel: string,
+  rawTarget: string,
+) => ParsedChannelExplicitTarget | null;
+
+function resolveRouteTarget(params: {
+  channel: string;
+  rawTarget?: string | null;
+  fallbackThreadId?: string | number | null;
+  parseExplicitTarget?: ExplicitTargetParser;
+}) {
+  return resolveChannelRouteTargetWithParser({
+    ...params,
+    parseExplicitTarget: params.parseExplicitTarget ?? parseExplicitTargetForLoadedChannel,
+  });
+}
+
 function parseExplicitTargetWithPlugin(params: {
   channel?: DeliverableMessageChannel;
   fallbackChannel?: DeliverableMessageChannel;
   raw?: string;
+  parseExplicitTarget?: ExplicitTargetParser;
 }) {
   const raw = params.raw?.trim();
   if (!raw) {
@@ -43,7 +64,7 @@ function parseExplicitTargetWithPlugin(params: {
   if (!provider) {
     return null;
   }
-  return parseExplicitTargetForLoadedChannel(provider, raw);
+  return (params.parseExplicitTarget ?? parseExplicitTargetForLoadedChannel)(provider, raw);
 }
 
 export function resolveSessionDeliveryTarget(params: {
@@ -64,25 +85,28 @@ export function resolveSessionDeliveryTarget(params: {
   turnSourceTo?: string;
   turnSourceAccountId?: string;
   turnSourceThreadId?: string | number;
+  parseExplicitTarget?: ExplicitTargetParser;
 }): SessionDeliveryTarget {
   const context = deliveryContextFromSession(params.entry);
   const sessionLastChannel =
     context?.channel && isDeliverableMessageChannel(context.channel) ? context.channel : undefined;
   const parsedSessionTarget = sessionLastChannel
-    ? resolveRouteTargetForLoadedChannel({
+    ? resolveRouteTarget({
         channel: sessionLastChannel,
         rawTarget: context?.to,
         fallbackThreadId: context?.threadId,
+        parseExplicitTarget: params.parseExplicitTarget,
       })
     : null;
 
   const hasTurnSourceChannel = params.turnSourceChannel != null;
   const parsedTurnSourceTarget =
     hasTurnSourceChannel && params.turnSourceChannel
-      ? resolveRouteTargetForLoadedChannel({
+      ? resolveRouteTarget({
           channel: params.turnSourceChannel,
           rawTarget: params.turnSourceTo,
           fallbackThreadId: params.turnSourceThreadId,
+          parseExplicitTarget: params.parseExplicitTarget,
         })
       : null;
   const hasTurnSourceThreadId = parsedTurnSourceTarget?.threadId != null;
@@ -135,6 +159,7 @@ export function resolveSessionDeliveryTarget(params: {
     channel,
     fallbackChannel: !channel ? lastChannel : undefined,
     raw: rawExplicitTo,
+    parseExplicitTarget: params.parseExplicitTarget,
   });
   if (parsedExplicitTarget?.to) {
     explicitTo = parsedExplicitTarget.to;
diff --git a/src/infra/outbound/targets.test-helpers.ts b/src/infra/outbound/targets.test-helpers.ts
@@ -62,8 +62,13 @@ function parseTelegramTargetForTest(raw: string): {
   const trimmed = raw.trim();
   const withoutPrefix = trimmed.replace(/^telegram:/i, "").trim();
   const topicMatch = withoutPrefix.match(/^(.*):topic:(\d+)$/i);
-  const chatId = topicMatch?.[1]?.trim() || withoutPrefix;
-  const messageThreadId = topicMatch?.[2] ? Number.parseInt(topicMatch[2], 10) : undefined;
+  const slashMatch = withoutPrefix.match(/^(-?\d+)\/(\d+)$/i);
+  const chatId = topicMatch?.[1]?.trim() || slashMatch?.[1] || withoutPrefix;
+  const messageThreadId = topicMatch?.[2]
+    ? Number.parseInt(topicMatch[2], 10)
+    : slashMatch?.[2]
+      ? Number.parseInt(slashMatch[2], 10)
+      : undefined;
   const numericId = chatId.startsWith("-") ? chatId.slice(1) : chatId;
   const chatType =
     /^\d+$/.test(numericId) && !chatId.startsWith("-100")
