@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/monitor/thread-channel-context.ts

@@ -1,112 +0,0 @@
-import { ChannelType } from "../internal/discord.js";
-import { normalizeDiscordSlug } from "./allow-list.js";
-import {
-  resolveDiscordChannelIdSafe,
-  resolveDiscordChannelInfoSafe,
-  resolveDiscordChannelParentIdSafe,
-} from "./channel-access.js";
-import {
-  resolveDiscordChannelInfo,
-  type DiscordChannelInfo,
-  type DiscordChannelInfoClient,
-} from "./message-utils.js";
-import { resolveDiscordThreadParentInfo } from "./threading.js";
-
-type DiscordThreadLikeChannelContext = {
-  channelType?: ChannelType;
-  isThreadChannel: boolean;
-  channelId: string;
-  channelName?: string;
-  channelSlug: string;
-  parentId?: string;
-  threadParentId?: string;
-  threadParentName?: string;
-  threadParentSlug: string;
-  channelInfo: DiscordChannelInfo | null;
-};
-
-function isDiscordThreadChannelType(type: ChannelType | number | undefined): boolean {
-  return (
-    type === ChannelType.PublicThread ||
-    type === ChannelType.PrivateThread ||
-    type === ChannelType.AnnouncementThread
-  );
-}
-
-function buildFetchedChannelInfo(channel: unknown): DiscordChannelInfo | null {
-  const channelInfo = resolveDiscordChannelInfoSafe(channel);
-  if (channelInfo.type === undefined) {
-    return null;
-  }
-  return {
-    type: channelInfo.type as ChannelType,
-    name: channelInfo.name,
-    topic: channelInfo.topic,
-    parentId: channelInfo.parentId,
-    ownerId: channelInfo.ownerId,
-  };
-}
-
-export async function resolveDiscordThreadLikeChannelContext(params: {
-  client: DiscordChannelInfoClient;
-  channel: unknown;
-  channelIdFallback?: string;
-  channelInfo?: DiscordChannelInfo | null;
-}): Promise<DiscordThreadLikeChannelContext> {
-  const safeChannelInfo = resolveDiscordChannelInfoSafe(params.channel);
-  const channelId = resolveDiscordChannelIdSafe(params.channel) ?? params.channelIdFallback ?? "";
-  const channelInfo =
-    params.channelInfo !== undefined
-      ? params.channelInfo
-      : channelId
-        ? await resolveDiscordChannelInfo(params.client, channelId)
-        : null;
-  const channelType = (safeChannelInfo.type as ChannelType | undefined) ?? channelInfo?.type;
-  const channelName = safeChannelInfo.name ?? channelInfo?.name;
-  const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
-  const parentId = resolveDiscordChannelParentIdSafe(params.channel) ?? channelInfo?.parentId;
-  const isThreadChannel = isDiscordThreadChannelType(channelType);
-
-  let threadParentId: string | undefined;
-  let threadParentName: string | undefined;
-  let threadParentSlug = "";
-  if (channelId && isThreadChannel) {
-    const parentInfo = await resolveDiscordThreadParentInfo({
-      client: params.client,
-      threadChannel: {
-        id: channelId,
-        name: channelName,
-        parentId,
-        parent: undefined,
-      },
-      channelInfo,
-    });
-    threadParentId = parentInfo.id;
-    threadParentName = parentInfo.name;
-    threadParentSlug = threadParentName ? normalizeDiscordSlug(threadParentName) : "";
-  }
-
-  return {
-    channelType,
-    isThreadChannel,
-    channelId,
-    channelName,
-    channelSlug,
-    parentId,
-    threadParentId,
-    threadParentName,
-    threadParentSlug,
-    channelInfo,
-  };
-}
-
-export async function resolveFetchedDiscordThreadLikeChannelContext(params: {
-  client: DiscordChannelInfoClient;
-  channel: unknown;
-  channelIdFallback?: string;
-}): Promise<DiscordThreadLikeChannelContext> {
-  return await resolveDiscordThreadLikeChannelContext({
-    ...params,
-    channelInfo: buildFetchedChannelInfo(params.channel),
-  });
-}

package/src/monitor/thread-session-close.test.ts

