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

package/src/cli/commands/channels.ts

@@ -15,8 +15,8 @@ type DeployState = LocalDeployState;
 type CloudChannel = {
   id: string;
   name: string;
-  type: "website" | "telegram" | "whatsapp" | "discord" | "slack";
-  provider: "agentkit" | "telegram" | "zapster" | "meta" | "discord" | "slack";
+  type: "website" | "telegram" | "whatsapp" | "discord" | "slack" | "webhook";
+  provider: "agentkit" | "telegram" | "zapster" | "meta" | "uazapi" | "evolution" | "discord" | "slack" | "generic";
   mode?: "interactions" | "bot";
   status: string;
   webhook_url: string;
@@ -78,10 +78,12 @@ type ChannelBufferActionResponse = {
 type ChannelSetupResponse = {
   channel: CloudChannel;
   setup?: {
-    provider: "telegram";
+    provider: "telegram" | "uazapi" | "evolution";
     webhook_url: string;
     status: "configured";
     bot_username?: string;
+    webhook_count?: number;
+    matched_webhook_id?: string;
     get_webhook_info?: {
       url: string;
       pending_update_count: number;
@@ -144,7 +146,7 @@ export async function handleChannelsCommand(args: ParsedArgs): Promise<void> {
     const name = second;
 
     if (!type || !name || !isCliChannelType(type)) {
-      throw new Error("Usage: agentkit channels add <website|telegram|whatsapp|discord|slack> <name> [--provider zapster|meta] [--mode interactions|bot]");
+      throw new Error("Usage: agentkit channels add <website|telegram|whatsapp|discord|slack|webhook> <name> [--provider zapster|meta|uazapi|evolution] [--mode interactions|bot]");
     }
 
     const response = await createHostedChannel(type, name, args.flags.provider, args.flags.mode, args.flags.api);
@@ -158,7 +160,7 @@ export async function handleChannelsCommand(args: ParsedArgs): Promise<void> {
     const name = second;
 
     if (!type || !name || !isCliChannelType(type)) {
-      throw new Error("Usage: agentkit channels connect <website|telegram|whatsapp|discord|slack> <name> [--provider zapster|meta] [--mode interactions|bot]");
+      throw new Error("Usage: agentkit channels connect <website|telegram|whatsapp|discord|slack|webhook> <name> [--provider zapster|meta|uazapi|evolution] [--mode interactions|bot]");
     }
 
     const created = await createHostedChannel(type, name, args.flags.provider, args.flags.mode, args.flags.api);
@@ -195,6 +197,37 @@ export async function handleChannelsCommand(args: ParsedArgs): Promise<void> {
       return;
     }
 
+    if (channel.type === "whatsapp" && channel.provider === "uazapi") {
+      const setup = await applyProviderWebhook(channel, args.flags.api);
+      channel = setup.channel ?? channel;
+      console.log("UAZAPI webhook setup: OK");
+      console.log("UAZAPI webhook confirmed.");
+      if (setup.setup?.webhook_count !== undefined) {
+        console.log(`UAZAPI webhooks: ${setup.setup.webhook_count}`);
+      }
+
+      const smoke = await runConnectSmoke(() => runChannelSmoke(channel, args.flags.api, args.flags.message));
+      printUazapiHumanNextStep(channel);
+      if (!smoke) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+
+    if (channel.type === "whatsapp" && channel.provider === "evolution") {
+      const setup = await applyProviderWebhook(channel, args.flags.api);
+      channel = setup.channel ?? channel;
+      console.log("Evolution webhook setup: OK");
+      console.log("Evolution webhook confirmed.");
+
+      const smoke = await runConnectSmoke(() => runChannelSmoke(channel, args.flags.api, args.flags.message));
+      printEvolutionHumanNextStep(channel);
+      if (!smoke) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+
     if (channel.type === "discord") {
       const smoke = await runConnectSmoke(() => runChannelSmoke(channel, args.flags.api, args.flags.message));
       printDiscordHumanNextStep(channel);
@@ -213,6 +246,15 @@ export async function handleChannelsCommand(args: ParsedArgs): Promise<void> {
       return;
     }
 
+    if (channel.type === "webhook") {
+      const smoke = await runConnectSmoke(() => runChannelSmoke(channel, args.flags.api, args.flags.message));
+      printGenericWebhookHumanNextStep(channel);
+      if (!smoke) {
+        process.exitCode = 1;
+      }
+      return;
+    }
+
     if (channel.type === "whatsapp" && channel.provider === "zapster") {
       const smoke = await runConnectSmoke(() => runChannelSmoke(channel, args.flags.api, args.flags.message));
       console.log(`Next human step: paste ${channel.webhook_url} into ${channel.provider}'s webhook settings.`);
@@ -249,12 +291,34 @@ export async function handleChannelsCommand(args: ParsedArgs): Promise<void> {
         console.log(`Setup: call Telegram setWebhook with ${channel.webhook_url}`);
         console.log("Use --apply to mutate Telegram webhook settings.");
       }
+    } else if (channel.type === "whatsapp" && channel.provider === "uazapi") {
+      if (args.flags.apply) {
+        const setup = await applyProviderWebhook(channel, args.flags.api);
+        console.log("UAZAPI webhook confirmed.");
+        printChannelStatus(setup.channel ?? channel);
+        printUazapiHumanNextStep(setup.channel ?? channel);
+      } else {
+        console.log(`Setup: configure UAZAPI /webhook with ${channel.webhook_url}`);
+        console.log("Use --apply to mutate UAZAPI webhook settings.");
+      }
+    } else if (channel.type === "whatsapp" && channel.provider === "evolution") {
+      if (args.flags.apply) {
+        const setup = await applyProviderWebhook(channel, args.flags.api);
+        console.log("Evolution webhook confirmed.");
+        printChannelStatus(setup.channel ?? channel);
+        printEvolutionHumanNextStep(setup.channel ?? channel);
+      } else {
+        console.log(`Setup: configure Evolution /webhook/set/{instance} with ${channel.webhook_url}`);
+        console.log("Use --apply to mutate Evolution webhook settings.");
+      }
     } else if (channel.type === "whatsapp") {
       console.log(`Next step: paste this URL into ${channel.provider}'s webhook settings.`);
     } else if (channel.type === "discord") {
       printDiscordHumanNextStep(channel);
     } else if (channel.type === "slack") {
       printSlackHumanNextStep(channel);
+    } else if (channel.type === "webhook") {
+      printGenericWebhookHumanNextStep(channel);
     } else {
       console.log(`Website endpoint: ${channel.webhook_url}`);
       console.log("Use this endpoint from the AgentKit website client or a signed server-to-server test.");
@@ -298,8 +362,9 @@ export async function handleChannelsCommand(args: ParsedArgs): Promise<void> {
 
     const channel = await resolveCloudChannelByName(first, args.flags.api);
     const apiUrl = parseCloudApiUrl(args.flags.api);
-    const body = await channelTestBody(channel, args.flags.message, args.flags.fixture);
-    const signed = await runServerSignedChannelTest(channel, apiUrl, body);
+    const signed = channel.type === "whatsapp" && channel.provider === "evolution" && !args.flags.fixture
+      ? await runServerGeneratedChannelTest(channel, apiUrl, args.flags.message)
+      : await runServerSignedChannelTest(channel, apiUrl, await channelTestBody(channel, args.flags.message, args.flags.fixture));
     const response = signed.response;
     const payload = signed.payload;
 
@@ -427,7 +492,7 @@ export async function handleChannelsCommand(args: ParsedArgs): Promise<void> {
 }
 
 async function createHostedChannel(
-  type: "website" | "telegram" | "whatsapp" | "discord" | "slack",
+  type: "website" | "telegram" | "whatsapp" | "discord" | "slack" | "webhook",
   name: string,
   providerFlag: string | boolean | undefined,
   modeFlag: string | boolean | undefined,
@@ -460,8 +525,10 @@ async function runChannelSmoke(
   apiFlag: string | boolean | undefined,
   messageFlag: string | boolean | undefined,
 ): Promise<{ status: string; delivery_id?: string }> {
-  const body = await channelTestBody(channel, messageFlag, undefined);
-  const { response, payload } = await runServerSignedChannelTest(channel, parseCloudApiUrl(apiFlag), body);
+  const apiUrl = parseCloudApiUrl(apiFlag);
+  const { response, payload } = channel.type === "whatsapp" && channel.provider === "evolution"
+    ? await runServerGeneratedChannelTest(channel, apiUrl, messageFlag)
+    : await runServerSignedChannelTest(channel, apiUrl, await channelTestBody(channel, messageFlag, undefined));
 
   if (!response.ok) {
     throw new Error(readCloudError(payload, response.status));
@@ -477,6 +544,35 @@ async function runChannelSmoke(
   return { status: "unknown" };
 }
 
+async function runServerGeneratedChannelTest(
+  channel: CloudChannel,
+  apiUrl: string,
+  messageFlag: string | boolean | undefined,
+): Promise<{ response: Response; payload: unknown }> {
+  const body: Record<string, unknown> = {};
+
+  if (typeof messageFlag === "string") {
+    body.message = messageFlag;
+  }
+
+  const response = await cloudFetch(apiUrl, `/v1/channels/${encodeURIComponent(channel.id)}/test`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = await response.json().catch(() => null);
+
+  if (!response.ok && isUnsupportedChannelTestRoute(payload)) {
+    return runLocallySignedChannelTest(
+      channel,
+      apiUrl,
+      await channelTestBody(channel, messageFlag, undefined),
+    );
+  }
+
+  return { response, payload };
+}
+
 async function runConnectSmoke(
   run: () => Promise<{ status: string; delivery_id?: string }>,
 ): Promise<{ status: string; delivery_id?: string } | null> {
@@ -521,6 +617,14 @@ async function runLocallySignedChannelTest(
     webhookUrl.searchParams.set("token", process.env.ZAPSTER_WEBHOOK_TOKEN ?? "");
   }
 
+  if (channel.required_secrets.some((secret) => secret.name === "UAZAPI_WEBHOOK_TOKEN")) {
+    webhookUrl.searchParams.set("token", process.env.UAZAPI_WEBHOOK_TOKEN ?? "");
+  }
+
+  if (channel.required_secrets.some((secret) => secret.name === "EVOLUTION_WEBHOOK_TOKEN")) {
+    webhookUrl.searchParams.set("token", process.env.EVOLUTION_WEBHOOK_TOKEN ?? "");
+  }
+
   const path = `${webhookUrl.pathname}${webhookUrl.search}`;
   const headers = channelTestHeaders(channel, rawBody);
   const response = await cloudFetch(apiUrl, path, {
@@ -624,6 +728,17 @@ async function applyTelegramWebhook(
   };
 }
 
+async function applyProviderWebhook(
+  channel: CloudChannel,
+  apiFlag: string | boolean | undefined,
+): Promise<ChannelSetupResponse> {
+  return cloudPost<ChannelSetupResponse>(
+    parseCloudApiUrl(apiFlag),
+    `/v1/channels/${encodeURIComponent(channel.id)}/setup`,
+    {},
+  );
+}
+
 function shouldFallbackToLocalTelegramSetup(error: unknown): boolean {
   if (!(error instanceof Error)) {
     return false;
@@ -669,6 +784,22 @@ function printTelegramHumanNextStep(channelName: string, botUsername: string | u
   console.log(`  Then run: npm run agentkit -- channels deliveries list ${channelName}`);
 }
 
+function printUazapiHumanNextStep(channel: CloudChannel): void {
+  console.log("");
+  console.log("Next human step:");
+  console.log("  Confirm the UAZAPI instance is connected to WhatsApp");
+  console.log('  Send "hello" from a real WhatsApp contact');
+  console.log(`  Then run: npm run agentkit -- channels deliveries list ${channel.name}`);
+}
+
+function printEvolutionHumanNextStep(channel: CloudChannel): void {
+  console.log("");
+  console.log("Next human step:");
+  console.log("  Confirm the Evolution API instance is connected to WhatsApp");
+  console.log('  Send "hello" from a real WhatsApp contact');
+  console.log(`  Then run: npm run agentkit -- channels deliveries list ${channel.name}`);
+}
+
 function printDiscordHumanNextStep(channel: CloudChannel): void {
   console.log("");
   console.log("Next human step:");
@@ -702,6 +833,15 @@ function printSlackHumanNextStep(channel: CloudChannel): void {
   console.log(`  Then run: npm run agentkit -- channels deliveries list ${channel.name}`);
 }
 
+function printGenericWebhookHumanNextStep(channel: CloudChannel): void {
+  console.log("");
+  console.log("Next human step:");
+  console.log(`  Point n8n, Make, Zapier, or your server to ${channel.webhook_url}`);
+  console.log("  Send JSON with event_id, external_id, and message");
+  console.log("  Authenticate with Authorization: Bearer <AGENTKIT_WEBHOOK_SECRET>");
+  console.log(`  Then run: npm run agentkit -- channels deliveries list ${channel.name}`);
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -714,8 +854,8 @@ async function readDeployStateIfExists(cwd: string): Promise<DeployState | null>
   return readLocalDeployStateIfExists(cwd);
 }
 
-function isCliChannelType(value: string): value is "website" | "telegram" | "whatsapp" | "discord" | "slack" {
-  return value === "website" || value === "telegram" || value === "whatsapp" || value === "discord" || value === "slack";
+function isCliChannelType(value: string): value is "website" | "telegram" | "whatsapp" | "discord" | "slack" | "webhook" {
+  return value === "website" || value === "telegram" || value === "whatsapp" || value === "discord" || value === "slack" || value === "webhook";
 }
 
 async function readDeployStateRequired(cwd: string): Promise<DeployState> {
@@ -1009,10 +1149,18 @@ function channelProviderForCli(type: string, providerFlag: string | boolean | un
     return "slack";
   }
 
+  if (type === "webhook") {
+    if (providerFlag !== undefined) {
+      throw new Error("--provider is not supported for generic webhook channels.");
+    }
+
+    return "generic";
+  }
+
   const provider = providerFlag ?? "zapster";
 
-  if (provider !== "zapster" && provider !== "meta") {
-    throw new Error('WhatsApp provider must be "zapster" or "meta".');
+  if (provider !== "zapster" && provider !== "meta" && provider !== "uazapi" && provider !== "evolution") {
+    throw new Error('WhatsApp provider must be "zapster", "meta", "uazapi", or "evolution".');
   }
 
   return provider;
@@ -1059,6 +1207,14 @@ function defaultChannelSecretsForCli(type: string, provider: string, mode?: "int
     return ["META_WHATSAPP_ACCESS_TOKEN", "META_WHATSAPP_APP_SECRET", "META_WHATSAPP_VERIFY_TOKEN"];
   }
 
+  if (type === "whatsapp" && provider === "uazapi") {
+    return ["UAZAPI_BASE_URL", "UAZAPI_TOKEN"];
+  }
+
+  if (type === "whatsapp" && provider === "evolution") {
+    return ["EVOLUTION_API_BASE_URL", "EVOLUTION_API_KEY", "EVOLUTION_INSTANCE_NAME", "EVOLUTION_WEBHOOK_TOKEN"];
+  }
+
   if (type === "discord") {
     return mode === "bot" ? ["DISCORD_BOT_TOKEN"] : ["DISCORD_PUBLIC_KEY"];
   }
@@ -1067,6 +1223,10 @@ function defaultChannelSecretsForCli(type: string, provider: string, mode?: "int
     return ["SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"];
   }
 
+  if (type === "webhook") {
+    return ["AGENTKIT_WEBHOOK_SECRET"];
+  }
+
   return [];
 }
 
@@ -1117,6 +1277,45 @@ async function channelTestBody(
     });
   }
 
+  if (channel.type === "whatsapp" && channel.provider === "uazapi") {
+    return JSON.stringify({
+      EventType: "messages",
+      event: "messages",
+      message: {
+        id: `uaz_msg_${Date.now()}`,
+        messageid: `uaz_wamid_${Date.now()}`,
+        chatid: "5511999999999@s.whatsapp.net",
+        sender: "5511999999999@s.whatsapp.net",
+        senderName: "AgentKit",
+        fromMe: false,
+        wasSentByApi: false,
+        messageType: "text",
+        text: message,
+        messageTimestamp: Date.now(),
+      },
+    });
+  }
+
+  if (channel.type === "whatsapp" && channel.provider === "evolution") {
+    return JSON.stringify({
+      event: "MESSAGES_UPSERT",
+      instance: process.env.EVOLUTION_INSTANCE_NAME ?? "local",
+      data: {
+        key: {
+          remoteJid: "5511999999999@s.whatsapp.net",
+          fromMe: false,
+          id: `evo_wamid_${Date.now()}`,
+        },
+        pushName: "AgentKit",
+        messageType: "conversation",
+        message: {
+          conversation: message,
+        },
+        messageTimestamp: Math.floor(Date.now() / 1000),
+      },
+    });
+  }
+
   if (channel.type === "whatsapp") {
     return JSON.stringify({
       event_id: `evt_${Date.now()}`,
@@ -1201,6 +1400,14 @@ async function channelTestBody(
     });
   }
 
+  if (channel.type === "webhook") {
+    return JSON.stringify({
+      event_id: `evt_${Date.now()}`,
+      external_id: "agentkit-webhook-test",
+      message,
+    });
+  }
+
   return JSON.stringify({
     event_id: `web_${Date.now()}`,
     visitor_id: "visitor_test",
@@ -1268,6 +1475,62 @@ async function channelAudioTestBody(
     });
   }
 
+  if (channel.type === "whatsapp" && channel.provider === "uazapi") {
+    if (fixture !== "voice-note" && fixture !== "audio-file" && fixture !== "uazapi-audio" && fixture !== "uazapi-audio-message") {
+      throw new Error('UAZAPI audio smoke supports --fixture voice-note, --fixture audio-file, or --fixture uazapi-audio.');
+    }
+
+    return JSON.stringify({
+      EventType: "messages",
+      event: "messages",
+      message: {
+        id: `uaz_audio_${Date.now()}`,
+        messageid: `uaz_wamid_audio_${Date.now()}`,
+        chatid: "5511999999999@s.whatsapp.net",
+        sender: "5511999999999@s.whatsapp.net",
+        senderName: "AgentKit",
+        fromMe: false,
+        wasSentByApi: false,
+        messageType: fixture === "voice-note" ? "ptt" : "audio",
+        mimetype: "audio/ogg",
+        duration: 12,
+        file_size: 42,
+        messageTimestamp: Date.now(),
+      },
+    });
+  }
+
+  if (channel.type === "whatsapp" && channel.provider === "evolution") {
+    if (fixture !== "voice-note" && fixture !== "audio-file" && fixture !== "evolution-audio" && fixture !== "evolution-audio-message") {
+      throw new Error(
+        'Evolution audio smoke supports --fixture voice-note, --fixture audio-file, --fixture evolution-audio, or --fixture evolution-audio-message.',
+      );
+    }
+
+    return JSON.stringify({
+      event: "MESSAGES_UPSERT",
+      instance: process.env.EVOLUTION_INSTANCE_NAME ?? "local",
+      data: {
+        key: {
+          remoteJid: "5511999999999@s.whatsapp.net",
+          fromMe: false,
+          id: `evo_wamid_audio_${Date.now()}`,
+        },
+        pushName: "AgentKit",
+        messageType: "audioMessage",
+        message: {
+          audioMessage: {
+            mimetype: "audio/ogg",
+            seconds: 12,
+            ptt: fixture === "voice-note",
+            fileLength: 42,
+          },
+        },
+        messageTimestamp: Math.floor(Date.now() / 1000),
+      },
+    });
+  }
+
   throw new Error(`Audio smoke is not supported for ${channel.type}/${channel.provider}.`);
 }
 
@@ -1311,5 +1574,13 @@ function channelTestHeaders(channel: CloudChannel, rawBody: string): Headers {
     }
   }
 
+  if (channel.type === "webhook") {
+    const secret = process.env.AGENTKIT_WEBHOOK_SECRET;
+
+    if (secret) {
+      headers.set("Authorization", `Bearer ${secret}`);
+    }
+  }
+
   return headers;
 }

package/src/cli/help.ts

@@ -89,8 +89,8 @@ Usage:
   agentkit conversations show <conversation-id> [--deploy]
   agentkit conversations trace <conversation-id> [--deploy]
   agentkit channels list
-  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 add <website|telegram|whatsapp|discord|slack|webhook> <name> [--provider zapster|meta|uazapi|evolution] [--mode interactions|bot] [--api <url>]
+  agentkit channels connect <website|telegram|whatsapp|discord|slack|webhook> <name> [--provider zapster|meta|uazapi|evolution] [--mode interactions|bot] [--api <url>]
   agentkit channels setup <name> [--apply] [--api <url>]
   agentkit channels status <name> [--api <url>]
   agentkit channels doctor <name> [--api <url>]

package/src/index.ts

@@ -2,9 +2,9 @@ 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" | "slack";
-export type ChannelProvider = "agentkit" | "telegram" | "zapster" | "meta" | "discord" | "slack";
-export type WhatsappChannelProvider = "zapster" | "meta";
+export type ChannelType = "website" | "telegram" | "whatsapp" | "discord" | "slack" | "webhook";
+export type ChannelProvider = "agentkit" | "telegram" | "zapster" | "meta" | "uazapi" | "evolution" | "discord" | "slack" | "generic";
+export type WhatsappChannelProvider = "zapster" | "meta" | "uazapi" | "evolution";
 export type DiscordChannelMode = "interactions" | "bot";
 export type TelegramAllowedUpdate = "message";
 export type ChannelAudioMode = "off" | "reject" | "transcribe";
@@ -180,12 +180,30 @@ export type SlackChannelConfig = {
   audio?: never;
 };
 
+export type GenericWebhookChannelInput = {
+  name: string;
+  secrets?: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
+};
+
+export type GenericWebhookChannelConfig = {
+  type: "webhook";
+  provider: "generic";
+  name: string;
+  secrets: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
+  audio?: never;
+};
+
 export type AgentChannel =
   | WebsiteChannelConfig
   | TelegramChannelConfig
   | WhatsappChannelConfig
   | DiscordChannelConfig
-  | SlackChannelConfig;
+  | SlackChannelConfig
+  | GenericWebhookChannelConfig;
 
 export type IntegrationTagsConfig = {
   enable?: string[];
@@ -495,6 +513,17 @@ export function slackChannel(input: SlackChannelInput): SlackChannelConfig {
   };
 }
 
+export function webhookChannel(input: GenericWebhookChannelInput): GenericWebhookChannelConfig {
+  return {
+    type: "webhook",
+    provider: "generic",
+    name: input.name,
+    secrets: normalizeChannelSecrets(input.secrets ?? ["AGENTKIT_WEBHOOK_SECRET"], "generic webhook channel"),
+    ...(input.limits ? { limits: input.limits } : {}),
+    ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, "generic webhook channel") } : {}),
+  };
+}
+
 function defaultDiscordChannelSecrets(mode: DiscordChannelMode): string[] {
   return mode === "bot" ? ["DISCORD_BOT_TOKEN"] : ["DISCORD_PUBLIC_KEY"];
 }
@@ -504,6 +533,14 @@ function defaultWhatsappChannelSecrets(provider: WhatsappChannelProvider): strin
     return ["ZAPSTER_API_KEY", "ZAPSTER_INSTANCE_ID", "ZAPSTER_WEBHOOK_ID"];
   }
 
+  if (provider === "uazapi") {
+    return ["UAZAPI_BASE_URL", "UAZAPI_TOKEN"];
+  }
+
+  if (provider === "evolution") {
+    return ["EVOLUTION_API_BASE_URL", "EVOLUTION_API_KEY", "EVOLUTION_INSTANCE_NAME", "EVOLUTION_WEBHOOK_TOKEN"];
+  }
+
   return ["META_WHATSAPP_ACCESS_TOKEN", "META_WHATSAPP_APP_SECRET", "META_WHATSAPP_VERIFY_TOKEN"];
 }
 

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

@@ -15,11 +15,24 @@ export type ChannelFixtureName =
   | "zapster-audio-message"
   | "zapster-duplicate-message"
   | "zapster-unsupported-media"
+  | "uazapi-message"
+  | "uazapi-audio-message"
+  | "uazapi-duplicate-message"
+  | "uazapi-unsupported-media"
+  | "uazapi-was-sent-by-api"
+  | "evolution-message"
+  | "evolution-audio-message"
+  | "evolution-captioned-media"
+  | "evolution-duplicate-message"
+  | "evolution-from-me"
+  | "evolution-unsupported-media"
   | "discord-command"
   | "discord-message-create"
   | "discord-ping"
   | "slack-app-mention"
-  | "slack-direct-message";
+  | "slack-direct-message"
+  | "generic-webhook-message"
+  | "generic-webhook-duplicate";
 
 export type ChannelFixture = {
   name: ChannelFixtureName;