@andreprado/agentkit 0.1.0-alpha.9 → 0.1.0

package/src/runtime/dev-server.ts

@@ -7,10 +7,15 @@ import { Readable } from "node:stream";
 
 import { openCapsuleStore, type ConversationRecord } from "../storage/sqlite";
 import type { AgentChannel, ChannelProvider, ChannelType } from "../index";
-import type { ChannelAdapter, RawWebhookEvent } from "./channels";
+import type { ChannelAdapter, NormalizedChannelMessage, RawWebhookEvent } from "./channels";
+import { discordChannelAdapter } from "./channels/discord";
+import { genericWebhookChannelAdapter } from "./channels/generic-webhook";
+import { slackChannelAdapter } from "./channels/slack";
 import { telegramChannelAdapter } from "./channels/telegram";
 import { websiteChannelAdapter } from "./channels/website";
+import { evolutionWhatsappChannelAdapter } from "./channels/whatsapp-evolution";
 import { metaWhatsappChannelAdapter } from "./channels/whatsapp-meta";
+import { uazapiWhatsappChannelAdapter } from "./channels/whatsapp-uazapi";
 import { zapsterWhatsappChannelAdapter } from "./channels/whatsapp-zapster";
 import { runAgentMessage } from "./chat";
 import { isChannelBufferEnabled, renderBufferedChannelMessage, resolveChannelBuffer } from "./channel-buffer";
@@ -20,11 +25,13 @@ import { loadCapsuleEnv } from "./env";
 import { buildInspectState } from "./inspect";
 import { syncConfiguredKnowledgeSources } from "./knowledge/ingest";
 import { runToolFromCwd } from "./tool-runner";