@@ -1,180 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-const hoisted = vi.hoisted(() => {
-  const updateSessionStore = vi.fn();
-  const resolveStorePath = vi.fn(() => "/tmp/openclaw-sessions.json");
-  return { updateSessionStore, resolveStorePath };
-});
-
-vi.mock("openclaw/plugin-sdk/session-store-runtime", async () => {
-  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/session-store-runtime")>(
-    "openclaw/plugin-sdk/session-store-runtime",
-  );
-  return {
-    ...actual,
-    updateSessionStore: hoisted.updateSessionStore,
-    resolveStorePath: hoisted.resolveStorePath,
-  };
-});
-
-let closeDiscordThreadSessions: typeof import("./thread-session-close.js").closeDiscordThreadSessions;
-
-function setupStore(store: Record<string, { updatedAt: number }>) {
-  hoisted.updateSessionStore.mockImplementation(
-    async (_storePath: string, mutator: (s: typeof store) => unknown) => mutator(store),
-  );
-}
-
-const THREAD_ID = "999";
-const OTHER_ID = "111";
-
-const MATCHED_KEY = `agent:main:discord:channel:${THREAD_ID}`;
-const UNMATCHED_KEY = `agent:main:discord:channel:${OTHER_ID}`;
-
-describe("closeDiscordThreadSessions", () => {
-  beforeAll(async () => {
-    ({ closeDiscordThreadSessions } = await import("./thread-session-close.js"));
-  });
-
-  beforeEach(() => {
-    hoisted.updateSessionStore.mockClear();
-    hoisted.resolveStorePath.mockClear();
-    hoisted.resolveStorePath.mockReturnValue("/tmp/openclaw-sessions.json");
-  });
-
-  it("resets updatedAt to 0 for sessions whose key contains the threadId", async () => {
-    const store = {
-      [MATCHED_KEY]: { updatedAt: 1_700_000_000_000 },
-      [UNMATCHED_KEY]: { updatedAt: 1_700_000_000_001 },
-    };
-    setupStore(store);
-
-    const count = await closeDiscordThreadSessions({
-      cfg: {},
-      accountId: "default",
-      threadId: THREAD_ID,
-    });
-
-    expect(count).toBe(1);
-    expect(store[MATCHED_KEY].updatedAt).toBe(0);
-    expect(store[UNMATCHED_KEY].updatedAt).toBe(1_700_000_000_001);
-  });
-
-  it("returns 0 and leaves store unchanged when no session matches", async () => {
-    const store = {
-      [UNMATCHED_KEY]: { updatedAt: 1_700_000_000_001 },
-    };
-    setupStore(store);
-
-    const count = await closeDiscordThreadSessions({
-      cfg: {},
-      accountId: "default",
-      threadId: THREAD_ID,
-    });
-
-    expect(count).toBe(0);
-    expect(store[UNMATCHED_KEY].updatedAt).toBe(1_700_000_000_001);
-  });
-
-  it("resets all matching sessions when multiple keys contain the threadId", async () => {
-    const keyA = `agent:main:discord:channel:${THREAD_ID}`;
-    const keyB = `agent:work:discord:channel:${THREAD_ID}`;
-    const keyC = `agent:main:discord:channel:${OTHER_ID}`;
-    const store = {
-      [keyA]: { updatedAt: 1_000 },
-      [keyB]: { updatedAt: 2_000 },
-      [keyC]: { updatedAt: 3_000 },
-    };
-    setupStore(store);
-
-    const count = await closeDiscordThreadSessions({
-      cfg: {},
-      accountId: "default",
-      threadId: THREAD_ID,
-    });
-
-    expect(count).toBe(2);
-    expect(store[keyA].updatedAt).toBe(0);
-    expect(store[keyB].updatedAt).toBe(0);
-    expect(store[keyC].updatedAt).toBe(3_000);
-  });
-
-  it("does not match a key that contains the threadId as a substring of a longer snowflake", async () => {
-    const longerSnowflake = `${THREAD_ID}00`;
-    const noMatchKey = `agent:main:discord:channel:${longerSnowflake}`;
-    const store = {
-      [noMatchKey]: { updatedAt: 9_999 },
-    };
-    setupStore(store);
-
-    const count = await closeDiscordThreadSessions({
-      cfg: {},
-      accountId: "default",
-      threadId: THREAD_ID,
-    });
-
-    expect(count).toBe(0);
-    expect(store[noMatchKey].updatedAt).toBe(9_999);
-  });
-
-  it("matching is case-insensitive for the session key", async () => {
-    const uppercaseKey = `agent:main:discord:channel:${THREAD_ID.toUpperCase()}`;
-    const store = {
-      [uppercaseKey]: { updatedAt: 5_000 },
-    };
-    setupStore(store);
-
-    const count = await closeDiscordThreadSessions({
-      cfg: {},
-      accountId: "default",
-      threadId: THREAD_ID.toLowerCase(),
-    });
-
-    expect(count).toBe(1);
-    expect(store[uppercaseKey].updatedAt).toBe(0);
-  });
-
-  it("returns 0 immediately when threadId is empty without touching the store", async () => {
-    const count = await closeDiscordThreadSessions({
-      cfg: {},
-      accountId: "default",
-      threadId: "   ",
-    });
-
-    expect(count).toBe(0);
-    expect(hoisted.updateSessionStore).not.toHaveBeenCalled();
-  });
-
-  it("does not recount sessions that were already reset", async () => {
-    const store = {
-      [MATCHED_KEY]: { updatedAt: 0 },
-      [UNMATCHED_KEY]: { updatedAt: 1_700_000_000_001 },
-    };
-    setupStore(store);
-
-    const count = await closeDiscordThreadSessions({
-      cfg: {},
-      accountId: "default",
-      threadId: THREAD_ID,
-    });
-
-    expect(count).toBe(0);
-    expect(store[MATCHED_KEY].updatedAt).toBe(0);
-    expect(store[UNMATCHED_KEY].updatedAt).toBe(1_700_000_000_001);
-  });
-
-  it("resolves the store path using cfg.session.store and accountId", async () => {
-    const store = {};
-    setupStore(store);
-
-    await closeDiscordThreadSessions({
-      cfg: { session: { store: "/custom/path/sessions.json" } },
-      accountId: "my-bot",
-      threadId: THREAD_ID,
-    });
-
-    expect(hoisted.resolveStorePath).toHaveBeenCalledWith("/custom/path/sessions.json", {
-      agentId: "my-bot",
-    });
-  });
-});

