@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,197 @@
+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

@@ -0,0 +1,31 @@
+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",
+    );
+  });
+});