@openclaw/whatsapp 2026.5.1-beta.1 → 2026.5.2-beta.2

package/src/auto-reply/heartbeat-runner.runtime.ts

@@ -1,33 +0,0 @@
-export { appendCronStyleCurrentTimeLine } from "openclaw/plugin-sdk/agent-runtime";
-export {
-  canonicalizeMainSessionAlias,
-  loadSessionStore,
-  resolveSessionKey,
-  resolveStorePath,
-  updateSessionStore,
-} from "openclaw/plugin-sdk/session-store-runtime";
-export { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
-export {
-  emitHeartbeatEvent,
-  resolveHeartbeatVisibility,
-  resolveIndicatorType,
-} from "openclaw/plugin-sdk/heartbeat-runtime";
-export {
-  hasOutboundReplyContent,
-  resolveSendableOutboundReplyParts,
-} from "openclaw/plugin-sdk/reply-payload";
-export {
-  DEFAULT_HEARTBEAT_ACK_MAX_CHARS,
-  HEARTBEAT_TOKEN,
-  getReplyFromConfig,
-  resolveHeartbeatPrompt,
-  resolveHeartbeatReplyPayload,
-  stripHeartbeatToken,
-} from "openclaw/plugin-sdk/reply-runtime";
-export { normalizeMainKey } from "openclaw/plugin-sdk/routing";
-export { getChildLogger } from "openclaw/plugin-sdk/runtime-env";
-export { redactIdentifier } from "openclaw/plugin-sdk/text-runtime";
-export { resolveWhatsAppHeartbeatRecipients } from "../runtime-api.js";
-export { sendMessageWhatsApp } from "../send.js";
-export { formatError } from "../session.js";
-export { whatsappHeartbeatLog } from "./loggers.js";

package/src/auto-reply/heartbeat-runner.test.ts

@@ -1,214 +0,0 @@
-import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import type { sendMessageWhatsApp } from "../send.js";
-import type { getReplyFromConfig } from "./heartbeat-runner.runtime.js";
-
-const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
-
-const state = vi.hoisted(() => ({
-  visibility: { showAlerts: true, showOk: true, useIndicator: false },
-  store: {} as Record<string, { updatedAt?: number; sessionId?: string }>,
-  snapshot: {
-    key: "k",
-    entry: { sessionId: "s1", updatedAt: 123 },
-    fresh: false,
-    resetPolicy: { mode: "none", atHour: null, idleMinutes: null },
-    dailyResetAt: null as number | null,
-    idleExpiresAt: null as number | null,
-  },
-  events: [] as unknown[],
-  loggerInfoCalls: [] as unknown[][],
-  loggerWarnCalls: [] as unknown[][],
-  heartbeatInfoLogs: [] as string[],
-  heartbeatWarnLogs: [] as string[],
-}));
-
-vi.mock("./heartbeat-runner.runtime.js", () => {
-  const logger = {
-    child: () => logger,
-    info: (...args: unknown[]) => state.loggerInfoCalls.push(args),
-    warn: (...args: unknown[]) => state.loggerWarnCalls.push(args),
-    error: vi.fn(),
-    debug: vi.fn(),
-  };
-  return {
-    DEFAULT_HEARTBEAT_ACK_MAX_CHARS: 32,
-    HEARTBEAT_TOKEN,
-    appendCronStyleCurrentTimeLine: (body: string) =>
-      `${body}\nCurrent time: 2026-02-15T00:00:00Z (mock)`,
-    canonicalizeMainSessionAlias: ({ sessionKey }: { sessionKey: string }) => sessionKey,
-    emitHeartbeatEvent: (event: unknown) => state.events.push(event),
-    formatError: (err: unknown) => `ERR:${String(err)}`,
-    getChildLogger: () => logger,
-    getReplyFromConfig: vi.fn(async () => undefined),
-    hasOutboundReplyContent: (payload: { text?: string } | undefined) =>
-      Boolean(payload?.text?.trim()),
-    loadConfig: () => ({ agents: { defaults: {} }, session: {} }),
-    loadSessionStore: () => state.store,
-    normalizeMainKey: () => null,
-    redactIdentifier,
-    resolveHeartbeatPrompt: (prompt?: string) => prompt || "Heartbeat",
-    resolveHeartbeatReplyPayload: (reply: unknown) => reply,
-    resolveHeartbeatVisibility: () => state.visibility,
-    resolveIndicatorType: (status: string) => `indicator:${status}`,
-    resolveSendableOutboundReplyParts: (payload: { text?: string }) => ({
-      text: payload.text ?? "",
-      hasMedia: false,
-    }),
-    resolveSessionKey: () => "k",
-    resolveStorePath: () => "/tmp/store.json",
-    resolveWhatsAppHeartbeatRecipients: () => [],
-    sendMessageWhatsApp: vi.fn(async () => ({ messageId: "m1" })),
-    stripHeartbeatToken: (text: string) => {
-      const trimmed = text.trim();
-      if (trimmed === HEARTBEAT_TOKEN) {
-        return { shouldSkip: true, text: "" };
-      }
-      return { shouldSkip: false, text: trimmed };
-    },
-    updateSessionStore: async (_path: string, updater: (store: typeof state.store) => void) => {
-      updater(state.store);
-    },
-    whatsappHeartbeatLog: {
-      info: (msg: string) => state.heartbeatInfoLogs.push(msg),
-      warn: (msg: string) => state.heartbeatWarnLogs.push(msg),
-    },
-  };
-});
-
-vi.mock("./session-snapshot.js", () => ({
-  getSessionSnapshot: () => state.snapshot,
-}));
-
-vi.mock("../reconnect.js", () => ({
-  newConnectionId: () => "run-1",
-}));
-
-describe("runWebHeartbeatOnce", () => {
-  let senderMock: ReturnType<typeof vi.fn>;
-  let sender: typeof sendMessageWhatsApp;
-  let replyResolverMock: ReturnType<typeof vi.fn>;
-  let replyResolver: typeof getReplyFromConfig;
-  let runWebHeartbeatOnce: typeof import("./heartbeat-runner.js").runWebHeartbeatOnce;
-
-  const buildRunArgs = (overrides: Record<string, unknown> = {}) => ({
-    cfg: { agents: { defaults: {} }, session: {} } as never,
-    to: "+123",
-    sender,
-    replyResolver,
-    ...overrides,
-  });
-
-  beforeAll(async () => {
-    ({ runWebHeartbeatOnce } = await import("./heartbeat-runner.js"));
-  });
-
-  beforeEach(() => {
-    state.visibility = { showAlerts: true, showOk: true, useIndicator: false };
-    state.store = { k: { updatedAt: 999, sessionId: "s1" } };
-    state.snapshot = {
-      key: "k",
-      entry: { sessionId: "s1", updatedAt: 123 },
-      fresh: false,
-      resetPolicy: { mode: "none", atHour: null, idleMinutes: null },
-      dailyResetAt: null,
-      idleExpiresAt: null,
-    };
-    state.events = [];
-    state.loggerInfoCalls = [];
-    state.loggerWarnCalls = [];
-    state.heartbeatInfoLogs = [];
-    state.heartbeatWarnLogs = [];
-
-    senderMock = vi.fn(async () => ({ messageId: "m1" }));
-    sender = senderMock as unknown as typeof sendMessageWhatsApp;
-    replyResolverMock = vi.fn(async () => undefined);
-    replyResolver = replyResolverMock as unknown as typeof getReplyFromConfig;
-  });
-
-  it("supports manual override body dry-run without sending", async () => {
-    await runWebHeartbeatOnce(buildRunArgs({ overrideBody: "hello", dryRun: true }));
-    expect(senderMock).not.toHaveBeenCalled();
-    expect(state.events).toHaveLength(0);
-  });
-
-  it("sends HEARTBEAT_OK when reply is empty and showOk is enabled", async () => {
-    await runWebHeartbeatOnce(buildRunArgs());
-    expect(senderMock).toHaveBeenCalledWith(
-      "+123",
-      HEARTBEAT_TOKEN,
-      expect.objectContaining({ verbose: false, cfg: expect.any(Object) }),
-    );
-    expect(state.events).toEqual(
-      expect.arrayContaining([expect.objectContaining({ status: "ok-empty", silent: false })]),
-    );
-  });
-
-  it("injects a cron-style Current time line into the heartbeat prompt", async () => {
-    await runWebHeartbeatOnce(
-      buildRunArgs({
-        cfg: { agents: { defaults: { heartbeat: { prompt: "Ops check" } } }, session: {} } as never,
-        dryRun: true,
-      }),
-    );
-    expect(replyResolver).toHaveBeenCalledTimes(1);
-    const ctx = replyResolverMock.mock.calls[0]?.[0];
-    expect(ctx?.Body).toContain("Ops check");
-    expect(ctx?.Body).toContain("Current time: 2026-02-15T00:00:00Z (mock)");
-  });
-
-  it("treats heartbeat token-only replies as ok-token and preserves session updatedAt", async () => {
-    replyResolverMock.mockResolvedValue({ text: HEARTBEAT_TOKEN });
-    await runWebHeartbeatOnce(buildRunArgs());
-    expect(state.store.k?.updatedAt).toBe(123);
-    expect(senderMock).toHaveBeenCalledWith(
-      "+123",
-      HEARTBEAT_TOKEN,
-      expect.objectContaining({ verbose: false, cfg: expect.any(Object) }),
-    );
-    expect(state.events).toEqual(
-      expect.arrayContaining([expect.objectContaining({ status: "ok-token", silent: false })]),
-    );
-  });
-
-  it("skips sending alerts when showAlerts is disabled but still emits a skipped event", async () => {
-    state.visibility = { showAlerts: false, showOk: true, useIndicator: true };
-    replyResolverMock.mockResolvedValue({ text: "ALERT" });
-    await runWebHeartbeatOnce(buildRunArgs());
-    expect(senderMock).not.toHaveBeenCalled();
-    expect(state.events).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ status: "skipped", reason: "alerts-disabled", preview: "ALERT" }),
-      ]),
-    );
-  });
-
-  it("emits failed events when sending throws and rethrows the error", async () => {
-    replyResolverMock.mockResolvedValue({ text: "ALERT" });
-    senderMock.mockRejectedValueOnce(new Error("nope"));
-    await expect(runWebHeartbeatOnce(buildRunArgs())).rejects.toThrow("nope");
-    expect(state.events).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ status: "failed", reason: "ERR:Error: nope" }),
-      ]),
-    );
-  });
-
-  it("redacts recipient and omits body preview in heartbeat logs", async () => {
-    replyResolverMock.mockResolvedValue({ text: "sensitive heartbeat body" });
-    await runWebHeartbeatOnce(buildRunArgs({ dryRun: true }));
-
-    const expected = redactIdentifier("+123");
-    const heartbeatLogs = state.heartbeatInfoLogs.join("\n");
-    const childLoggerLogs = state.loggerInfoCalls.map((entry) => JSON.stringify(entry)).join("\n");
-
-    expect(heartbeatLogs).toContain(expected);
-    expect(heartbeatLogs).not.toContain("+123");
-    expect(heartbeatLogs).not.toContain("sensitive heartbeat body");
-
-    expect(childLoggerLogs).toContain(expected);
-    expect(childLoggerLogs).not.toContain("+123");
-    expect(childLoggerLogs).not.toContain("sensitive heartbeat body");
-    expect(childLoggerLogs).not.toContain('"preview"');
-  });
-});