package/src/monitor/thread-session-close.ts

@@ -1,63 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { resolveStorePath, updateSessionStore } from "openclaw/plugin-sdk/session-store-runtime";
-import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/text-runtime";
-
-/**
- * Marks every session entry in the store whose key contains {@link threadId}
- * as "reset" by setting `updatedAt` to 0.
- *
- * This mirrors how the daily / idle session reset works: zeroing `updatedAt`
- * makes `evaluateSessionFreshness` treat the session as stale on the next
- * inbound message, so the bot starts a fresh conversation without deleting
- * any on-disk transcript history.
- */
-export async function closeDiscordThreadSessions(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-  threadId: string;
-}): Promise<number> {
-  const { cfg, accountId, threadId } = params;
-
-  const normalizedThreadId = normalizeOptionalLowercaseString(threadId) ?? "";
-  if (!normalizedThreadId) {
-    return 0;
-  }
-
-  // Match when the threadId appears as a complete colon-separated segment.
-  // e.g. "999" must be followed by ":" (middle) or end-of-string (final).
-  // Using a regex avoids false-positives where one snowflake is a prefix of
-  // another (e.g. searching for "999" must not match ":99900").
-  //
-  // Session key shapes:
-  //   agent:<agentId>:discord:channel:<threadId>
-  //   agent:<agentId>:discord:channel:<parentId>:thread:<threadId>
-  const segmentRe = new RegExp(`:${normalizedThreadId}(?::|$)`, "i");
-
-  function sessionKeyContainsThreadId(key: string): boolean {
-    return segmentRe.test(key);
-  }
-
-  // Resolve the store file. We pass `accountId` as `agentId` here to mirror
-  // how other Discord subsystems resolve their per-account sessions stores.
-  const storePath = resolveStorePath(cfg.session?.store, { agentId: accountId });
-
-  let resetCount = 0;
-
-  await updateSessionStore(storePath, (store) => {
-    for (const [key, entry] of Object.entries(store)) {
-      if (!entry || !sessionKeyContainsThreadId(key)) {
-        continue;
-      }
-      if (entry.updatedAt === 0) {
-        continue;
-      }
-      // Setting updatedAt to 0 signals that this session is stale.
-      // evaluateSessionFreshness will create a new session on the next message.
-      entry.updatedAt = 0;
-      resetCount += 1;
-    }
-    return resetCount;
-  });
-
-  return resetCount;
-}

package/src/monitor/thread-title.generate.test.ts

