@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/monitor/thread-title.ts

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

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