package/src/auto-reply/heartbeat-runner.ts

@@ -1,330 +0,0 @@
-import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/text-runtime";
-import { newConnectionId } from "../reconnect.js";
-import {
-  DEFAULT_HEARTBEAT_ACK_MAX_CHARS,
-  HEARTBEAT_TOKEN,
-  appendCronStyleCurrentTimeLine,
-  canonicalizeMainSessionAlias,
-  emitHeartbeatEvent,
-  formatError,
-  getRuntimeConfig,
-  getChildLogger,
-  getReplyFromConfig,
-  hasOutboundReplyContent,
-  loadSessionStore,
-  normalizeMainKey,
-  redactIdentifier,
-  resolveHeartbeatPrompt,
-  resolveHeartbeatReplyPayload,
-  resolveHeartbeatVisibility,
-  resolveIndicatorType,
-  resolveSendableOutboundReplyParts,
-  resolveSessionKey,
-  resolveStorePath,
-  resolveWhatsAppHeartbeatRecipients,
-  sendMessageWhatsApp,
-  stripHeartbeatToken,
-  updateSessionStore,
-  whatsappHeartbeatLog,
-} from "./heartbeat-runner.runtime.js";
-import { getSessionSnapshot } from "./session-snapshot.js";
-
-function resolveDefaultAgentIdFromConfig(cfg: ReturnType<typeof getRuntimeConfig>): string {
-  const agents = cfg.agents?.list ?? [];
-  const chosen = agents.find((agent) => agent?.default)?.id ?? agents[0]?.id ?? "main";
-  return normalizeOptionalLowercaseString(chosen) ?? "main";
-}
-
-export async function runWebHeartbeatOnce(opts: {
-  cfg?: ReturnType<typeof getRuntimeConfig>;
-  to: string;
-  verbose?: boolean;
-  replyResolver?: typeof getReplyFromConfig;
-  sender?: typeof sendMessageWhatsApp;
-  sessionId?: string;
-  overrideBody?: string;
-  dryRun?: boolean;
-}) {
-  const { cfg: cfgOverride, to, verbose = false, sessionId, overrideBody, dryRun = false } = opts;
-  const replyResolver = opts.replyResolver ?? getReplyFromConfig;
-  const sender = opts.sender ?? sendMessageWhatsApp;
-  const runId = newConnectionId();
-  const redactedTo = redactIdentifier(to);
-  const heartbeatLogger = getChildLogger({
-    module: "web-heartbeat",
-    runId,
-    to: redactedTo,
-  });
-
-  const cfg = cfgOverride ?? getRuntimeConfig();
-
-  // Resolve heartbeat visibility settings for WhatsApp
-  const visibility = resolveHeartbeatVisibility({ cfg, channel: "whatsapp" });
-  const heartbeatOkText = HEARTBEAT_TOKEN;
-
-  const maybeSendHeartbeatOk = async (): Promise<boolean> => {
-    if (!visibility.showOk) {
-      return false;
-    }
-    if (dryRun) {
-      whatsappHeartbeatLog.info(`[dry-run] heartbeat ok -> ${redactedTo}`);
-      return false;
-    }
-    const sendResult = await sender(to, heartbeatOkText, { verbose, cfg });
-    heartbeatLogger.info(
-      {
-        to: redactedTo,
-        messageId: sendResult.messageId,
-        chars: heartbeatOkText.length,
-        reason: "heartbeat-ok",
-      },
-      "heartbeat ok sent",
-    );
-    whatsappHeartbeatLog.info(`heartbeat ok sent to ${redactedTo} (id ${sendResult.messageId})`);
-    return true;
-  };
-
-  const sessionCfg = cfg.session;
-  const sessionScope = sessionCfg?.scope ?? "per-sender";
-  const mainKey = normalizeMainKey(sessionCfg?.mainKey);
-  // Canonicalize so the written key matches what read paths produce (#29683).
-  const rawSessionKey = resolveSessionKey(sessionScope, { From: to }, mainKey);
-  const sessionKey = canonicalizeMainSessionAlias({
-    cfg,
-    agentId: resolveDefaultAgentIdFromConfig(cfg),
-    sessionKey: rawSessionKey,
-  });
-  if (sessionId) {
-    const storePath = resolveStorePath(cfg.session?.store);
-    const store = loadSessionStore(storePath);
-    const current = store[sessionKey] ?? {};
-    store[sessionKey] = {
-      ...current,
-      sessionId,
-      updatedAt: Date.now(),
-    };
-    await updateSessionStore(storePath, (nextStore) => {
-      const nextCurrent = nextStore[sessionKey] ?? current;
-      nextStore[sessionKey] = {
-        ...nextCurrent,
-        sessionId,
-        updatedAt: Date.now(),
-      };
-    });
-  }
-  const sessionSnapshot = getSessionSnapshot(cfg, to, true, { sessionKey });
-  if (verbose) {
-    heartbeatLogger.info(
-      {
-        to: redactedTo,
-        sessionKey: sessionSnapshot.key,
-        sessionId: sessionId ?? sessionSnapshot.entry?.sessionId ?? null,
-        sessionFresh: sessionSnapshot.fresh,
-        resetMode: sessionSnapshot.resetPolicy.mode,
-        resetAtHour: sessionSnapshot.resetPolicy.atHour,
-        idleMinutes: sessionSnapshot.resetPolicy.idleMinutes ?? null,
-        dailyResetAt: sessionSnapshot.dailyResetAt ?? null,
-        idleExpiresAt: sessionSnapshot.idleExpiresAt ?? null,
-      },
-      "heartbeat session snapshot",
-    );
-  }
-
-  if (overrideBody && overrideBody.trim().length === 0) {
-    throw new Error("Override body must be non-empty when provided.");
-  }
-
-  try {
-    if (overrideBody) {
-      if (dryRun) {
-        whatsappHeartbeatLog.info(
-          `[dry-run] web send -> ${redactedTo} (${overrideBody.trim().length} chars, manual message)`,
-        );
-        return;
-      }
-      const sendResult = await sender(to, overrideBody, { verbose, cfg });
-      emitHeartbeatEvent({
-        status: "sent",
-        to,
-        preview: overrideBody.slice(0, 160),
-        hasMedia: false,
-        channel: "whatsapp",
-        indicatorType: visibility.useIndicator ? resolveIndicatorType("sent") : undefined,
-      });
-      heartbeatLogger.info(
-        {
-          to: redactedTo,
-          messageId: sendResult.messageId,
-          chars: overrideBody.length,
-          reason: "manual-message",
-        },
-        "manual heartbeat message sent",
-      );
-      whatsappHeartbeatLog.info(
-        `manual heartbeat sent to ${redactedTo} (id ${sendResult.messageId})`,
-      );
-      return;
-    }
-
-    if (!visibility.showAlerts && !visibility.showOk && !visibility.useIndicator) {
-      heartbeatLogger.info({ to: redactedTo, reason: "alerts-disabled" }, "heartbeat skipped");
-      emitHeartbeatEvent({
-        status: "skipped",
-        to,
-        reason: "alerts-disabled",
-        channel: "whatsapp",
-      });
-      return;
-    }
-
-    const replyResult = await replyResolver(
-      {
-        Body: appendCronStyleCurrentTimeLine(
-          resolveHeartbeatPrompt(cfg.agents?.defaults?.heartbeat?.prompt),
-          cfg,
-          Date.now(),
-        ),
-        From: to,
-        To: to,
-        MessageSid: sessionId ?? sessionSnapshot.entry?.sessionId,
-      },
-      { isHeartbeat: true },
-      cfg,
-    );
-    const replyPayload = resolveHeartbeatReplyPayload(replyResult);
-
-    if (!replyPayload || !hasOutboundReplyContent(replyPayload)) {
-      heartbeatLogger.info(
-        {
-          to: redactedTo,
-          reason: "empty-reply",
-          sessionId: sessionSnapshot.entry?.sessionId ?? null,
-        },
-        "heartbeat skipped",
-      );
-      const okSent = await maybeSendHeartbeatOk();
-      emitHeartbeatEvent({
-        status: "ok-empty",
-        to,
-        channel: "whatsapp",
-        silent: !okSent,
-        indicatorType: visibility.useIndicator ? resolveIndicatorType("ok-empty") : undefined,
-      });
-      return;
-    }
-
-    const reply = resolveSendableOutboundReplyParts(replyPayload);
-    const hasMedia = reply.hasMedia;
-    const ackMaxChars = Math.max(
-      0,
-      cfg.agents?.defaults?.heartbeat?.ackMaxChars ?? DEFAULT_HEARTBEAT_ACK_MAX_CHARS,
-    );
-    const stripped = stripHeartbeatToken(replyPayload.text, {
-      mode: "heartbeat",
-      maxAckChars: ackMaxChars,
-    });
-    if (stripped.shouldSkip && !hasMedia) {
-      // Don't let heartbeats keep sessions alive: restore previous updatedAt so idle expiry still works.
-      const storePath = resolveStorePath(cfg.session?.store);
-      const store = loadSessionStore(storePath);
-      if (sessionSnapshot.entry && store[sessionSnapshot.key]) {
-        store[sessionSnapshot.key].updatedAt = sessionSnapshot.entry.updatedAt;
-        await updateSessionStore(storePath, (nextStore) => {
-          const nextEntry = nextStore[sessionSnapshot.key];
-          if (!nextEntry) {
-            return;
-          }
-          nextStore[sessionSnapshot.key] = {
-            ...nextEntry,
-            updatedAt: sessionSnapshot.entry.updatedAt,
-          };
-        });
-      }
-
-      heartbeatLogger.info(
-        { to: redactedTo, reason: "heartbeat-token", rawLength: replyPayload.text?.length },
-        "heartbeat skipped",
-      );
-      const okSent = await maybeSendHeartbeatOk();
-      emitHeartbeatEvent({
-        status: "ok-token",
-        to,
-        channel: "whatsapp",
-        silent: !okSent,
-        indicatorType: visibility.useIndicator ? resolveIndicatorType("ok-token") : undefined,
-      });
-      return;
-    }
-
-    if (hasMedia) {
-      heartbeatLogger.warn(
-        { to: redactedTo },
-        "heartbeat reply contained media; sending text only",
-      );
-    }
-
-    const finalText = stripped.text || reply.text;
-
-    // Check if alerts are disabled for WhatsApp
-    if (!visibility.showAlerts) {
-      heartbeatLogger.info({ to: redactedTo, reason: "alerts-disabled" }, "heartbeat skipped");
-      emitHeartbeatEvent({
-        status: "skipped",
-        to,
-        reason: "alerts-disabled",
-        preview: finalText.slice(0, 200),
-        channel: "whatsapp",
-        hasMedia,
-        indicatorType: visibility.useIndicator ? resolveIndicatorType("sent") : undefined,
-      });
-      return;
-    }
-
-    if (dryRun) {
-      heartbeatLogger.info(
-        { to: redactedTo, reason: "dry-run", chars: finalText.length },
-        "heartbeat dry-run",
-      );
-      whatsappHeartbeatLog.info(`[dry-run] heartbeat -> ${redactedTo} (${finalText.length} chars)`);
-      return;
-    }
-
-    const sendResult = await sender(to, finalText, { verbose, cfg });
-    emitHeartbeatEvent({
-      status: "sent",
-      to,
-      preview: finalText.slice(0, 160),
-      hasMedia,
-      channel: "whatsapp",
-      indicatorType: visibility.useIndicator ? resolveIndicatorType("sent") : undefined,
-    });
-    heartbeatLogger.info(
-      {
-        to: redactedTo,
-        messageId: sendResult.messageId,
-        chars: finalText.length,
-      },
-      "heartbeat sent",
-    );
-    whatsappHeartbeatLog.info(`heartbeat alert sent to ${redactedTo}`);
-  } catch (err) {
-    const reason = formatError(err);
-    heartbeatLogger.warn({ to: redactedTo, error: reason }, "heartbeat failed");
-    whatsappHeartbeatLog.warn(`heartbeat failed (${reason})`);
-    emitHeartbeatEvent({
-      status: "failed",
-      to,
-      reason,
-      channel: "whatsapp",
-      indicatorType: visibility.useIndicator ? resolveIndicatorType("failed") : undefined,
-    });
-    throw err;
-  }
-}
-
-export function resolveHeartbeatRecipients(
-  cfg: ReturnType<typeof getRuntimeConfig>,
-  opts: { to?: string; all?: boolean; accountId?: string } = {},
-) {
-  return resolveWhatsAppHeartbeatRecipients(cfg, opts);
-}