@@ -1,197 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import * as agentRuntimeModule from "openclaw/plugin-sdk/simple-completion-runtime";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { EMPTY_DISCORD_TEST_CONFIG } from "../test-support/config.js";
-
-const completeWithPreparedSimpleCompletionModelMock =
-  vi.fn<typeof agentRuntimeModule.completeWithPreparedSimpleCompletionModel>();
-const prepareSimpleCompletionModelForAgentMock =
-  vi.fn<typeof agentRuntimeModule.prepareSimpleCompletionModelForAgent>();
-const extractAssistantTextMock = vi.fn<typeof agentRuntimeModule.extractAssistantText>();
-
-let generateThreadTitle: typeof import("./thread-title.js").generateThreadTitle;
-
-beforeAll(async () => {
-  ({ generateThreadTitle } = await import("./thread-title.js"));
-});
-
-beforeEach(() => {
-  vi.restoreAllMocks();
-  completeWithPreparedSimpleCompletionModelMock.mockReset();
-  prepareSimpleCompletionModelForAgentMock.mockReset();
-  extractAssistantTextMock.mockReset();
-
-  prepareSimpleCompletionModelForAgentMock.mockResolvedValue({
-    selection: {
-      provider: "anthropic",
-      modelId: "claude-sonnet-4-6",
-      agentDir: "/tmp/openclaw-agent",
-    },
-    model: {
-      provider: "anthropic",
-      id: "claude-sonnet-4-6",
-    },
-    auth: {
-      apiKey: "sk-test",
-      source: "env:TEST_API_KEY",
-      mode: "api-key",
-    },
-  } as Awaited<ReturnType<typeof agentRuntimeModule.prepareSimpleCompletionModelForAgent>>);
-  completeWithPreparedSimpleCompletionModelMock.mockResolvedValue(
-    {} as Awaited<ReturnType<typeof agentRuntimeModule.completeWithPreparedSimpleCompletionModel>>,
-  );
-  extractAssistantTextMock.mockReturnValue("Generated title");
-  vi.spyOn(agentRuntimeModule, "prepareSimpleCompletionModelForAgent").mockImplementation(
-    (...args) => prepareSimpleCompletionModelForAgentMock(...args),
-  );
-  vi.spyOn(agentRuntimeModule, "completeWithPreparedSimpleCompletionModel").mockImplementation(
-    (...args) => completeWithPreparedSimpleCompletionModelMock(...args),
-  );
-  vi.spyOn(agentRuntimeModule, "extractAssistantText").mockImplementation((...args) =>
-    extractAssistantTextMock(...args),
-  );
-});
-
-describe("generateThreadTitle", () => {
-  it("calls shared one-shot model prep with aws-sdk allowance", async () => {
-    prepareSimpleCompletionModelForAgentMock.mockResolvedValueOnce({
-      selection: {
-        provider: "openrouter",
-        modelId: "anthropic/claude-sonnet-4-5",
-        profileId: "work",
-        agentDir: "/tmp/openclaw-agent",
-      },
-      model: {
-        provider: "openrouter",
-        id: "anthropic/claude-sonnet-4-5",
-      },
-      auth: {
-        apiKey: "sk-openrouter",
-        source: "profile:work",
-        mode: "api-key",
-      },
-    } as Awaited<ReturnType<typeof agentRuntimeModule.prepareSimpleCompletionModelForAgent>>);
-    const cfg = {
-      agents: {
-        defaults: {
-          model: "openrouter/anthropic/claude-sonnet-4-5@work",
-        },
-      },
-    } as OpenClawConfig;
-
-    await generateThreadTitle({
-      cfg,
-      agentId: "main",
-      messageText: "Need a generated title.",
-    });
-
-    expect(prepareSimpleCompletionModelForAgentMock).toHaveBeenCalledWith({
-      cfg,
-      agentId: "main",
-      allowMissingApiKeyModes: ["aws-sdk"],
-    });
-  });
-
-  it("passes model override refs into shared model prep", async () => {
-    const cfg = EMPTY_DISCORD_TEST_CONFIG;
-    await generateThreadTitle({
-      cfg,
-      agentId: "main",
-      modelRef: "openai/gpt-4.1-mini@local",
-      messageText: "Need a generated title.",
-    });
-
-    expect(prepareSimpleCompletionModelForAgentMock).toHaveBeenCalledWith({
-      cfg,
-      agentId: "main",
-      modelRef: "openai/gpt-4.1-mini@local",
-      allowMissingApiKeyModes: ["aws-sdk"],
-    });
-  });
-
-  it("returns null when shared model prep cannot resolve selection", async () => {
-    prepareSimpleCompletionModelForAgentMock.mockResolvedValueOnce({
-      error: "No model configured for agent main.",
-    } as Awaited<ReturnType<typeof agentRuntimeModule.prepareSimpleCompletionModelForAgent>>);
-
-    const result = await generateThreadTitle({
-      cfg: EMPTY_DISCORD_TEST_CONFIG,
-      agentId: "main",
-      messageText: "Need a thread title.",
-    });
-
-    expect(result).toBeNull();
-    expect(completeWithPreparedSimpleCompletionModelMock).not.toHaveBeenCalled();
-  });
-
-  it("returns null when shared completion prep fails", async () => {
-    prepareSimpleCompletionModelForAgentMock.mockResolvedValue({
-      error: 'No API key resolved for provider "anthropic" (auth mode: api-key).',
-      selection: {
-        provider: "anthropic",
-        modelId: "claude-sonnet-4-6",
-        agentDir: "/tmp/openclaw-agent",
-      },
-    } as Awaited<ReturnType<typeof agentRuntimeModule.prepareSimpleCompletionModelForAgent>>);
-
-    const result = await generateThreadTitle({
-      cfg: EMPTY_DISCORD_TEST_CONFIG,
-      agentId: "main",
-      messageText: "Need a thread title.",
-    });
-
-    expect(result).toBeNull();
-    expect(completeWithPreparedSimpleCompletionModelMock).not.toHaveBeenCalled();
-  });
-
-  it("builds contextual prompt and forwards completion options", async () => {
-    const result = await generateThreadTitle({
-      cfg: EMPTY_DISCORD_TEST_CONFIG,
-      agentId: "main",
-      messageText: "Summarize deployment blockers and owner follow-ups.",
-      channelName: "release-status",
-      channelDescription: "Deploy updates and incident notes",
-    });
-
-    expect(result).toBe("Generated title");
-    expect(completeWithPreparedSimpleCompletionModelMock).toHaveBeenCalledTimes(1);
-    expect(completeWithPreparedSimpleCompletionModelMock.mock.calls[0]?.[0]?.context).toEqual(
-      expect.objectContaining({
-        systemPrompt:
-          "Generate a concise Discord thread title (3-6 words). Return only the title. Use channel context when provided and avoid redundant channel-name words unless needed for clarity.",
-        messages: [
-          expect.objectContaining({
-            role: "user",
-            content: expect.stringContaining("Channel: release-status"),
-          }),
-        ],
-      }),
-    );
-    expect(
-      completeWithPreparedSimpleCompletionModelMock.mock.calls[0]?.[0]?.context?.messages?.[0]
-        ?.content,
-    ).toContain("Channel description: Deploy updates and incident notes");
-    expect(completeWithPreparedSimpleCompletionModelMock.mock.calls[0]?.[0]?.options).toEqual(
-      expect.objectContaining({
-        maxTokens: 512,
-      }),
-    );
-    expect(
-      completeWithPreparedSimpleCompletionModelMock.mock.calls[0]?.[0]?.options,
-    ).not.toHaveProperty("temperature");
-  });
-
-  it("returns null when completion throws", async () => {
-    completeWithPreparedSimpleCompletionModelMock.mockRejectedValueOnce(
-      new Error("network timeout"),
-    );
-
-    const result = await generateThreadTitle({
-      cfg: EMPTY_DISCORD_TEST_CONFIG,
-      agentId: "main",
-      messageText: "Generate title.",
-    });
-
-    expect(result).toBeNull();
-  });
-});

