@kodelyth/discord 2026.5.42 → 2026.6.1

package/src/outbound-send-context.ts

@@ -1,89 +0,0 @@
-import type { KlawConfig, ReplyToMode } from "klaw/plugin-sdk/config-contracts";
-import { createReplyToFanout, type ReplyToResolution } from "klaw/plugin-sdk/outbound-runtime";
-import { resolveOutboundSendDep, type OutboundSendDeps } from "klaw/plugin-sdk/outbound-send-deps";
-import { normalizeOptionalStringifiedId } from "klaw/plugin-sdk/string-coerce-runtime";
-import { withDiscordDeliveryRetry } from "./delivery-retry.js";
-
-type DiscordSendRuntime = typeof import("./send.js");
-
-export type DiscordSendFn = DiscordSendRuntime["sendMessageDiscord"];
-export type DiscordVoiceSendFn = DiscordSendRuntime["sendVoiceMessageDiscord"];
-type DiscordFormattingOptions = {
-  textLimit?: number;
-  maxLinesPerMessage?: number;
-  tableMode?: NonNullable<Parameters<DiscordSendFn>[2]>["tableMode"];
-  chunkMode?: NonNullable<Parameters<DiscordSendFn>[2]>["chunkMode"];
-};
-
-let discordSendRuntimePromise: Promise<DiscordSendRuntime> | undefined;
-
-export async function loadDiscordSendRuntime(): Promise<DiscordSendRuntime> {
-  discordSendRuntimePromise ??= import("./send.js");
-  return await discordSendRuntimePromise;
-}
-
-export function resolveDiscordOutboundTarget(params: {
-  to: string;
-  threadId?: string | number | null;
-}): string {
-  if (params.threadId == null) {
-    return params.to;
-  }
-  const threadId = normalizeOptionalStringifiedId(params.threadId) ?? "";
-  if (!threadId) {
-    return params.to;
-  }
-  return `channel:${threadId}`;
-}
-
-export function resolveDiscordFormattingOptions(ctx: {
-  formatting?: DiscordFormattingOptions;
-}): DiscordFormattingOptions {
-  const formatting = ctx.formatting;
-  return {
-    textLimit: formatting?.textLimit,
-    maxLinesPerMessage: formatting?.maxLinesPerMessage,
-    tableMode: formatting?.tableMode,
-    chunkMode: formatting?.chunkMode,
-  };
-}
-
-export async function createDiscordPayloadSendContext(ctx: {
-  cfg: KlawConfig;
-  to: string;
-  accountId?: string | null;
-  deps?: OutboundSendDeps;
-  replyToId?: string | null;
-  replyToIdSource?: ReplyToResolution["source"];
-  replyToMode?: ReplyToMode;
-  formatting?: DiscordFormattingOptions;
-  threadId?: string | number | null;
-}): Promise<{
-  target: string;
-  formatting: DiscordFormattingOptions;
-  resolveReplyTo: () => string | undefined;
-  send: DiscordSendFn;
-  sendVoice: DiscordVoiceSendFn;
-  withRetry: <T>(fn: () => Promise<T>) => Promise<T>;
-}> {
-  const runtime = await loadDiscordSendRuntime();
-  return {
-    target: resolveDiscordOutboundTarget({ to: ctx.to, threadId: ctx.threadId }),
-    formatting: resolveDiscordFormattingOptions(ctx),
-    resolveReplyTo: createReplyToFanout({
-      replyToId: ctx.replyToId,
-      replyToIdSource: ctx.replyToIdSource,
-      replyToMode: ctx.replyToMode,
-    }),
-    send: resolveOutboundSendDep<DiscordSendFn>(ctx.deps, "discord") ?? runtime.sendMessageDiscord,
-    sendVoice:
-      resolveOutboundSendDep<DiscordVoiceSendFn>(ctx.deps, "discordVoice") ??
-      runtime.sendVoiceMessageDiscord,
-    withRetry: async (fn) =>
-      await withDiscordDeliveryRetry({
-        cfg: ctx.cfg,
-        accountId: ctx.accountId,
-        fn,
-      }),
-  };
-}