package/src/auto-reply/session-snapshot.ts

@@ -1,69 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { normalizeMainKey } from "openclaw/plugin-sdk/routing";
-import {
-  evaluateSessionFreshness,
-  loadSessionStore,
-  resolveChannelResetConfig,
-  resolveThreadFlag,
-  resolveSessionResetPolicy,
-  resolveSessionResetType,
-  resolveSessionKey,
-  resolveStorePath,
-} from "./config.runtime.js";
-
-export function getSessionSnapshot(
-  cfg: OpenClawConfig,
-  from: string,
-  _isHeartbeat = false,
-  ctx?: {
-    sessionKey?: string | null;
-    isGroup?: boolean;
-    messageThreadId?: string | number | null;
-    threadLabel?: string | null;
-    threadStarterBody?: string | null;
-    parentSessionKey?: string | null;
-  },
-) {
-  const sessionCfg = cfg.session;
-  const scope = sessionCfg?.scope ?? "per-sender";
-  const key =
-    ctx?.sessionKey?.trim() ??
-    resolveSessionKey(
-      scope,
-      { From: from, To: "", Body: "" },
-      normalizeMainKey(sessionCfg?.mainKey),
-    );
-  const store = loadSessionStore(resolveStorePath(sessionCfg?.store));
-  const entry = store[key];
-
-  const isThread = resolveThreadFlag({
-    sessionKey: key,
-    messageThreadId: ctx?.messageThreadId ?? null,
-    threadLabel: ctx?.threadLabel ?? null,
-    threadStarterBody: ctx?.threadStarterBody ?? null,
-    parentSessionKey: ctx?.parentSessionKey ?? null,
-  });
-  const resetType = resolveSessionResetType({ sessionKey: key, isGroup: ctx?.isGroup, isThread });
-  const channelReset = resolveChannelResetConfig({
-    sessionCfg,
-    channel: entry?.lastChannel ?? entry?.channel,
-  });
-  const resetPolicy = resolveSessionResetPolicy({
-    sessionCfg,
-    resetType,
-    resetOverride: channelReset,
-  });
-  const now = Date.now();
-  const freshness = entry
-    ? evaluateSessionFreshness({ updatedAt: entry.updatedAt, now, policy: resetPolicy })
-    : { fresh: false };
-  return {
-    key,
-    entry,
-    fresh: freshness.fresh,
-    resetPolicy,
-    resetType,
-    dailyResetAt: freshness.dailyResetAt,
-    idleExpiresAt: freshness.idleExpiresAt,
-  };
-}

package/src/heartbeat-recipients.runtime.ts

@@ -1,6 +0,0 @@
-export { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
-export { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
-export { readChannelAllowFromStoreSync } from "openclaw/plugin-sdk/channel-pairing";
-export { normalizeChannelId } from "openclaw/plugin-sdk/channel-targets";
-export { loadSessionStore, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
-export type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";