package/src/monitor/thread-title.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeGeneratedThreadTitle } from "./thread-title.js";
-
-describe("normalizeGeneratedThreadTitle", () => {
-  it("strips quotes and keeps the first non-empty line", () => {
-    expect(normalizeGeneratedThreadTitle(' "Weekly Release Summary"\nExtra text')).toBe(
-      "Weekly Release Summary",
-    );
-  });
-
-  it("skips leading blank lines before selecting a title", () => {
-    expect(normalizeGeneratedThreadTitle('\n\n "Weekly Release Summary"\nExtra text')).toBe(
-      "Weekly Release Summary",
-    );
-  });
-
-  it("skips leading markdown fence lines before selecting a title", () => {
-    expect(normalizeGeneratedThreadTitle("```markdown\nWeekly Release Summary\n```")).toBe(
-      "Weekly Release Summary",
-    );
-  });
-
-  it("strips markdown emphasis wrappers around the full title", () => {
-    expect(normalizeGeneratedThreadTitle("**Scaling ArcherScore Development Roadmap**")).toBe(
-      "Scaling ArcherScore Development Roadmap",
-    );
-    expect(normalizeGeneratedThreadTitle('"__Weekly Release Summary__"')).toBe(
-      "Weekly Release Summary",
-    );
-  });
-});