+import { resolveTranscriptionConfig, transcribeAudio } from "./transcription";
 
 export type AgentDevServerOptions = {
   port?: number;
   hostname?: string;
   basePort?: number;
+  access?: AgentDevServerAccessPolicy;
 };
 
 export type AgentDevServer = {
@@ -48,9 +55,19 @@ export type AgentDevServer = {
 
 const DEFAULT_PORT = 4123;
 const DEFAULT_HOSTNAME = "localhost";
+const MAX_JSON_BODY_BYTES = 1_048_576;
+const MAX_WEBHOOK_BODY_BYTES = 1_048_576;
+const CHANNEL_DEDUPE_TTL_MS = 6 * 60 * 60 * 1000;
+const CHANNEL_DEDUPE_MAX_KEYS = 10_000;
+
+export type AgentDevServerAccessPolicy = "local" | "enforce";
+
+type DevHttpServerOptions = {
+  access: AgentDevServerAccessPolicy;
+};
 
 type DevChannelRuntimeState = {
-  dedupeKeys: Set<string>;
+  dedupeKeys: BoundedDedupeCache;
   buffers: Map<string, DevChannelBuffer>;
 };
 
@@ -74,7 +91,9 @@ export async function startAgentDevServer(
   const hostname = options.hostname ?? DEFAULT_HOSTNAME;
   const requestedPort = options.port ?? options.basePort ?? DEFAULT_PORT;
   const autoPort = options.port === undefined;
-  const start = await listenForDevServer(capsule, hostname, requestedPort, autoPort);
+  const start = await listenForDevServer(capsule, hostname, requestedPort, autoPort, {
+    access: options.access ?? "local",
+  });
 
   if (start.actualPort === undefined) {
     throw new AgentKitError("runtime_error", "Could not determine the AgentKit dev server port.");
@@ -106,9 +125,10 @@ async function listenForDevServer(
   hostname: string,
   requestedPort: number,
   autoPort: boolean,
+  serverOptions: DevHttpServerOptions,
 ): Promise<{ server: Server; actualPort: number; portConflict: AgentDevServer["portConflict"] }> {
   if (requestedPort === 0) {
-    const server = createDevHttpServer(capsule);
+    const server = createDevHttpServer(capsule, serverOptions);
     const actualPort = await listen(server, hostname, await findAvailablePort());
     return { server, actualPort, portConflict: null };
   }
@@ -117,7 +137,7 @@ async function listenForDevServer(
   const lastPort = autoPort ? requestedPort + 50 : requestedPort;
 
   for (let port = requestedPort; port <= lastPort; port += 1) {
-    const server = createDevHttpServer(capsule);
+    const server = createDevHttpServer(capsule, serverOptions);
 
     try {
       const actualPort = await listen(server, hostname, port);
@@ -142,14 +162,14 @@ async function listenForDevServer(
   );
 }
 
-function createDevHttpServer(capsule: LoadedAgentCapsule): Server {
+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;
   return createHttpServer((incoming, outgoing) => {
-    void handleNodeRequest(capsuleRoot, incoming, outgoing, channelRuntime);
+    void handleNodeRequest(capsuleRoot, incoming, outgoing, channelRuntime, options);
   });
 }
 
@@ -158,18 +178,19 @@ async function handleNodeRequest(
   incoming: IncomingMessage,
   outgoing: ServerResponse,
   channelRuntime: DevChannelRuntimeState,
+  options: DevHttpServerOptions,
 ): Promise<void> {
   try {
+    const request = nodeRequestToFetchRequest(incoming, options);
     const capsule = await loadAgentCapsule(capsuleRoot);
-    const request = nodeRequestToFetchRequest(incoming);
-    const response = await handleDevServerRequest(capsule, request, channelRuntime);
+    const response = await handleDevServerRequest(capsule, request, channelRuntime, options);
     await writeFetchResponse(outgoing, response);
   } catch (error) {
     await writeFetchResponse(outgoing, jsonError(error, statusForError(error)));
   }
 }
 
-function nodeRequestToFetchRequest(incoming: IncomingMessage): Request {
+function nodeRequestToFetchRequest(incoming: IncomingMessage, options: DevHttpServerOptions): Request {
   const headers = new Headers();
 
   for (const [key, value] of Object.entries(incoming.headers)) {
@@ -182,9 +203,24 @@ function nodeRequestToFetchRequest(incoming: IncomingMessage): Request {
     }
   }
 
-  const protocol = headers.get("x-forwarded-proto") ?? "http";
   const host = headers.get("host") ?? `${DEFAULT_HOSTNAME}:${DEFAULT_PORT}`;
-  const url = new URL(incoming.url ?? "/", `${protocol}://${host}`).href;
+  const hostname = requestHeaderHostname(`http://${host}`, "Host");
+  const pathname = normalizePath(new URL(incoming.url ?? "/", "http://localhost").pathname);
+
+  if (options.access === "local" && !isChannelWebhookPath(pathname)) {
+    assertLoopbackHostname(hostname, "Host");
+
+    const origin = headers.get("origin");
+    if (origin) {
+      assertLoopbackHostname(requestHeaderHostname(origin, "Origin"), "Origin");
+    }
+
+    if (headers.get("sec-fetch-site") === "cross-site") {
+      throw new AgentKitError("request_origin_invalid", "Cross-site browser requests are not allowed by the local dev server.");
+    }
+  }
+
+  const url = new URL(incoming.url ?? "/", `http://${host}`).href;
   const init: RequestInit & { duplex?: "half" } = {
     method: incoming.method ?? "GET",
     headers,
@@ -198,6 +234,28 @@ function nodeRequestToFetchRequest(incoming: IncomingMessage): Request {
   return new Request(url, init);
 }
 
+function isChannelWebhookPath(pathname: string): boolean {
+  return /^\/channels\/[^/]+\/(?:(?:website|telegram|whatsapp|discord|slack|webhook)\/[^/]+\/)?webhook$/.test(
+    pathname,
+  );
+}
+
+function requestHeaderHostname(value: string, header: string): string {
+  try {
+    return new URL(value).hostname;
+  } catch {
+    throw new AgentKitError("request_origin_invalid", `${header} is not a valid URL authority.`);
+  }
+}
+
+function assertLoopbackHostname(hostname: string, header: string): void {
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]") {
+    return;
+  }
+
+  throw new AgentKitError("request_origin_invalid", `${header} must target localhost while dev access is local.`);
+}
+
 async function writeFetchResponse(outgoing: ServerResponse, response: Response): Promise<void> {
   outgoing.statusCode = response.status;
   response.headers.forEach((value, key) => {
@@ -222,27 +280,43 @@ async function handleDevServerRequest(
   capsule: LoadedAgentCapsule,
   request: Request,
   channelRuntime: DevChannelRuntimeState,
+  options: DevHttpServerOptions,
 ): Promise<Response> {
   try {
     const url = new URL(request.url);
     const route = normalizePath(url.pathname);
 
+    if (request.method === "GET" && route === "/health") {
+      return jsonResponse({ status: "ok", agent: capsule.config.name });
+    }
+
     if (request.method === "GET" && route === "/") {
+      const auth = await authorizeDevRoute(capsule, request, options, "chat");
+      if (auth) {
+        return auth;
+      }
+
       const env = await loadCapsuleEnv(capsule.root);
       return htmlResponse(renderChatApp(capsule, url.origin, env));
     }
 
     if (request.method === "GET" && route === "/_agentkit") {
+      const auth = await authorizeDevRoute(capsule, request, options, "admin");
+      if (auth) {
+        return auth;
+      }
+
       const env = await loadCapsuleEnv(capsule.root);
       return jsonResponse(buildInspectState(capsule, env));
     }
 
-    if (request.method === "GET" && route === "/health") {
-      return jsonResponse({ status: "ok", agent: capsule.config.name });
-    }
-
     if (request.method === "POST" && (route === "/v1/chat" || route === "/chat")) {
       const body = await readJsonBody(request);
+      const auth = await authorizeDevRoute(capsule, request, options, "chat", body);
+      if (auth) {
+        return auth;
+      }
+
       const { message, conversationId } = readChatRequest(body);
       const result = await runAgentMessage(capsule, {
         message,
@@ -262,6 +336,11 @@ async function handleDevServerRequest(
     const toolMatch = route.match(/^\/tools\/([^/]+)$/);
 
     if (request.method === "POST" && toolMatch) {
+      const auth = await authorizeDevRoute(capsule, request, options, "admin");
+      if (auth) {
+        return auth;
+      }
+
       const body = await readJsonBody(request);
       const result = await runToolFromCwd(capsule.root, {
         name: decodeURIComponent(toolMatch[1]),
@@ -275,32 +354,53 @@ async function handleDevServerRequest(
     const fileMatch = route.match(/^\/files\/(.+)$/);
 
     if (fileMatch) {
+      const auth = await authorizeDevRoute(capsule, request, options, "admin");
+      if (auth) {
+        return auth;
+      }
+
       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|slack|webhook)\/([^/]+)\/webhook$/);
+    const directWebhookMatch = route.match(/^\/channels\/([^/]+)\/webhook$/);
 
-    if (channelMatch) {
+    if (channelMatch || directWebhookMatch) {
       return await handlePortableChannel(capsule, request, channelRuntime, {
-        name: decodeURIComponent(channelMatch[1]),
-        type: channelMatch[2] as ChannelType,
-        provider: decodeURIComponent(channelMatch[3]) as ChannelProvider,
+        name: decodeURIComponent((channelMatch ?? directWebhookMatch)?.[1] ?? ""),
+        type: channelMatch ? channelMatch[2] as ChannelType : "webhook",
+        provider: channelMatch ? decodeURIComponent(channelMatch[3]) as ChannelProvider : "generic",
       });
     }
 
     if (request.method === "GET" && route === "/v1/conversations") {
+      const auth = await authorizeDevRoute(capsule, request, options, "admin");
+      if (auth) {
+        return auth;
+      }
+
       return jsonResponse({ conversations: await listConversations(capsule) });
     }
 
     const conversationMatch = route.match(/^\/v1\/conversations\/([^/]+)$/);
 
     if (request.method === "GET" && conversationMatch) {
+      const auth = await authorizeDevRoute(capsule, request, options, "admin");
+      if (auth) {
+        return auth;
+      }
+
       return jsonResponse(await getConversation(capsule, decodeURIComponent(conversationMatch[1])));
     }
 
     const conversationTraceMatch = route.match(/^\/v1\/conversations\/([^/]+)\/trace$/);
 
     if (request.method === "GET" && conversationTraceMatch) {
+      const auth = await authorizeDevRoute(capsule, request, options, "admin");
+      if (auth) {
+        return auth;
+      }
+
       return jsonResponse(await getConversationTrace(capsule, decodeURIComponent(conversationTraceMatch[1])));
     }
 
@@ -310,6 +410,109 @@ async function handleDevServerRequest(
   }
 }
 
+async function authorizeDevRoute(
+  capsule: LoadedAgentCapsule,
+  request: Request,
+  options: DevHttpServerOptions,
+  kind: "chat" | "admin",
+  body?: unknown,
+): Promise<Response | null> {
+  if (options.access === "local") {
+    return null;
+  }
+
+  const env = await loadCapsuleEnv(capsule.root);
+
+  if (kind === "admin") {
+    return authorizeBearerSecret(request, body, env.AGENTKIT_PRIVATE_TOKEN, {
+      missingCode: "deploy_not_ready",
+      missingMessage: "Privileged AgentKit endpoints require AGENTKIT_PRIVATE_TOKEN to be set.",
+      unauthorizedMessage: "Missing or invalid AgentKit admin token.",
+    });
+  }
+
+  if (capsule.config.access.mode === "public") {
+    return null;
+  }
+
+  if (capsule.config.access.mode === "private") {
+    return authorizeBearerSecret(request, body, env.AGENTKIT_PRIVATE_TOKEN, {
+      missingCode: "deploy_not_ready",
+      missingMessage: "Private deploy requires AGENTKIT_PRIVATE_TOKEN to be set.",
+      unauthorizedMessage: "Missing or invalid deploy access token.",
+    });
+  }
+
+  return authorizeBearerSecret(request, body, env.AGENTKIT_ACCESS_TOKEN, {
+    missingCode: "deploy_not_ready",
+    missingMessage: "Token deploy requires AGENTKIT_ACCESS_TOKEN to be set.",
+    unauthorizedMessage: "Missing or invalid deploy access token.",
+  });
+}
+
+function authorizeBearerSecret(
+  request: Request,
+  body: unknown,
+  secret: string | undefined,
+  messages: { missingCode: string; missingMessage: string; unauthorizedMessage: string },
+): Response | null {
+  if (!secret) {
+    return jsonResponse(
+      {
+        error: {
+          code: messages.missingCode,
+          message: messages.missingMessage,
+        },
+      },
+      { status: 503 },
+    );
+  }
+
+  if (readRequestAccessToken(request, body) !== secret) {
+    return jsonResponse(
+      {
+        error: {
+          code: "unauthorized",
+          message: messages.unauthorizedMessage,
+        },
+      },
+      { status: 401 },
+    );
+  }
+
+  return null;
+}
+
+function readRequestAccessToken(request: Request, body: unknown): string {
+  const authorization = request.headers.get("authorization");
+
+  if (authorization?.startsWith("Bearer ")) {
+    return authorization.slice("Bearer ".length).trim();
+  }
+
+  const header =
+    request.headers.get("x-agentkit-access-token") ??
+    request.headers.get("x-agentkit-deploy-access-token") ??
+    "";
+  const token = header.startsWith("Bearer ") ? header.slice("Bearer ".length) : header;
+  if (token.trim()) {
+    return token.trim();
+  }
+
+  if (body && typeof body === "object") {
+    const record = body as { access_token?: unknown; accessToken?: unknown };
+    const bodyToken =
+      typeof record.access_token === "string"
+        ? record.access_token
+        : typeof record.accessToken === "string"
+          ? record.accessToken
+          : "";
+    return bodyToken.trim();
+  }
+
+  return "";
+}
+
 async function handlePortableChannel(
   capsule: LoadedAgentCapsule,
   request: Request,
@@ -325,7 +528,7 @@ async function handlePortableChannel(
   }
 
   const adapter = adapterForChannel(route.type, route.provider);
-  const rawBody = request.method === "GET" ? "" : await request.text();
+  const rawBody = request.method === "GET" ? "" : await readRequestTextWithLimit(request, MAX_WEBHOOK_BODY_BYTES);
   const rawEvent: RawWebhookEvent = {
     type: route.type,
     provider: route.provider,
@@ -345,8 +548,12 @@ async function handlePortableChannel(
     throw new AgentKitError(verification.code, verification.message);
   }
 
-  if (channel.type === "whatsapp" && channel.provider === "meta" && request.method === "GET") {
-    return new Response(new URL(request.url).searchParams.get("hub.challenge") ?? "");
+  const webhookResponse = adapter.getWebhookResponse
+    ? await adapter.getWebhookResponse({ ...rawEvent, channel, secrets })
+    : null;
+
+  if (webhookResponse) {
+    return channelAdapterResponse(webhookResponse);
   }
 
   const events = await adapter.normalizeInbound(rawEvent);
@@ -360,7 +567,9 @@ async function handlePortableChannel(
 
     channelRuntime.dedupeKeys.add(event.dedupeKey);
 
-    if (event.kind !== "message" || !event.message) {
+    const processedMessage = await processDevChannelMessage(capsule, adapter, channel, event.message, secrets);
+
+    if (event.kind !== "message" || !processedMessage) {
       deliveries.push({ state: "skipped", dedupeKey: event.dedupeKey, unsupportedReason: event.unsupportedReason });
       continue;
     }
@@ -376,7 +585,7 @@ async function handlePortableChannel(
       bufferDevChannelMessage(capsule, channelRuntime, {
         bufferKey: `${channel.name}:${event.externalIdentity.key}`,
         conversationId,
-        content: event.message.content,
+        content: processedMessage.content,
         receivedAt: event.receivedAt,
         buffer,
       });
@@ -390,21 +599,214 @@ async function handlePortableChannel(
     }
 
     const result = await runAgentMessage(capsule, {
-      message: event.message.content,
+      message: processedMessage.content,
       conversationId,
       signal: request.signal,
     });
+    const routedReply = channel.replyTo
+      ? await sendDevChannelReply({
+          capsule,
+          sourceChannel: channel,
+          sourceEvent: event,
+          rawBody,
+          conversationId: result.conversationId,
+          message: result.message.content,
+        })
+      : null;
+
     deliveries.push({
       state: "sent",
       dedupeKey: event.dedupeKey,
       conversationId: result.conversationId,
       message: result.message,
+      ...(routedReply ? { outbound: routedReply } : {}),
     });
   }
 
+  if (channel.type === "discord" && channel.provider === "discord") {
+    return jsonResponse(discordLocalInteractionResponse(deliveries));
+  }
+
   return jsonResponse({ deliveries });
 }
 
+async function sendDevChannelReply(input: {
+  capsule: LoadedAgentCapsule;
+  sourceChannel: AgentChannel;
+  sourceEvent: Awaited<ReturnType<ChannelAdapter["normalizeInbound"]>>[number];
+  rawBody: string;
+  conversationId: string;
+  message: string;
+}) {
+  const replyTo = input.sourceChannel.replyTo;
+
+  if (!replyTo) {
+    return null;
+  }
+
+  const target = (input.capsule.config.channels ?? []).find((channel) => channel.name === replyTo.channel);
+
+  if (!target) {
+    throw new AgentKitError("channel_not_found", `Reply target channel "${replyTo.channel}" was not found.`);
+  }
+
+  if (target.type === "webhook" && target.direction !== "outbound") {
+    throw new AgentKitError("channel_payload_invalid", `Reply target channel "${replyTo.channel}" is inbound-only.`);
+  }
+
+  const recipient = replyTo.recipientFrom ? readDevJsonPathScalar(input.rawBody, replyTo.recipientFrom) : null;
+
+  if (replyTo.recipientFrom && !recipient) {
+    throw new AgentKitError("channel_payload_invalid", `Reply route recipientFrom "${replyTo.recipientFrom}" did not resolve to a non-empty value.`);
+  }
+
+  const externalIdentity = recipient
+    ? recipientIdentityForDevChannel(target, recipient)
+    : input.sourceEvent.externalIdentity.key;
+
+  const targetAdapter = adapterForChannel(target.type, target.provider);
+  const secrets = await resolveChannelSecrets(input.capsule.root, target);
+
+  return targetAdapter.sendMessage({
+    type: target.type,
+    provider: target.provider,
+    channelId: target.name,
+    channel: target,
+    conversationId: input.conversationId,
+    externalIdentity: {
+      key: externalIdentity,
+    },
+    message: {
+      role: "assistant",
+      contentType: "text",
+      content: input.message,
+    },
+    secrets,
+  });
+}
+
+function recipientIdentityForDevChannel(channel: AgentChannel, recipient: string): string {
+  if (channel.type === "whatsapp") {
+    const prefix = `whatsapp:${channel.provider}:contact:`;
+    return recipient.startsWith(prefix) ? recipient : `${prefix}${recipient}`;
+  }
+
+  if (channel.type === "telegram") {
+    return recipient.includes(":chat:") ? recipient : `telegram:reply:chat:${recipient}`;
+  }
+
+  if (channel.type === "webhook" && channel.direction === "outbound") {
+    return recipient.startsWith("webhook:generic:") ? recipient : `webhook:generic:recipient:${recipient}`;
+  }
+
+  if (channel.type === "website") {
+    return recipient.startsWith("website:") ? recipient : `website:reply:${createHash("sha256").update(recipient).digest("hex").slice(0, 32)}`;
+  }
+
+  throw new AgentKitError(
+    "channel_payload_invalid",
+    `Reply target ${channel.type}/${channel.provider} requires a provider-native reply target and cannot use recipientFrom.`,
+  );
+}
+
+function readDevJsonPathScalar(rawBody: string, path: string): string | undefined {
+  let value: unknown;
+
+  try {
+    value = JSON.parse(rawBody) as unknown;
+  } catch {
+    return undefined;
+  }
+
+  for (const segment of path.replace(/^payload\./, "").split(".")) {
+    if (!isRecord(value)) {
+      return undefined;
+    }
+
+    value = value[segment];
+  }
+
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+
+  if (typeof value === "boolean") {
+    return String(value);
+  }
+
+  return undefined;
+}
+
+async function processDevChannelMessage(
+  capsule: LoadedAgentCapsule,
+  adapter: ChannelAdapter,
+  channel: AgentChannel,
+  message: NormalizedChannelMessage | undefined,
+  secrets: Record<string, string>,
+): Promise<NormalizedChannelMessage | null> {
+  if (!message) {
+    return null;
+  }
+
+  if (message.contentType === "text" && message.content) {
+    return message;
+  }
+
+  if (message.contentType !== "audio" || !message.audio || channel.audio?.mode !== "transcribe") {
+    return null;
+  }
+
+  if (!adapter.downloadMedia) {
+    return null;
+  }
+
+  const env = await loadCapsuleEnv(capsule.root);
+  const transcriptionConfig = resolveTranscriptionConfig(capsule.config.transcription);
+  const secretName = transcriptionConfig.secret;
+  const download = await adapter.downloadMedia({
+    type: channel.type,
+    provider: channel.provider,
+    channelId: channel.name,
+    message,
+    secrets: {
+      ...secrets,
+      ...(secretName ? { [secretName]: env[secretName] ?? "" } : {}),
+      ...(env.AGENTKIT_TELEGRAM_API_BASE_URL ? { AGENTKIT_TELEGRAM_API_BASE_URL: env.AGENTKIT_TELEGRAM_API_BASE_URL } : {}),
+    },
+  });
+
+  if (!download.ok) {
+    return null;
+  }
+
+  const transcription = await transcribeAudio({
+    config: transcriptionConfig,
+    secrets: {
+      ...(secretName ? { [secretName]: env[secretName] ?? "" } : {}),
+    },
+    audio: download.audio,
+    filename: download.filename,
+    ...(download.mimeType ? { mimeType: download.mimeType } : {}),
+    ...(download.durationSeconds !== undefined ? { durationSeconds: download.durationSeconds } : {}),
+  });
+
+  if (!transcription.ok) {
+    return null;
+  }
+
+  return {
+    role: "user",
+    contentType: "text",
+    content: `The user sent an audio message.\n\nTranscript:\n${transcription.text}`,
+    providerMessageId: message.providerMessageId,
+  };
+}
+
 function bufferDevChannelMessage(
   capsule: LoadedAgentCapsule,
   runtime: DevChannelRuntimeState,
@@ -509,6 +911,10 @@ function unrefTimer(timer: ReturnType<typeof setTimeout>): void {
 }
 
 async function handleLocalFile(capsule: LoadedAgentCapsule, request: Request, rawKey: string): Promise<Response> {
+  if (capsule.config.storage.files?.driver !== "r2") {
+    throw new AgentKitError("files_not_configured", "File storage is not configured for this Agent Capsule.");
+  }
+
   const key = normalizeFileKey(rawKey);
   const root = resolve(capsule.root, ".agentkit/files");
   const path = resolve(root, key);
@@ -518,14 +924,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?.driver === "r2"
-      ? capsule.config.storage.files.maxUploadBytes ?? 10 * 1024 * 1024
-      : 10 * 1024 * 1024;
-
-    if (bytes.byteLength > maxUploadBytes) {
-      throw new AgentKitError("file_too_large", `File exceeds max upload size of ${maxUploadBytes} bytes.`);
-    }
+    const maxUploadBytes = capsule.config.storage.files.maxUploadBytes ?? 10 * 1024 * 1024;
+    const bytes = await readRequestBytesWithLimit(request, maxUploadBytes);
 
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, bytes);
@@ -548,6 +948,112 @@ 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,
+  errorCode = "file_too_large",
+  label = "File",
+): Promise<Uint8Array> {
+  const contentLength = request.headers.get("content-length");
+
+  if (contentLength) {
+    const declaredBytes = Number(contentLength);
+
+    if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
+      throw new AgentKitError(errorCode, `${label} exceeds the maximum 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(errorCode, `${label} exceeds the maximum 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 readRequestTextWithLimit(request: Request, maxBytes: number): Promise<string> {
+  const bytes = await readRequestBytesWithLimit(request, maxBytes, "request_too_large", "Request body");
+  return new TextDecoder().decode(bytes);
+}
+
 async function listConversations(capsule: LoadedAgentCapsule) {
   const store = await openCapsuleStore(capsule);
 
@@ -612,8 +1118,12 @@ async function readJsonBody(request: Request): Promise<unknown> {
   }
 
   try {
-    return await request.json();
+    return JSON.parse(await readRequestTextWithLimit(request, MAX_JSON_BODY_BYTES));
   } catch (error) {
+    if (isAgentKitError(error)) {
+      throw error;
+    }
+
     throw new AgentKitError("validation_error", "Request body must be valid JSON.", { cause: error });
   }
 }
@@ -701,11 +1211,22 @@ function statusForError(error: unknown): number {
     return 409;
   }
 
+  if (error.code === "request_origin_invalid" || error.code === "tool_authorization_required") {
+    return 403;
+  }
+
+  if (error.code === "request_too_large") {
+    return 413;
+  }
+
+  if (error.code === "channel_signature_invalid") {
+    return 401;
+  }
+
   if (
     error.code === "file_key_invalid" ||
     error.code === "file_too_large" ||
     error.code === "channel_payload_invalid" ||
-    error.code === "channel_signature_invalid" ||
     error.code === "channel_secret_missing"
   ) {
     return 400;
@@ -715,6 +1236,7 @@ function statusForError(error: unknown): number {
     error.code === "conversation_not_found" ||
     error.code === "not_found" ||
     error.code === "tool_not_found" ||
+    error.code === "files_not_configured" ||
     error.code === "file_not_found" ||
     error.code === "channel_not_found"
   ) {
@@ -807,12 +1329,90 @@ function adapterForChannel(type: ChannelType, provider: ChannelProvider): Channe
     return metaWhatsappChannelAdapter;
   }
 
+  if (type === "whatsapp" && provider === "uazapi") {
+    return uazapiWhatsappChannelAdapter;
+  }
+
+  if (type === "whatsapp" && provider === "evolution") {
+    return evolutionWhatsappChannelAdapter;
+  }
+
+  if (type === "discord" && provider === "discord") {
+    return discordChannelAdapter;
+  }
+
+  if (type === "slack" && provider === "slack") {
+    return slackChannelAdapter;
+  }
+
+  if (type === "webhook" && provider === "generic") {
+    return genericWebhookChannelAdapter;
+  }
+
   throw new AgentKitError("channel_not_found", `No channel adapter for ${type}/${provider}.`);
 }
 
+function channelAdapterResponse(response: {
+  status?: number;
+  headers?: Record<string, string>;
+  body: string | Record<string, unknown>;
+}): Response {
+  if (typeof response.body === "string") {
+    return new Response(response.body, {
+      status: response.status ?? 200,
+      headers: response.headers,
+    });
+  }
+
+  return jsonResponse(response.body, {
+    status: response.status ?? 200,
+    headers: response.headers,
+  });
+}
+
+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] ?? ""]));
+  const secrets = Object.fromEntries(channel.secrets.map((name) => [name, env[name] ?? ""]));
+
+  if (env.AGENTKIT_CHANNEL_SEND_DRY_RUN === "1") {
+    secrets.AGENTKIT_CHANNEL_SEND_DRY_RUN = "1";
+  }
+
+  return secrets;
 }
 
 function relativePath(root: string, path: string): string {