package/src/outbound-session-route.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveDiscordOutboundSessionRoute } from "./outbound-session-route.js";
-
-describe("resolveDiscordOutboundSessionRoute", () => {
-  it("keeps explicit delivery thread ids without adding a session suffix", () => {
-    const route = resolveDiscordOutboundSessionRoute({
-      cfg: {},
-      agentId: "main",
-      target: "channel:123",
-      threadId: "thread-1",
-    });
-
-    expect(route).toEqual({
-      baseSessionKey: "agent:main:discord:channel:123",
-      chatType: "channel",
-      from: "discord:channel:123",
-      peer: { kind: "channel", id: "123" },
-      sessionKey: "agent:main:discord:channel:123",
-      threadId: "thread-1",
-      to: "channel:123",
-    });
-  });
-
-  it("does not promote replyToId into Discord delivery thread metadata", () => {
-    const route = resolveDiscordOutboundSessionRoute({
-      cfg: {},
-      agentId: "main",
-      target: "channel:123",
-      replyToId: "message-1",
-    });
-
-    expect(route).toEqual({
-      baseSessionKey: "agent:main:discord:channel:123",
-      chatType: "channel",
-      from: "discord:channel:123",
-      peer: { kind: "channel", id: "123" },
-      sessionKey: "agent:main:discord:channel:123",
-      to: "channel:123",
-    });
-    expect(route?.threadId).toBeUndefined();
-  });
-});

package/src/outbound-session-route.ts

@@ -1,72 +0,0 @@
-import { buildThreadAwareOutboundSessionRoute } from "klaw/plugin-sdk/channel-core";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { buildOutboundBaseSessionKey, type RoutePeer } from "klaw/plugin-sdk/routing";
-import { parseDiscordTarget } from "./target-parsing.js";
-
-export type ResolveDiscordOutboundSessionRouteParams = {
-  cfg: KlawConfig;
-  agentId: string;
-  accountId?: string | null;
-  target: string;
-  resolvedTarget?: { kind: string };
-  replyToId?: string | null;
-  threadId?: string | number | null;
-};
-
-export function resolveDiscordOutboundSessionRoute(
-  params: ResolveDiscordOutboundSessionRouteParams,
-) {
-  const parsed = parseDiscordTarget(params.target, {
-    defaultKind: resolveDiscordOutboundTargetKindHint(params),
-  });
-  if (!parsed) {
-    return null;
-  }
-  const isDm = parsed.kind === "user";
-  const peer: RoutePeer = {
-    kind: isDm ? "direct" : "channel",
-    id: parsed.id,
-  };
-  const baseSessionKey = buildOutboundBaseSessionKey({
-    cfg: params.cfg,
-    agentId: params.agentId,
-    channel: "discord",
-    accountId: params.accountId,
-    peer,
-  });
-  return buildThreadAwareOutboundSessionRoute({
-    route: {
-      sessionKey: baseSessionKey,
-      baseSessionKey,
-      peer,
-      chatType: isDm ? ("direct" as const) : ("channel" as const),
-      from: isDm ? `discord:${parsed.id}` : `discord:channel:${parsed.id}`,
-      to: isDm ? `user:${parsed.id}` : `channel:${parsed.id}`,
-    },
-    threadId: params.threadId,
-    precedence: ["threadId"],
-    useSuffix: false,
-  });
-}
-
-function resolveDiscordOutboundTargetKindHint(params: {
-  target: string;
-  resolvedTarget?: { kind: string };
-}): "user" | "channel" | undefined {
-  const resolvedKind = params.resolvedTarget?.kind;
-  if (resolvedKind === "user") {
-    return "user";
-  }
-  if (resolvedKind === "group" || resolvedKind === "channel") {
-    return "channel";
-  }
-
-  const target = params.target.trim();
-  if (/^channel:/i.test(target)) {
-    return "channel";
-  }
-  if (/^(user:|discord:|@|<@!?)/i.test(target)) {
-    return "user";
-  }
-  return undefined;
-}

package/src/pluralkit.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { fetchPluralKitMessageInfo } from "./pluralkit.js";
-
-type MockResponse = {
-  status: number;
-  ok: boolean;
-  text: () => Promise<string>;
-  json: () => Promise<unknown>;
-};
-
-const buildResponse = (params: { status: number; body?: unknown }): MockResponse => {
-  const body = params.body;
-  const textPayload = typeof body === "string" ? body : body == null ? "" : JSON.stringify(body);
-  return {
-    status: params.status,
-    ok: params.status >= 200 && params.status < 300,
-    text: async () => textPayload,
-    json: async () => body ?? {},
-  };
-};
-
-describe("fetchPluralKitMessageInfo", () => {
-  it("returns null when disabled", async () => {
-    const fetcher = vi.fn();
-    const result = await fetchPluralKitMessageInfo({
-      messageId: "123",
-      config: { enabled: false },
-      fetcher: fetcher as unknown as typeof fetch,
-    });
-    expect(result).toBeNull();
-    expect(fetcher).not.toHaveBeenCalled();
-  });
-
-  it("returns null on 404", async () => {
-    const fetcher = vi.fn(async () => buildResponse({ status: 404 }));
-    const result = await fetchPluralKitMessageInfo({
-      messageId: "missing",
-      config: { enabled: true },
-      fetcher: fetcher as unknown as typeof fetch,
-    });
-    expect(result).toBeNull();
-  });
-
-  it("returns payload and sends token when configured", async () => {
-    let receivedHeaders: Record<string, string> | undefined;
-    const fetcher = vi.fn(async (_url: string, init?: RequestInit) => {
-      receivedHeaders = init?.headers as Record<string, string> | undefined;
-      return buildResponse({
-        status: 200,
-        body: {
-          id: "123",
-          member: { id: "mem_1", name: "Alex" },
-          system: { id: "sys_1", name: "System" },
-        },
-      });
-    });
-
-    const result = await fetchPluralKitMessageInfo({
-      messageId: "123",
-      config: { enabled: true, token: "pk_test" },
-      fetcher: fetcher as unknown as typeof fetch,
-    });
-
-    expect(result?.member?.id).toBe("mem_1");
-    expect(receivedHeaders?.Authorization).toBe("pk_test");
-  });
-});

