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

package/src/runtime/channels.ts

@@ -49,6 +49,19 @@ export type ChannelExternalIdentity = {
   redactedDisplay?: string;
 };
 
+export type ChannelReplyTarget =
+  | {
+      type: "discord_interaction";
+      applicationId: string;
+      interactionId: string;
+      interactionToken: string;
+    }
+  | {
+      type: "discord_message";
+      channelId: string;
+      messageId: string;
+    };
+
 export type ChannelAudioAttachment = {
   providerMediaId: string;
   kind: "voice" | "audio";
@@ -77,6 +90,7 @@ export type NormalizedChannelEvent = ChannelAdapterId & {
   receivedAt: string;
   unsupportedReason?: string;
   providerMetadata?: Record<string, unknown>;
+  replyTarget?: ChannelReplyTarget;
 };
 
 export type WebhookVerificationInput = RawWebhookEvent & {
@@ -98,6 +112,7 @@ export type ChannelSendInput = ChannelAdapterId & {
   channelId: string;
   conversationId: string;
   externalIdentity: ChannelExternalIdentity;
+  replyTarget?: ChannelReplyTarget;
   message: NormalizedChannelMessage;
   secrets: Record<string, string>;
 };

package/src/runtime/config.ts

@@ -13,6 +13,7 @@ import type {
   AgentChannel,
   ChannelProvider,
   ChannelType,
+  DiscordChannelMode,
   TelegramAllowedUpdate,
   AgentKnowledgeEmbeddingProvider,
   ChannelBufferMode,
@@ -29,10 +30,11 @@ const AGENT_RUNTIMES = new Set<AgentRuntime>(["local", "edge"]);
 const PROVIDERS = new Set<AgentProviderName>(["test", "openai", "anthropic", "openrouter", "custom"]);
 const ACCESS_MODES = new Set<AccessMode>(["private", "token", "public"]);
 const TOOL_VISIBILITIES = new Set<ToolVisibility>(["user", "internal"]);
-const CHANNEL_TYPES = new Set<ChannelType>(["website", "telegram", "whatsapp"]);
-const CHANNEL_PROVIDERS = new Set<ChannelProvider>(["agentkit", "telegram", "zapster", "meta"]);
+const CHANNEL_TYPES = new Set<ChannelType>(["website", "telegram", "whatsapp", "discord"]);
+const CHANNEL_PROVIDERS = new Set<ChannelProvider>(["agentkit", "telegram", "zapster", "meta", "discord"]);
 const CHANNEL_BUFFER_MODES = new Set<ChannelBufferMode>(["off", "debounce"]);
 const CHANNEL_AUDIO_MODES = new Set<ChannelAudioMode>(["off", "reject", "transcribe"]);
+const DISCORD_CHANNEL_MODES = new Set<DiscordChannelMode>(["interactions", "bot"]);
 const TELEGRAM_ALLOWED_UPDATES = new Set<TelegramAllowedUpdate>(["message"]);
 const KNOWLEDGE_EMBEDDING_PROVIDERS = new Set<AgentKnowledgeEmbeddingProvider>(["none", "test", "openai"]);
 const TRANSCRIPTION_PROVIDERS = new Set<TranscriptionProviderName>(["test", "openai", "groq"]);
@@ -260,6 +262,10 @@ function validateAgentConfig(value: unknown): asserts value is AgentConfig {
     throw invalidConfig("storage.path must be a string when provided.");
   }
 
+  if (value.storage.driver === "sqlite" && typeof value.storage.path !== "string") {
+    throw invalidConfig('storage.path is required when storage.driver is "sqlite".');
+  }
+
   validateDatabaseConfig(value.storage.database);
   validateFilesConfig(value.storage.files);
 }
@@ -371,6 +377,10 @@ function validateComposioManagedIntegration(value: AgentIntegration, index: numb
   if (value.tags !== undefined) {
     validateIntegrationTags(value.tags, `integrations[${index}].tags`);
   }
+
+  if (value.confirmExternalWrites !== undefined && typeof value.confirmExternalWrites !== "boolean") {
+    throw invalidConfig(`integrations[${index}].confirmExternalWrites must be a boolean when provided.`);
+  }
 }
 
 function validateIntegrationTags(value: unknown, label: string): void {
@@ -606,6 +616,12 @@ function validateChannel(value: unknown, index: number, hasTranscriptionConfig:
   validateSecretNames(value.secrets, `channels[${index}].secrets`);
   validateChannelLimits(value.limits, index);
   validateChannelBuffer(value.buffer, index);
+
+  if (value.type === "discord") {
+    validateDiscordChannel(value, index);
+    return;
+  }
+
   validateChannelAudio(value.audio, index, hasTranscriptionConfig);
 
   if (value.type === "website") {
@@ -678,7 +694,7 @@ function validateTelegramChannel(value: Record<string, unknown>, index: number):
 
 function validateWhatsappChannel(value: Record<string, unknown>, index: number): void {
   if (value.type !== "whatsapp") {
-    throw invalidConfig(`channels[${index}].type must be "website", "telegram", or "whatsapp".`);
+    throw invalidConfig(`channels[${index}].type must be "website", "telegram", "whatsapp", or "discord".`);
   }
 
   if (value.provider === "zapster") {
@@ -702,6 +718,26 @@ function validateWhatsappChannel(value: Record<string, unknown>, index: number):
   throw invalidConfig(`channels[${index}].provider must be "zapster" or "meta" when type is "whatsapp".`);
 }
 
+function validateDiscordChannel(value: Record<string, unknown>, index: number): void {
+  if (value.provider !== "discord") {
+    throw invalidConfig(`channels[${index}].provider must be "discord" when type is "discord".`);
+  }
+
+  if (value.mode !== undefined && !DISCORD_CHANNEL_MODES.has(value.mode as DiscordChannelMode)) {
+    throw invalidConfig(`channels[${index}].mode must be "interactions" or "bot" when type is "discord".`);
+  }
+
+  if (value.audio !== undefined) {
+    throw invalidConfig(`channels[${index}].audio is not supported when type is "discord".`);
+  }
+
+  expectRequiredSecrets(
+    value.secrets,
+    value.mode === "bot" ? ["DISCORD_BOT_TOKEN"] : ["DISCORD_PUBLIC_KEY"],
+    `channels[${index}]`,
+  );
+}
+
 function validateChannelLimits(value: unknown, index: number): void {
   if (value === undefined) {
     return;

package/src/runtime/core/manifest.ts

@@ -40,6 +40,7 @@ export type SharedAgentManifest = {
     toolkits: string[];
     tools: string[];
     userId: string;
+    confirmExternalWrites: boolean;
   }>;
   channels: NonNullable<AgentConfig["channels"]>;
   transcription: {
@@ -174,6 +175,7 @@ export function buildSharedAgentManifest(
       toolkits: integration.toolkits,
       tools: integration.allowedTools,
       userId: integration.userId,
+      confirmExternalWrites: integration.confirmExternalWrites !== false,
     })),
     channels: capsule.config.channels ?? [],
     transcription: {

package/src/runtime/dev-server.ts

@@ -8,6 +8,7 @@ import { Readable } from "node:stream";
 import { openCapsuleStore, type ConversationRecord } from "../storage/sqlite";
 import type { AgentChannel, ChannelProvider, ChannelType } from "../index";
 import type { ChannelAdapter, NormalizedChannelMessage, RawWebhookEvent } from "./channels";
+import { discordChannelAdapter, isDiscordPingInteraction } from "./channels/discord";
 import { telegramChannelAdapter } from "./channels/telegram";
 import { websiteChannelAdapter } from "./channels/website";
 import { metaWhatsappChannelAdapter } from "./channels/whatsapp-meta";
@@ -50,6 +51,8 @@ export type AgentDevServer = {
 
 const DEFAULT_PORT = 4123;
 const DEFAULT_HOSTNAME = "localhost";
+const CHANNEL_DEDUPE_TTL_MS = 6 * 60 * 60 * 1000;
+const CHANNEL_DEDUPE_MAX_KEYS = 10_000;
 
 export type AgentDevServerAccessPolicy = "local" | "enforce";
 
@@ -58,7 +61,7 @@ type DevHttpServerOptions = {
 };
 
 type DevChannelRuntimeState = {
-  dedupeKeys: Set<string>;
+  dedupeKeys: BoundedDedupeCache;
   buffers: Map<string, DevChannelBuffer>;
 };
 
@@ -155,7 +158,7 @@ async function listenForDevServer(
 
 function createDevHttpServer(capsule: LoadedAgentCapsule, options: DevHttpServerOptions): Server {
   const channelRuntime: DevChannelRuntimeState = {
-    dedupeKeys: new Set<string>(),
+    dedupeKeys: new BoundedDedupeCache(CHANNEL_DEDUPE_MAX_KEYS, CHANNEL_DEDUPE_TTL_MS),
     buffers: new Map<string, DevChannelBuffer>(),
   };
   const capsuleRoot = capsule.root;
@@ -316,7 +319,7 @@ async function handleDevServerRequest(
       return await handleLocalFile(capsule, request, decodeURIComponent(fileMatch[1]));
     }
 
-    const channelMatch = route.match(/^\/channels\/([^/]+)\/(website|telegram|whatsapp)\/([^/]+)\/webhook$/);
+    const channelMatch = route.match(/^\/channels\/([^/]+)\/(website|telegram|whatsapp|discord)\/([^/]+)\/webhook$/);
 
     if (channelMatch) {
       return await handlePortableChannel(capsule, request, channelRuntime, {
@@ -505,6 +508,10 @@ async function handlePortableChannel(
     return new Response(new URL(request.url).searchParams.get("hub.challenge") ?? "");
   }
 
+  if (channel.type === "discord" && channel.provider === "discord" && isDiscordPingInteraction(rawBody)) {
+    return jsonResponse({ type: 1 });
+  }
+
   const events = await adapter.normalizeInbound(rawEvent);
   const deliveries = [];
 
@@ -560,6 +567,10 @@ async function handlePortableChannel(
     });
   }
 
+  if (channel.type === "discord" && channel.provider === "discord") {
+    return jsonResponse(discordLocalInteractionResponse(deliveries));
+  }
+
   return jsonResponse({ deliveries });
 }
 
@@ -745,12 +756,8 @@ async function handleLocalFile(capsule: LoadedAgentCapsule, request: Request, ra
   }
 
   if (request.method === "PUT") {
-    const bytes = new Uint8Array(await request.arrayBuffer());
     const maxUploadBytes = capsule.config.storage.files.maxUploadBytes ?? 10 * 1024 * 1024;
-
-    if (bytes.byteLength > maxUploadBytes) {
-      throw new AgentKitError("file_too_large", `File exceeds max upload size of ${maxUploadBytes} bytes.`);
-    }
+    const bytes = await readRequestBytesWithLimit(request, maxUploadBytes);
 
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, bytes);
@@ -773,6 +780,102 @@ async function handleLocalFile(capsule: LoadedAgentCapsule, request: Request, ra
   throw new AgentKitError("method_not_allowed", "Unsupported file method.");
 }
 
+export class BoundedDedupeCache {
+  private readonly entries = new Map<string, number>();
+
+  constructor(
+    private readonly maxKeys: number,
+    private readonly ttlMs: number,
+  ) {}
+
+  has(key: string): boolean {
+    this.pruneExpired();
+    return this.entries.has(key);
+  }
+
+  add(key: string): void {
+    this.pruneExpired();
+    this.entries.set(key, Date.now());
+    this.pruneOverflow();
+  }
+
+  get size(): number {
+    this.pruneExpired();
+    return this.entries.size;
+  }
+
+  private pruneExpired(): void {
+    const cutoff = Date.now() - this.ttlMs;
+
+    for (const [key, timestamp] of this.entries) {
+      if (timestamp >= cutoff) {
+        continue;
+      }
+
+      this.entries.delete(key);
+    }
+  }
+
+  private pruneOverflow(): void {
+    while (this.entries.size > this.maxKeys) {
+      const oldest = this.entries.keys().next().value;
+
+      if (typeof oldest !== "string") {
+        return;
+      }
+
+      this.entries.delete(oldest);
+    }
+  }
+}
+
+async function readRequestBytesWithLimit(request: Request, maxBytes: number): Promise<Uint8Array> {
+  const contentLength = request.headers.get("content-length");
+
+  if (contentLength) {
+    const declaredBytes = Number(contentLength);
+
+    if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
+      throw new AgentKitError("file_too_large", `File exceeds max upload size of ${maxBytes} bytes.`);
+    }
+  }
+
+  if (!request.body) {
+    return new Uint8Array();
+  }
+
+  const reader = request.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+
+  while (true) {
+    const { done, value } = await reader.read();
+
+    if (done) {
+      break;
+    }
+
+    total += value.byteLength;
+
+    if (total > maxBytes) {
+      await reader.cancel().catch(() => undefined);
+      throw new AgentKitError("file_too_large", `File exceeds max upload size of ${maxBytes} bytes.`);
+    }
+
+    chunks.push(value);
+  }
+
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  return bytes;
+}
+
 async function listConversations(capsule: LoadedAgentCapsule) {
   const store = await openCapsuleStore(capsule);
 
@@ -1033,9 +1136,47 @@ function adapterForChannel(type: ChannelType, provider: ChannelProvider): Channe
     return metaWhatsappChannelAdapter;
   }
 
+  if (type === "discord" && provider === "discord") {
+    return discordChannelAdapter;
+  }
+
   throw new AgentKitError("channel_not_found", `No channel adapter for ${type}/${provider}.`);
 }
 
+function discordLocalInteractionResponse(
+  deliveries: Array<{
+    state: string;
+    message?: {
+      content?: string;
+    };
+  }>,
+): Record<string, unknown> {
+  const sent = deliveries.find((delivery) => delivery.state === "sent" && delivery.message?.content);
+
+  if (sent?.message?.content) {
+    return {
+      type: 4,
+      data: {
+        content: sent.message.content,
+        allowed_mentions: {
+          parse: [],
+        },
+      },
+    };
+  }
+
+  return {
+    type: 4,
+    data: {
+      content: "This Discord interaction was received but could not be processed.",
+      flags: 64,
+      allowed_mentions: {
+        parse: [],
+      },
+    },
+  };
+}
+
 async function resolveChannelSecrets(root: string, channel: AgentChannel): Promise<Record<string, string>> {
   const env = await loadCapsuleEnv(root);
   return Object.fromEntries(channel.secrets.map((name) => [name, env[name] ?? ""]));

package/src/runtime/evals.ts

@@ -184,6 +184,7 @@ export async function writeEvalFromConversation(
   const root = await findAgentCapsuleRoot(cwd);
   const trace = await getConversationTraceFromCwd(root, input.conversationId);
   const turns = replayTurnsFromMessages(trace.messages);
+  const safeTitle = redactEvalText(trace.title ?? trace.id);
 
   if (turns.length === 0) {
     throw new AgentKitError(
@@ -192,11 +193,11 @@ export async function writeEvalFromConversation(
     );
   }
 
-  const file = resolveEvalOutputPath(root, input.out, trace.title ?? trace.id);
+  const file = resolveEvalOutputPath(root, input.out, safeTitle);
   const source = `import { defineEval } from "@andreprado/agentkit";
 
 export default defineEval({
-  name: ${JSON.stringify(input.name ?? `replay ${trace.title ?? trace.id}`)},
+  name: ${JSON.stringify(input.name ? redactEvalText(input.name) : `replay ${safeTitle}`)},
   turns: ${formatEvalTurns(turns)},
 });
 `;
@@ -729,14 +730,22 @@ function replayTurnsFromMessages(
     }
 
     const nextAssistant = messages.slice(index + 1).find((candidate) => candidate.role === "assistant");
+    const input = redactEvalText(message.content);
+    const contains = nextAssistant ? redactEvalText(nextAssistant.content) : undefined;
+    const redactionPresent = input.includes("[redacted_") || Boolean(contains?.includes("[redacted_"));
+
     turns.push({
-      input: message.content,
+      input,
       ...(nextAssistant
         ? {
             expect: {
-              response: {
-                contains: nextAssistant.content,
-              },
+              response: redactionPresent
+                ? {
+                    notRegex: ["API_KEY|Bearer\\s+|(?:sk|agk|ak|dpat)[_-]|[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}"],
+                  }
+                : {
+                    contains: contains ?? "",
+                  },
             },
           }
         : {}),
@@ -746,6 +755,18 @@ function replayTurnsFromMessages(
   return turns;
 }
 
+function redactEvalText(value: string): string {
+  return value
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[redacted_email]")
+    .replace(
+      /\b[A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PRIVATE[_-]?KEY|CLIENT[_-]?SECRET)\s*=\s*[^\s,;]+/gi,
+      (match) => `${match.slice(0, match.indexOf("=")).trim()}=[redacted_secret]`,
+    )
+    .replace(/\b(?:sk|agk|ak|dpat)[_-][A-Za-z0-9_-]{8,}\b/g, "[redacted_token]")
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [redacted_token]")
+    .replace(/\+?\d[\d\s().-]{7,}\d/g, "[redacted_phone]");
+}
+
 function formatEvalTurns(turns: Array<{ input: string; expect?: EvalExpect }>): string {
   return JSON.stringify(turns, null, 4)
     .split("\n")