@andreprado/agentkit 0.1.0-alpha.19 → 0.1.0-alpha.20

package/src/cli/commands/feedback.ts

@@ -0,0 +1,438 @@
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { AgentKitError } from "../../runtime/errors";
+import { findAgentCapsuleRoot, loadAgentCapsule } from "../../runtime/config";
+import { readLocalDeployStateIfExists } from "../../runtime/core/deploy-state";
+import type { ParsedArgs } from "../args";
+import {
+  cloudApiRequest,
+  readCloudAuthForApiUrl,
+  resolveCloudApiUrl,
+  type FeedbackSendResponse,
+} from "../cloud-client";
+import { parseOptionalStringFlag } from "../flags";
+
+type FeedbackKind =
+  | "bug"
+  | "confusion"
+  | "missing_docs"
+  | "feature_request"
+  | "deploy_issue"
+  | "runtime_issue"
+  | "other";
+
+type FeedbackAbout = "last-run" | "deploy" | "manual";
+
+type FeedbackDraft = {
+  schema_version: "agentkit.feedback.v1";
+  client_report_id: string;
+  kind: FeedbackKind;
+  summary: string;
+  message?: string;
+  source: Record<string, unknown>;
+  context: Record<string, unknown>;
+  diagnostics: Record<string, unknown>;
+};
+
+const feedbackKinds = new Set<FeedbackKind>([
+  "bug",
+  "confusion",
+  "missing_docs",
+  "feature_request",
+  "deploy_issue",
+  "runtime_issue",
+  "other",
+]);
+
+const feedbackAboutValues = new Set<FeedbackAbout>(["last-run", "deploy", "manual"]);
+
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+
+export async function handleFeedbackCommand(args: ParsedArgs): Promise<void> {
+  const [subcommand, draftPath] = args.positional;
+
+  if (subcommand === "create") {
+    const draft = await buildFeedbackDraft(process.cwd(), args);
+    const written = await writeFeedbackDraft(process.cwd(), draft, args.flags.out);
+
+    console.log("Feedback draft created");
+    console.log(`JSON: ${relativePath(process.cwd(), written.jsonPath)}`);
+    console.log(`Markdown: ${relativePath(process.cwd(), written.markdownPath)}`);
+    console.log(`Send: agentkit feedback send ${relativePath(process.cwd(), written.jsonPath)}`);
+    return;
+  }
+
+  if (subcommand === "preview") {
+    const draft = draftPath
+      ? await readFeedbackDraft(resolve(process.cwd(), draftPath))
+      : await buildFeedbackDraft(process.cwd(), args);
+    console.log(JSON.stringify(draft, null, 2));
+    return;
+  }
+
+  if (subcommand === "send") {
+    const apiUrl = await resolveCloudApiUrl(args.flags.api);
+    const auth = await readCloudAuthForApiUrl(apiUrl);
+
+    if (!auth) {
+      throw new AgentKitError(
+        "auth_required",
+        `Log in before sending feedback: agentkit login --token <token> --api ${apiUrl}`,
+      );
+    }
+
+    const draft = draftPath
+      ? await readFeedbackDraft(resolve(process.cwd(), draftPath))
+      : await buildFeedbackDraft(process.cwd(), args);
+
+    if (!draftPath && args.flags.save === true) {
+      const written = await writeFeedbackDraft(process.cwd(), draft, args.flags.out);
+      console.log(`Feedback draft saved: ${relativePath(process.cwd(), written.jsonPath)}`);
+    }
+
+    const payload = (await cloudApiRequest(apiUrl, "/v1/feedback", {
+      method: "POST",
+      headers: {
+        "Idempotency-Key": draft.client_report_id,
+      },
+      body: JSON.stringify(feedbackDraftToSubmission(draft)),
+    })) as FeedbackSendResponse;
+
+    const feedback = payload.feedback;
+
+    if (!feedback?.id) {
+      throw new AgentKitError("feedback_response_invalid", "AgentKit Cloud returned an invalid feedback response.");
+    }
+
+    console.log("Feedback sent");
+    console.log(`ID:     ${feedback.id}`);
+    console.log(`Kind:   ${feedback.kind ?? draft.kind}`);
+    console.log(`Status: ${feedback.status ?? "new"}`);
+    return;
+  }
+
+  throw new Error(
+    "Usage: agentkit feedback create|preview|send [draft.json] [--about last-run|deploy|manual] [--kind bug|confusion|missing_docs|feature_request|deploy_issue|runtime_issue|other] [--summary <text>] [--message <text>] [--api <url>]",
+  );
+}
+
+async function buildFeedbackDraft(cwd: string, args: ParsedArgs): Promise<FeedbackDraft> {
+  const about = parseFeedbackAbout(args.flags.about);
+  const kind = parseFeedbackKind(args.flags.kind, about === "deploy" ? "deploy_issue" : "other");
+  const message = parseOptionalStringFlag(args.flags.message, "message", "agentkit feedback create --message <text>");
+  const summary =
+    parseOptionalStringFlag(args.flags.summary, "summary", "agentkit feedback create --summary <text>") ??
+    summarizeMessage(message);
+
+  if (!summary) {
+    throw new Error("Missing summary. Usage: agentkit feedback create --summary <text> [--message <text>]");
+  }
+
+  const now = new Date().toISOString();
+  const context = await collectFeedbackContext(cwd);
+  const draft: FeedbackDraft = {
+    schema_version: "agentkit.feedback.v1",
+    client_report_id: `fbdraft_${Date.now().toString(36)}_${randomBytes(6).toString("hex")}`,
+    kind,
+    summary: redactText(summary).slice(0, 200),
+    ...(message ? { message: redactText(message).slice(0, 5_000) } : {}),
+    source: {
+      channel: "cli",
+      about,
+      created_at: now,
+      agentkit_version: await readAgentKitVersion(),
+    },
+    context,
+    diagnostics: {
+      redaction: "agentkit-cli-redaction-v1",
+      note:
+        about === "last-run"
+          ? "AgentKit does not persist a last-command transcript yet; this draft includes current capsule and deploy context."
+          : "This draft includes current capsule and deploy context.",
+    },
+  };
+
+  return redactJson(draft) as FeedbackDraft;
+}
+
+async function collectFeedbackContext(cwd: string): Promise<Record<string, unknown>> {
+  const context: Record<string, unknown> = {
+    platform: {
+      node: process.version,
+      bun: (globalThis as { Bun?: { version?: string } }).Bun?.version,
+      platform: process.platform,
+      arch: process.arch,
+      package_manager: await detectPackageManager(cwd),
+    },
+  };
+
+  const root = await findAgentCapsuleRoot(cwd).catch(() => null);
+
+  if (!root) {
+    context.capsule = {
+      detected: false,
+      cwd_name: basename(cwd),
+    };
+    return redactJson(context) as Record<string, unknown>;
+  }
+
+  const capsule = await loadAgentCapsule(root).catch((error: unknown) => ({
+    error: error instanceof Error ? error.message : String(error),
+  }));
+  const deployState = await readLocalDeployStateIfExists(root).catch(() => null);
+
+  if ("config" in capsule) {
+    context.capsule = {
+      detected: true,
+      root_name: basename(root),
+      name: capsule.config.name,
+      runtime: capsule.config.runtime,
+      provider: capsule.config.provider,
+      access: capsule.config.access,
+      storage: capsule.config.storage,
+      secret_names: capsule.config.secrets,
+      tool_count: capsule.config.tools?.length ?? 0,
+      channel_count: capsule.config.channels?.length ?? 0,
+    };
+  } else {
+    context.capsule = {
+      detected: true,
+      root_name: basename(root),
+      load_error: capsule.error,
+    };
+  }
+
+  if (deployState) {
+    context.deploy = {
+      project_id: deployState.project_id,
+      deploy_id: deployState.deploy_id,
+      target: deployState.target,
+      runtime: deployState.runtime,
+      owner_state: deployState.owner_state,
+      access: deployState.access,
+      url: deployState.url,
+      created_at: deployState.created_at,
+    };
+  }
+
+  return redactJson(context) as Record<string, unknown>;
+}
+
+async function detectPackageManager(cwd: string): Promise<string> {
+  const candidates = [
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["package-lock.json", "npm"],
+  ] as const;
+
+  for (const [file, name] of candidates) {
+    if (await pathExists(join(cwd, file))) {
+      return name;
+    }
+  }
+
+  return "unknown";
+}
+
+async function writeFeedbackDraft(
+  cwd: string,
+  draft: FeedbackDraft,
+  outFlag: string | boolean | undefined,
+): Promise<{ jsonPath: string; markdownPath: string }> {
+  const out = parseOptionalStringFlag(outFlag, "out", "agentkit feedback create --out <path>");
+  const defaultDir = join(cwd, ".agentkit", "feedback");
+  const slug = slugify(draft.summary);
+  const filename = `${new Date().toISOString().replace(/[:.]/g, "-")}-${slug}`;
+  const jsonPath = out && extname(out) === ".json" ? resolve(cwd, out) : join(out ? resolve(cwd, out) : defaultDir, `${filename}.json`);
+  const markdownPath = jsonPath.replace(/\.json$/, ".md");
+
+  await mkdir(dirname(jsonPath), { recursive: true });
+  await writeFile(jsonPath, `${JSON.stringify(draft, null, 2)}\n`, { mode: 0o600 });
+  await chmod(jsonPath, 0o600);
+  await writeFile(markdownPath, renderFeedbackMarkdown(draft), { mode: 0o600 });
+  await chmod(markdownPath, 0o600);
+
+  return { jsonPath, markdownPath };
+}
+
+async function readFeedbackDraft(path: string): Promise<FeedbackDraft> {
+  const parsed = JSON.parse(await readFile(path, "utf8")) as unknown;
+  const draft = validateFeedbackDraft(parsed);
+
+  if (!draft) {
+    throw new AgentKitError("feedback_draft_invalid", "Feedback draft must be an agentkit.feedback.v1 JSON object.");
+  }
+
+  return redactJson(draft) as FeedbackDraft;
+}
+
+function validateFeedbackDraft(value: unknown): FeedbackDraft | null {
+  if (!isRecord(value) || value.schema_version !== "agentkit.feedback.v1") {
+    return null;
+  }
+
+  if (typeof value.client_report_id !== "string" || !/^[A-Za-z0-9._:-]{1,128}$/.test(value.client_report_id)) {
+    return null;
+  }
+
+  if (!isFeedbackKind(value.kind) || typeof value.summary !== "string" || !isRecord(value.source)) {
+    return null;
+  }
+
+  return {
+    schema_version: "agentkit.feedback.v1",
+    client_report_id: value.client_report_id,
+    kind: value.kind,
+    summary: redactText(value.summary).slice(0, 200),
+    ...(typeof value.message === "string" ? { message: redactText(value.message).slice(0, 5_000) } : {}),
+    source: redactJson(value.source) as Record<string, unknown>,
+    context: isRecord(value.context) ? redactJson(value.context) as Record<string, unknown> : {},
+    diagnostics: isRecord(value.diagnostics) ? redactJson(value.diagnostics) as Record<string, unknown> : {},
+  };
+}
+
+function feedbackDraftToSubmission(draft: FeedbackDraft): Record<string, unknown> {
+  return {
+    kind: draft.kind,
+    summary: draft.summary,
+    ...(draft.message ? { message: draft.message } : {}),
+    source: draft.source,
+    context: draft.context,
+    diagnostics: draft.diagnostics,
+    client_report_id: draft.client_report_id,
+  };
+}
+
+function renderFeedbackMarkdown(draft: FeedbackDraft): string {
+  const lines = [
+    "# AgentKit Feedback Draft",
+    "",
+    `Kind: ${draft.kind}`,
+    `Summary: ${draft.summary}`,
+    `Client report: ${draft.client_report_id}`,
+    "",
+  ];
+
+  if (draft.message) {
+    lines.push("## Message", "", draft.message, "");
+  }
+
+  lines.push("## Context", "", "```json", JSON.stringify(draft.context, null, 2), "```", "");
+  lines.push("Send with the JSON path printed by `agentkit feedback create`:", "", "```sh\nagentkit feedback send <draft.json>\n```", "");
+
+  return `${lines.join("\n")}\n`;
+}
+
+function parseFeedbackKind(value: string | boolean | undefined, fallback: FeedbackKind): FeedbackKind {
+  if (value === undefined || value === false) {
+    return fallback;
+  }
+
+  if (typeof value === "string" && isFeedbackKind(value)) {
+    return value;
+  }
+
+  throw new Error("feedback --kind must be bug, confusion, missing_docs, feature_request, deploy_issue, runtime_issue, or other.");
+}
+
+function parseFeedbackAbout(value: string | boolean | undefined): FeedbackAbout {
+  if (value === undefined || value === false) {
+    return "last-run";
+  }
+
+  if (typeof value === "string" && feedbackAboutValues.has(value as FeedbackAbout)) {
+    return value as FeedbackAbout;
+  }
+
+  throw new Error("feedback --about must be last-run, deploy, or manual.");
+}
+
+function summarizeMessage(message: string | undefined): string | undefined {
+  if (!message) {
+    return undefined;
+  }
+
+  return message.replace(/\s+/g, " ").trim().slice(0, 120);
+}
+
+function isFeedbackKind(value: unknown): value is FeedbackKind {
+  return typeof value === "string" && feedbackKinds.has(value as FeedbackKind);
+}
+
+function redactJson(value: unknown, key = ""): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => redactJson(item, key));
+  }
+
+  if (!isRecord(value)) {
+    return typeof value === "string" ? redactText(value) : value;
+  }
+
+  const out: Record<string, unknown> = {};
+
+  for (const [nestedKey, nestedValue] of Object.entries(value)) {
+    if (shouldRedactKey(nestedKey)) {
+      out[nestedKey] = "[redacted]";
+      continue;
+    }
+
+    out[nestedKey] = redactJson(nestedValue, nestedKey);
+  }
+
+  return out;
+}
+
+function shouldRedactKey(key: string): boolean {
+  return /token|password|credential|api[_-]?key|private[_-]?key/i.test(key) && key !== "client_report_id";
+}
+
+function redactText(value: string): string {
+  return value
+    .replace(/Authorization:\s*Bearer\s+[A-Za-z0-9._:-]+/gi, "Authorization: Bearer [redacted]")
+    .replace(/\b(?:agk_user|agk_deploy|ak_live|bsec|whsec|sk|rk|pk)[-_A-Za-z0-9]{12,}\b/g, "[redacted-token]")
+    .replace(/\b[A-Za-z0-9_-]{24,}\.[A-Za-z0-9_-]{24,}\.[A-Za-z0-9_-]{24,}\b/g, "[redacted-token]");
+}
+
+function slugify(value: string): string {
+  const slug = value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+
+  return slug || "feedback";
+}
+
+async function readAgentKitVersion(): Promise<string> {
+  try {
+    const packageJson = JSON.parse(await readFile(join(moduleDir, "..", "..", "..", "package.json"), "utf8")) as {
+      version?: unknown;
+    };
+    return typeof packageJson.version === "string" ? packageJson.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function relativePath(root: string, path: string): string {
+  const output = relative(root, path);
+  return output.startsWith("..") ? path : output || ".";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/cli/help.ts

@@ -30,6 +30,7 @@ Build:
   agentkit eval run
   agentkit eval from-conversation <id>
   agentkit improve collect --deploy --since 24h
+  agentkit feedback create --about last-run --kind bug --summary <text>
   agentkit replay <bundle-dir> --against local
   agentkit conversations list
 
@@ -48,6 +49,7 @@ More:
   agentkit account token ...
   agentkit access token ...
   agentkit env ...
+  agentkit feedback create --summary <text>
   agentkit docs full
   agentkit help commands
 `;
@@ -79,13 +81,16 @@ Usage:
   agentkit eval from-conversation <conversation-id> [--out <path>] [--force]
   agentkit improve collect [--deploy] [--since <duration|iso>] [--conversation-id <id>] [--out <directory>]
   agentkit improve evals <bundle-dir-or-json> [--force]
+  agentkit feedback create [--about last-run|deploy|manual] [--kind bug|confusion|missing_docs|feature_request|deploy_issue|runtime_issue|other] --summary <text> [--message <text>] [--out <path>]
+  agentkit feedback preview [draft.json]
+  agentkit feedback send [draft.json] [--about last-run|deploy|manual] [--kind <kind>] --summary <text> [--message <text>] [--api <url>] [--save]
   agentkit replay <bundle-dir-or-json> --against local
   agentkit conversations list [--deploy]
   agentkit conversations show <conversation-id> [--deploy]
   agentkit conversations trace <conversation-id> [--deploy]
   agentkit channels list
-  agentkit channels add <website|telegram|whatsapp|discord> <name> [--provider zapster|meta] [--mode interactions|bot] [--api <url>]
-  agentkit channels connect <website|telegram|whatsapp|discord> <name> [--provider zapster|meta] [--mode interactions|bot] [--api <url>]
+  agentkit channels add <website|telegram|whatsapp|discord|slack> <name> [--provider zapster|meta] [--mode interactions|bot] [--api <url>]
+  agentkit channels connect <website|telegram|whatsapp|discord|slack> <name> [--provider zapster|meta] [--mode interactions|bot] [--api <url>]
   agentkit channels setup <name> [--apply] [--api <url>]
   agentkit channels status <name> [--api <url>]
   agentkit channels doctor <name> [--api <url>]
@@ -155,6 +160,7 @@ Commands:
   db              Manage the local SQLite database
   eval            Run local eval files or create one from a conversation
   improve         Collect production or local traces and generate regression evals
+  feedback        Create local redacted feedback drafts and send them to AgentKit Cloud
   replay          Replay an improve bundle against the local Agent Capsule
   conversations   List, inspect, and trace stored local conversations
   channels        Manage hosted channel resources
@@ -201,6 +207,8 @@ export function renderCommandHelp(command: string): string {
     eval: "agentkit eval run | agentkit eval from-conversation <conversation-id> [--out <path>] [--force]",
     improve:
       "agentkit improve collect [--deploy] [--since <duration|iso>] [--conversation-id <id>] [--out <directory>] | agentkit improve evals <bundle-dir-or-json> [--force]",
+    feedback:
+      "agentkit feedback create|preview|send [draft.json] [--about last-run|deploy|manual] [--kind <kind>] [--summary <text>] [--message <text>]",
     replay: "agentkit replay <bundle-dir-or-json> --against local",
     conversations:
       "agentkit conversations list [--deploy] | agentkit conversations show <conversation-id> [--deploy] | agentkit conversations trace <conversation-id> [--deploy]",

package/src/cli/index.ts

@@ -74,6 +74,7 @@ import {
 import { renderCommandHelp, renderCommandReference, renderHelp } from "./help";
 import { runInheritedCommand, waitForShutdown } from "./process";
 import { handleChannelsCommand } from "./commands/channels";
+import { handleFeedbackCommand } from "./commands/feedback";
 import { handleKnowledgeCommand } from "./commands/knowledge";
 import { handleTranscribeCommand } from "./commands/transcribe";
 
@@ -549,6 +550,11 @@ async function main() {
     return;
   }
 
+  if (args.command === "feedback") {
+    await handleFeedbackCommand(args);
+    return;
+  }
+
   if (args.command === "sync") {
     const [subcommand] = args.positional;
 
@@ -1846,5 +1852,6 @@ main().catch((error: unknown) => {
   const message = error instanceof Error ? error.message : String(error);
   const prefix = isAgentKitError(error) ? `agentkit ${error.code}` : "agentkit";
   console.error(`${prefix}: ${message}`);
+  console.error("Feedback draft: agentkit feedback create --about last-run --kind bug --summary <text>");
   process.exitCode = 1;
 });

package/src/index.ts

@@ -2,8 +2,8 @@ export type AgentRuntime = "local" | "edge";
 export type AgentProviderName = "test" | "openai" | "anthropic" | "openrouter" | "custom";
 export type AccessMode = "private" | "token" | "public";
 export type ToolVisibility = "user" | "internal";
-export type ChannelType = "website" | "telegram" | "whatsapp" | "discord";
-export type ChannelProvider = "agentkit" | "telegram" | "zapster" | "meta" | "discord";
+export type ChannelType = "website" | "telegram" | "whatsapp" | "discord" | "slack";
+export type ChannelProvider = "agentkit" | "telegram" | "zapster" | "meta" | "discord" | "slack";
 export type WhatsappChannelProvider = "zapster" | "meta";
 export type DiscordChannelMode = "interactions" | "bot";
 export type TelegramAllowedUpdate = "message";
@@ -163,7 +163,29 @@ export type DiscordChannelConfig = {
   audio?: never;
 };
 
-export type AgentChannel = WebsiteChannelConfig | TelegramChannelConfig | WhatsappChannelConfig | DiscordChannelConfig;
+export type SlackChannelInput = {
+  name: string;
+  secrets?: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
+};
+
+export type SlackChannelConfig = {
+  type: "slack";
+  provider: "slack";
+  name: string;
+  secrets: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
+  audio?: never;
+};
+
+export type AgentChannel =
+  | WebsiteChannelConfig
+  | TelegramChannelConfig
+  | WhatsappChannelConfig
+  | DiscordChannelConfig
+  | SlackChannelConfig;
 
 export type IntegrationTagsConfig = {
   enable?: string[];
@@ -462,6 +484,17 @@ export function discordChannel(input: DiscordChannelInput): DiscordChannelConfig
   };
 }
 
+export function slackChannel(input: SlackChannelInput): SlackChannelConfig {
+  return {
+    type: "slack",
+    provider: "slack",
+    name: input.name,
+    secrets: normalizeChannelSecrets(input.secrets ?? ["SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"], "slack channel"),
+    ...(input.limits ? { limits: input.limits } : {}),
+    ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, "slack channel") } : {}),
+  };
+}
+
 function defaultDiscordChannelSecrets(mode: DiscordChannelMode): string[] {
   return mode === "bot" ? ["DISCORD_BOT_TOKEN"] : ["DISCORD_PUBLIC_KEY"];
 }
@@ -692,6 +725,7 @@ export type {
   ChannelSendResult,
   ChannelStatusInput,
   ChannelStatusResult,
+  ChannelWebhookResponse,
   NormalizedChannelEvent,
   NormalizedChannelMessage,
   RawWebhookEvent,

package/src/providers/pi.ts

@@ -291,6 +291,13 @@ function normalizeUsage(usage: Usage | undefined): ProviderRunResult["usage"] |
     inputTokens: usage.input,
     outputTokens: usage.output,
     totalTokens: usage.totalTokens,
+    cost: {
+      input: usage.cost.input,
+      output: usage.cost.output,
+      cacheRead: usage.cost.cacheRead,
+      cacheWrite: usage.cost.cacheWrite,
+      total: usage.cost.total,
+    },
   };
 }
 

package/src/providers/types.ts

@@ -24,6 +24,13 @@ export type ProviderRunResult = {
     inputTokens?: number;
     outputTokens?: number;
     totalTokens?: number;
+    cost?: {
+      input?: number;
+      output?: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      total?: number;
+    };
   };
   raw?: unknown;
 };

package/src/runtime/channel-test-harness.ts

@@ -17,7 +17,9 @@ export type ChannelFixtureName =
   | "zapster-unsupported-media"
   | "discord-command"
   | "discord-message-create"
-  | "discord-ping";
+  | "discord-ping"
+  | "slack-app-mention"
+  | "slack-direct-message";
 
 export type ChannelFixture = {
   name: ChannelFixtureName;

package/src/runtime/channels/discord.ts

@@ -20,6 +20,15 @@ export const discordChannelAdapter: ChannelAdapter = {
   async verifyWebhook(input): Promise<WebhookVerificationResult> {
     return verifyDiscordWebhook(input);
   },
+  getWebhookResponse(input) {
+    if (!isDiscordPingInteraction(input.rawBody)) {
+      return null;
+    }
+
+    return {
+      body: { type: 1 },
+    };
+  },
   normalizeInbound(input) {
     const body = parseJsonObject(input);
     const interactionId = readString(body, "id");