package/src/pluralkit.ts

@@ -1,58 +0,0 @@
-import { resolveFetch } from "klaw/plugin-sdk/fetch-runtime";
-
-const PLURALKIT_API_BASE = "https://api.pluralkit.me/v2";
-
-export type DiscordPluralKitConfig = {
-  enabled?: boolean;
-  token?: string;
-};
-
-export type PluralKitSystemInfo = {
-  id: string;
-  name?: string | null;
-  tag?: string | null;
-};
-
-export type PluralKitMemberInfo = {
-  id: string;
-  name?: string | null;
-  display_name?: string | null;
-};
-
-export type PluralKitMessageInfo = {
-  id: string;
-  original?: string | null;
-  sender?: string | null;
-  system?: PluralKitSystemInfo | null;
-  member?: PluralKitMemberInfo | null;
-};
-
-export async function fetchPluralKitMessageInfo(params: {
-  messageId: string;
-  config?: DiscordPluralKitConfig;
-  fetcher?: typeof fetch;
-}): Promise<PluralKitMessageInfo | null> {
-  if (!params.config?.enabled) {
-    return null;
-  }
-  const fetchImpl = resolveFetch(params.fetcher);
-  if (!fetchImpl) {
-    return null;
-  }
-  const headers: Record<string, string> = {};
-  if (params.config.token?.trim()) {
-    headers.Authorization = params.config.token.trim();
-  }
-  const res = await fetchImpl(`${PLURALKIT_API_BASE}/messages/${params.messageId}`, {
-    headers,
-  });
-  if (res.status === 404) {
-    return null;
-  }
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    const detail = text.trim() ? `: ${text.trim()}` : "";
-    throw new Error(`PluralKit API failed (${res.status})${detail}`);
-  }
-  return (await res.json()) as PluralKitMessageInfo;
-}

package/src/preview-streaming.ts

@@ -1,18 +0,0 @@
-import {
-  resolveChannelPreviewStreamMode,
-  type StreamingMode,
-} from "klaw/plugin-sdk/channel-streaming";
-
-type DiscordPreviewStreamMode = StreamingMode;
-
-export function resolveDiscordPreviewStreamMode(
-  params: {
-    streamMode?: unknown;
-    streaming?: unknown;
-  } = {},
-): DiscordPreviewStreamMode {
-  if (params.streaming === undefined && params.streamMode === undefined) {
-    return "progress";
-  }
-  return resolveChannelPreviewStreamMode(params, "off");
-}

package/src/probe.intents.test.ts

