@kodelyth/discord 2026.5.39 → 2026.5.42

package/src/monitor/thread-title.ts

@@ -0,0 +1,181 @@
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { logVerbose } from "klaw/plugin-sdk/runtime-env";
+import {
+  completeWithPreparedSimpleCompletionModel,
+  extractAssistantText,
+  prepareSimpleCompletionModelForAgent,
+} from "klaw/plugin-sdk/simple-completion-runtime";
+import { withAbortTimeout } from "./timeouts.js";
+
+const DEFAULT_THREAD_TITLE_TIMEOUT_MS = 10_000;
+const MAX_THREAD_TITLE_SOURCE_CHARS = 600;
+const MAX_THREAD_TITLE_CHANNEL_NAME_CHARS = 120;
+const MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS = 320;
+// Budget generous enough to cover reasoning-model thinking tokens plus the
+// short text output. Lower values (e.g. 24) starve reasoning models of output
+// capacity: the entire budget is consumed by the thinking block before any
+// text is emitted, so extractAssistantText returns empty and the rename is
+// silently skipped.
+const DISCORD_THREAD_TITLE_MAX_TOKENS = 512;
+const DISCORD_THREAD_TITLE_SYSTEM_PROMPT =
+  "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.";
+
+export async function generateThreadTitle(params: {
+  cfg: KlawConfig;
+  agentId: string;
+  messageText: string;
+  modelRef?: string;
+  channelName?: string;
+  channelDescription?: string;
+  timeoutMs?: number;
+}): Promise<string | null> {
+  const sourceText = params.messageText.trim();
+  if (!sourceText) {
+    return null;
+  }
+
+  const prepared = await prepareSimpleCompletionModelForAgent({
+    cfg: params.cfg,
+    agentId: params.agentId,
+    ...(params.modelRef ? { modelRef: params.modelRef } : {}),
+    allowMissingApiKeyModes: ["aws-sdk"],
+  });
+  if ("error" in prepared) {
+    const modelLabel = prepared.selection
+      ? `${prepared.selection.provider}/${prepared.selection.modelId}`
+      : "unknown";
+    logVerbose(`thread-title: ${prepared.error} (agent=${params.agentId}, model=${modelLabel})`);
+    return null;
+  }
+
+  try {
+    const promptText = truncateThreadTitleSourceText(sourceText);
+    const userMessage = buildThreadTitleUserMessage({
+      sourceText: promptText,
+      channelName: params.channelName,
+      channelDescription: params.channelDescription,
+    });
+    const timeoutMs = resolveThreadTitleTimeoutMs(params.timeoutMs);
+    const response = await completeThreadTitle({
+      model: prepared.model,
+      auth: prepared.auth,
+      userMessage,
+      timeoutMs,
+    });
+    const generated = normalizeGeneratedThreadTitle(extractAssistantText(response));
+    return generated || null;
+  } catch (err) {
+    logVerbose(`thread-title: title generation failed for agent ${params.agentId}: ${String(err)}`);
+    return null;
+  }
+}
+
+async function completeThreadTitle(params: {
+  model: Parameters<typeof completeWithPreparedSimpleCompletionModel>[0]["model"];
+  auth: Parameters<typeof completeWithPreparedSimpleCompletionModel>[0]["auth"];
+  userMessage: string;
+  timeoutMs: number;
+}) {
+  return await withAbortTimeout({
+    timeoutMs: params.timeoutMs,
+    createTimeoutError: () => new Error(`thread-title timed out after ${params.timeoutMs}ms`),
+    run: async (signal) =>
+      await completeWithPreparedSimpleCompletionModel({
+        model: params.model,
+        auth: params.auth,
+        context: {
+          systemPrompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
+          messages: [
+            {
+              role: "user",
+              content: params.userMessage,
+              timestamp: Date.now(),
+            },
+          ],
+        },
+        options: {
+          maxTokens: DISCORD_THREAD_TITLE_MAX_TOKENS,
+          signal,
+        },
+      }),
+  });
+}
+
+function buildThreadTitleUserMessage(params: {
+  sourceText: string;
+  channelName?: string;
+  channelDescription?: string;
+}): string {
+  const channelName = normalizeTitleContextField(
+    params.channelName,
+    MAX_THREAD_TITLE_CHANNEL_NAME_CHARS,
+  );
+  const channelDescription = normalizeTitleContextField(
+    params.channelDescription,
+    MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS,
+  );
+  const messageLines: string[] = [];
+  if (channelName) {
+    messageLines.push(`Channel: ${channelName}`);
+  }
+  if (channelDescription) {
+    messageLines.push(`Channel description: ${channelDescription}`);
+  }
+  messageLines.push(`Message:\n${params.sourceText}`);
+  return messageLines.join("\n\n");
+}
+
+function truncateThreadTitleSourceText(sourceText: string): string {
+  if (sourceText.length <= MAX_THREAD_TITLE_SOURCE_CHARS) {
+    return sourceText;
+  }
+  return `${sourceText.slice(0, MAX_THREAD_TITLE_SOURCE_CHARS)}...`;
+}
+
+function resolveThreadTitleTimeoutMs(timeoutMs: number | undefined): number {
+  return Math.max(100, Math.floor(timeoutMs ?? DEFAULT_THREAD_TITLE_TIMEOUT_MS));
+}
+
+export function normalizeGeneratedThreadTitle(raw: string): string {
+  const lines = raw.replace(/\r/g, "").split("\n");
+  let firstLine = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (!firstLine && trimmed.startsWith("```")) {
+      continue;
+    }
+    firstLine = trimmed;
+    break;
+  }
+  return stripThreadTitleWrappers(firstLine);
+}
+
+function stripThreadTitleWrappers(raw: string): string {
+  let current = raw.trim();
+  let previous = "";
+  while (current && current !== previous) {
+    previous = current;
+    current = current.replace(/^["'`]+|["'`]+$/g, "").trim();
+    current = current.replace(/^\*\*(.+)\*\*$/u, "$1").trim();
+    current = current.replace(/^__(.+)__$/u, "$1").trim();
+    current = current.replace(/^\*(.+)\*$/u, "$1").trim();
+    current = current.replace(/^_(.+)_$/u, "$1").trim();
+    current = current.replace(/^~~(.+)~~$/u, "$1").trim();
+  }
+  return current;
+}
+
+function normalizeTitleContextField(raw: string | undefined, maxChars: number): string | undefined {
+  const value = raw?.trim();
+  if (!value) {
+    return undefined;
+  }
+  const singleLine = value.replace(/\s+/g, " ");
+  if (singleLine.length <= maxChars) {
+    return singleLine;
+  }
+  return `${singleLine.slice(0, maxChars)}...`;
+}

package/src/monitor/threading.auto-thread.test.ts

@@ -0,0 +1,330 @@
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { ChannelType } from "../internal/discord.js";
+import { EMPTY_DISCORD_TEST_CONFIG } from "../test-support/config.js";
+type MaybeCreateDiscordAutoThreadFn = typeof import("./threading.js").maybeCreateDiscordAutoThread;
+
+const { generateThreadTitleMock } = vi.hoisted(() => ({
+  generateThreadTitleMock: vi.fn(),
+}));
+
+vi.mock("./thread-title.js", () => ({
+  generateThreadTitle: generateThreadTitleMock,
+}));
+
+let maybeCreateDiscordAutoThread: MaybeCreateDiscordAutoThreadFn;
+
+const postMock = vi.fn();
+const getMock = vi.fn();
+const patchMock = vi.fn();
+const mockClient = {
+  rest: { post: postMock, get: getMock, patch: patchMock },
+} as unknown as Parameters<MaybeCreateDiscordAutoThreadFn>[0]["client"];
+const mockMessage = {
+  id: "msg1",
+  timestamp: "123",
+} as unknown as Parameters<MaybeCreateDiscordAutoThreadFn>[0]["message"];
+
+function createBaseParams(
+  overrides: Partial<Parameters<MaybeCreateDiscordAutoThreadFn>[0]> = {},
+): Parameters<MaybeCreateDiscordAutoThreadFn>[0] {
+  return {
+    client: mockClient,
+    message: mockMessage,
+    messageChannelId: "text1",
+    channel: "discord",
+    isGuildMessage: true,
+    channelConfig: { allowed: true, autoThread: true },
+    channelType: ChannelType.GuildText,
+    baseText: "test",
+    combinedBody: "test",
+    cfg: EMPTY_DISCORD_TEST_CONFIG,
+    ...overrides,
+  };
+}
+
+async function flushAsyncWork() {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object") {
+    throw new Error(`expected ${label}`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function callArg(mock: unknown, callIndex: number, argIndex: number, label: string) {
+  const calls = (mock as { mock?: { calls?: Array<Array<unknown>> } }).mock?.calls ?? [];
+  const call = calls.at(callIndex);
+  if (!call) {
+    throw new Error(`Expected ${label}`);
+  }
+  return call[argIndex];
+}
+
+function expectRestBodyField(mock: unknown, field: string, expected: unknown) {
+  expect(callArg(mock, 0, 0, "rest path")).toBeTypeOf("string");
+  const options = requireRecord(callArg(mock, 0, 1, "rest options"), "rest options");
+  const body = requireRecord(options.body, "rest body");
+  expect(body[field]).toBe(expected);
+}
+
+function expectGeneratedTitleField(field: string, expected: unknown) {
+  const params = requireRecord(
+    callArg(generateThreadTitleMock, 0, 0, "thread title params"),
+    "thread title params",
+  );
+  expect(params[field]).toBe(expected);
+}
+
+beforeAll(async () => {
+  ({ maybeCreateDiscordAutoThread } = await import("./threading.js"));
+});
+
+beforeEach(() => {
+  postMock.mockReset();
+  getMock.mockReset();
+  patchMock.mockReset();
+  generateThreadTitleMock.mockReset();
+});
+
+describe("maybeCreateDiscordAutoThread", () => {
+  it("skips auto-thread if channelType is GuildForum", async () => {
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({ channelType: ChannelType.GuildForum }),
+    );
+    expect(result).toBeUndefined();
+    expect(postMock).not.toHaveBeenCalled();
+  });
+
+  it("skips auto-thread if channelType is GuildMedia", async () => {
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({ channelType: ChannelType.GuildMedia }),
+    );
+    expect(result).toBeUndefined();
+    expect(postMock).not.toHaveBeenCalled();
+  });
+
+  it("skips auto-thread if channelType is GuildVoice", async () => {
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({ channelType: ChannelType.GuildVoice }),
+    );
+    expect(result).toBeUndefined();
+    expect(postMock).not.toHaveBeenCalled();
+  });
+
+  it("skips auto-thread if channelType is GuildStageVoice", async () => {
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({ channelType: ChannelType.GuildStageVoice }),
+    );
+    expect(result).toBeUndefined();
+    expect(postMock).not.toHaveBeenCalled();
+  });
+
+  it("creates auto-thread if channelType is GuildText", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    const result = await maybeCreateDiscordAutoThread(createBaseParams());
+    expect(result).toBe("thread1");
+    expect(postMock).toHaveBeenCalled();
+  });
+});
+
+describe("maybeCreateDiscordAutoThread autoArchiveDuration", () => {
+  it("uses configured autoArchiveDuration", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: true, autoArchiveDuration: "10080" },
+      }),
+    );
+    expectRestBodyField(postMock, "auto_archive_duration", 10080);
+  });
+
+  it("accepts numeric autoArchiveDuration", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: true, autoArchiveDuration: 4320 },
+      }),
+    );
+    expectRestBodyField(postMock, "auto_archive_duration", 4320);
+  });
+
+  it("defaults to 60 when autoArchiveDuration not set", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    await maybeCreateDiscordAutoThread(createBaseParams());
+    expectRestBodyField(postMock, "auto_archive_duration", 60);
+  });
+});
+
+describe("maybeCreateDiscordAutoThread autoThreadName", () => {
+  it("renames created thread when generated mode is enabled", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    patchMock.mockResolvedValueOnce({});
+    generateThreadTitleMock.mockResolvedValueOnce("Deploy rollout summary");
+
+    const cfg = { agents: { defaults: { model: "anthropic/claude-opus-4-6" } } } as KlawConfig;
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        baseText: "Need help with deploy rollout",
+        combinedBody: "Need help with deploy rollout",
+        channelName: "klaw",
+        channelDescription: "Klaw development coordination and release planning",
+        channelConfig: { allowed: true, autoThread: true, autoThreadName: "generated" },
+        cfg,
+        agentId: "main",
+      }),
+    );
+    expect(result).toBe("thread1");
+    expectRestBodyField(postMock, "name", "Need help with deploy rollout");
+    await flushAsyncWork();
+    expectGeneratedTitleField("agentId", "main");
+    expectGeneratedTitleField("messageText", "Need help with deploy rollout");
+    expectGeneratedTitleField("channelName", "klaw");
+    expectGeneratedTitleField(
+      "channelDescription",
+      "Klaw development coordination and release planning",
+    );
+    expectRestBodyField(patchMock, "name", "Deploy rollout summary");
+  });
+
+  it("does not block thread creation while title summary is pending", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    patchMock.mockResolvedValueOnce({});
+    let resolveTitle: ((value: string | null) => void) | undefined;
+    generateThreadTitleMock.mockReturnValueOnce(
+      new Promise((resolve: (value: string | null) => void) => {
+        resolveTitle = resolve;
+      }),
+    );
+
+    const cfg = { agents: { defaults: { model: "anthropic/claude-opus-4-6" } } } as KlawConfig;
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: true, autoThreadName: "generated" },
+        cfg,
+        agentId: "main",
+      }),
+    );
+    expect(result).toBe("thread1");
+    expect(patchMock).not.toHaveBeenCalled();
+
+    resolveTitle?.("Async summary");
+    await flushAsyncWork();
+    expect(patchMock).toHaveBeenCalled();
+  });
+
+  it("uses channel-specific thread override for generated title model", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    patchMock.mockResolvedValueOnce({});
+    generateThreadTitleMock.mockResolvedValueOnce("Deploy rollout summary");
+
+    const cfg = {
+      agents: {
+        defaults: { model: "anthropic/claude-opus-4-6" },
+      },
+      channels: {
+        modelByChannel: {
+          discord: {
+            thread1: "openai/gpt-4.1-mini",
+          },
+        },
+      },
+    } as KlawConfig;
+    await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: true, autoThreadName: "generated" },
+        cfg,
+        agentId: "main",
+      }),
+    );
+
+    await flushAsyncWork();
+    expectGeneratedTitleField("modelRef", "openai/gpt-4.1-mini");
+  });
+
+  it("falls back to parent channel override for generated title model", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    patchMock.mockResolvedValueOnce({});
+    generateThreadTitleMock.mockResolvedValueOnce("Deploy rollout summary");
+
+    const cfg = {
+      agents: {
+        defaults: { model: "anthropic/claude-opus-4-6" },
+      },
+      channels: {
+        modelByChannel: {
+          discord: {
+            text1: "openai/gpt-4.1-mini",
+          },
+        },
+      },
+    } as KlawConfig;
+    await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: true, autoThreadName: "generated" },
+        cfg,
+        agentId: "main",
+      }),
+    );
+
+    await flushAsyncWork();
+    expectGeneratedTitleField("modelRef", "openai/gpt-4.1-mini");
+  });
+
+  it("skips summarization when cfg or agentId is missing", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: true, autoThreadName: "generated" },
+      }),
+    );
+    await flushAsyncWork();
+    expect(generateThreadTitleMock).not.toHaveBeenCalled();
+    expect(patchMock).not.toHaveBeenCalled();
+  });
+
+  it("does not rename when autoThreadName is not set", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: true },
+      }),
+    );
+    await flushAsyncWork();
+    expect(generateThreadTitleMock).not.toHaveBeenCalled();
+    expect(patchMock).not.toHaveBeenCalled();
+  });
+
+  it("does not rename when generated title sanitizes to fallback thread name", async () => {
+    postMock.mockResolvedValueOnce({ id: "thread1" });
+    generateThreadTitleMock.mockResolvedValueOnce("<@123456789012345678> <#987654321098765432>");
+
+    const cfg = { agents: { defaults: { model: "anthropic/claude-opus-4-6" } } } as KlawConfig;
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        baseText: "Need help with deploy rollout",
+        combinedBody: "Need help with deploy rollout",
+        channelConfig: { allowed: true, autoThread: true, autoThreadName: "generated" },
+        cfg,
+        agentId: "main",
+      }),
+    );
+
+    expect(result).toBe("thread1");
+    await flushAsyncWork();
+    expect(patchMock).not.toHaveBeenCalled();
+  });
+
+  it("skips thread creation when autoThread is false", async () => {
+    const result = await maybeCreateDiscordAutoThread(
+      createBaseParams({
+        channelConfig: { allowed: true, autoThread: false },
+      }),
+    );
+    expect(result).toBeUndefined();
+    expect(postMock).not.toHaveBeenCalled();
+  });
+});