@@ -1,94 +0,0 @@
-import { withFetchPreconnect } from "klaw/plugin-sdk/test-env";
-import { describe, expect, it } from "vitest";
-import {
-  fetchDiscordApplicationId,
-  fetchDiscordApplicationSummary,
-  resolveDiscordPrivilegedIntentsFromFlags,
-} from "./probe.js";
-import { jsonResponse } from "./test-http-helpers.js";
-
-describe("resolveDiscordPrivilegedIntentsFromFlags", () => {
-  it("reports disabled when no bits set", () => {
-    expect(resolveDiscordPrivilegedIntentsFromFlags(0)).toEqual({
-      presence: "disabled",
-      guildMembers: "disabled",
-      messageContent: "disabled",
-    });
-  });
-
-  it("reports enabled when full intent bits set", () => {
-    const flags = (1 << 12) | (1 << 14) | (1 << 18);
-    expect(resolveDiscordPrivilegedIntentsFromFlags(flags)).toEqual({
-      presence: "enabled",
-      guildMembers: "enabled",
-      messageContent: "enabled",
-    });
-  });
-
-  it("reports limited when limited intent bits set", () => {
-    const flags = (1 << 13) | (1 << 15) | (1 << 19);
-    expect(resolveDiscordPrivilegedIntentsFromFlags(flags)).toEqual({
-      presence: "limited",
-      guildMembers: "limited",
-      messageContent: "limited",
-    });
-  });
-
-  it("prefers enabled over limited when both set", () => {
-    const flags = (1 << 12) | (1 << 13) | (1 << 14) | (1 << 15) | (1 << 18) | (1 << 19);
-    expect(resolveDiscordPrivilegedIntentsFromFlags(flags)).toEqual({
-      presence: "enabled",
-      guildMembers: "enabled",
-      messageContent: "enabled",
-    });
-  });
-
-  it("retries Cloudflare HTML rate limits during application id lookup", async () => {
-    let calls = 0;
-    const fetcher = withFetchPreconnect(async () => {
-      calls += 1;
-      if (calls === 1) {
-        return new Response("<html><title>Error 1015</title></html>", {
-          status: 429,
-          headers: { "content-type": "text/html", "retry-after": "0" },
-        });
-      }
-      return jsonResponse({ id: "app-1" });
-    });
-
-    await expect(fetchDiscordApplicationId("unparseable.token", 1_000, fetcher)).resolves.toBe(
-      "app-1",
-    );
-    expect(calls).toBe(2);
-  });
-
-  it("does not retry Cloudflare HTML rate limits during application summary probes", async () => {
-    let calls = 0;
-    const fetcher = withFetchPreconnect(async () => {
-      calls += 1;
-      return new Response("<html><title>Error 1015</title></html>", {
-        status: 429,
-        headers: { "content-type": "text/html" },
-      });
-    });
-
-    await expect(
-      fetchDiscordApplicationSummary("unparseable.token", 1_000, fetcher),
-    ).resolves.toBeUndefined();
-    expect(calls).toBe(1);
-  });
-
-  it("derives application id from parseable tokens before probing REST", async () => {
-    let calls = 0;
-    const fetcher = withFetchPreconnect(async () => {
-      calls += 1;
-      return new Response("<html><title>Error 1015</title></html>", {
-        status: 429,
-        headers: { "content-type": "text/html" },
-      });
-    });
-
-    await expect(fetchDiscordApplicationId("MTIz.abc.def", 1_000, fetcher)).resolves.toBe("123");
-    expect(calls).toBe(0);
-  });
-});

package/src/probe.parse-token.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseApplicationIdFromToken } from "./probe.js";
-
-describe("parseApplicationIdFromToken", () => {
-  it("extracts application ID from a valid token", () => {
-    // "1234567890" base64-encoded is "MTIzNDU2Nzg5MA=="
-    const token = `${Buffer.from("1234567890").toString("base64")}.timestamp.hmac`;
-    expect(parseApplicationIdFromToken(token)).toBe("1234567890");
-  });
-
-  it("extracts large snowflake IDs without precision loss", () => {
-    // ID that exceeds Number.MAX_SAFE_INTEGER (2^53 - 1 = 9007199254740991)
-    const largeId = "1477179610322964541";
-    const token = `${Buffer.from(largeId).toString("base64")}.GhIiP9.vU1xEpJ6NjFm`;
-    expect(parseApplicationIdFromToken(token)).toBe(largeId);
-  });
-
-  it("handles tokens with Bot prefix", () => {
-    const token = `Bot ${Buffer.from("9876543210").toString("base64")}.ts.hmac`;
-    expect(parseApplicationIdFromToken(token)).toBe("9876543210");
-  });
-
-  it("returns undefined for empty string", () => {
-    expect(parseApplicationIdFromToken("")).toBeUndefined();
-  });
-
-  it("returns undefined for token without dots", () => {
-    expect(parseApplicationIdFromToken("nodots")).toBeUndefined();
-  });
-
-  it("returns undefined when decoded segment is not numeric", () => {
-    const token = `${Buffer.from("not-a-number").toString("base64")}.ts.hmac`;
-    expect(parseApplicationIdFromToken(token)).toBeUndefined();
-  });
-
-  it("returns undefined for whitespace-only input", () => {
-    expect(parseApplicationIdFromToken("   ")).toBeUndefined();
-  });
-
-  it("returns undefined when first segment is empty (starts with dot)", () => {
-    expect(parseApplicationIdFromToken(".ts.hmac")).toBeUndefined();
-  });
-});

package/src/probe.runtime.ts

@@ -1 +0,0 @@
-export * from "./probe.js";