@andreprado/agentkit 0.1.0-alpha.8 → 0.1.0

package/src/index.ts

@@ -1,11 +1,15 @@
 export type AgentRuntime = "local" | "edge";
-export type AgentProviderName = "test" | "openai" | "anthropic" | "openrouter" | "custom";
+export type AgentProviderName = "test" | "openai" | "openai-codex" | "anthropic" | "openrouter" | "opencode" | "opencode-go" | "custom";
 export type AccessMode = "private" | "token" | "public";
 export type ToolVisibility = "user" | "internal";
-export type ChannelType = "website" | "telegram" | "whatsapp";
-export type ChannelProvider = "agentkit" | "telegram" | "zapster" | "meta";
-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";
+export type TranscriptionProviderName = "test" | "openai" | "groq";
+export type GenericWebhookDirection = "inbound" | "outbound";
 
 export type AgentProvider = {
   name: AgentProviderName;
@@ -39,6 +43,76 @@ export type ChannelBufferConfig =
       maxChars: number;
     };
 
+export type ChannelAudioInput = {
+  mode?: ChannelAudioMode;
+  fallbackMessage?: string;
+  maxDurationSeconds?: number;
+  maxBytes?: number;
+};
+
+export type ChannelAudioConfig =
+  | {
+      mode: "off";
+    }
+  | {
+      mode: "reject";
+      fallbackMessage: string;
+      maxDurationSeconds?: number;
+      maxBytes?: number;
+    }
+  | {
+      mode: "transcribe";
+      fallbackMessage: string;
+      maxDurationSeconds?: number;
+      maxBytes?: number;
+    };
+
+export type ChannelReplyRouteInput = {
+  channel: string;
+  recipientFrom?: string;
+};
+
+export type ChannelReplyRouteConfig = {
+  channel: string;
+  recipientFrom?: string;
+};
+
+export type GenericWebhookOutputAuthInput =
+  | {
+      type: "none";
+    }
+  | {
+      type: "bearer";
+      tokenSecret: string;
+    }
+  | {
+      type: "header";
+      headerName: string;
+      valueSecret: string;
+    }
+  | {
+      type: "hmac";
+      secret: string;
+      headerName?: string;
+    };
+
+export type GenericWebhookOutputAuthConfig = GenericWebhookOutputAuthInput;
+
+export type AgentTranscriptionLimits = {
+  maxDurationSeconds?: number;
+  maxBytes?: number;
+};
+
+export type AgentTranscriptionConfig = {
+  provider: TranscriptionProviderName;
+  model: string;
+  secret?: string;
+  language?: string;
+  prompt?: string;
+  limits?: AgentTranscriptionLimits;
+  rawAudioTtlSeconds?: number;
+};
+
 export type WebsiteChannelAccess = {
   mode: "token";
 };
@@ -49,6 +123,8 @@ export type WebsiteChannelInput = {
   secrets?: string[];
   limits?: ChannelLimits;
   buffer?: ChannelBufferInput;
+  audio?: ChannelAudioInput;
+  replyTo?: ChannelReplyRouteInput;
 };
 
 export type WebsiteChannelConfig = {
@@ -59,6 +135,8 @@ export type WebsiteChannelConfig = {
   secrets: string[];
   limits?: ChannelLimits;
   buffer?: ChannelBufferConfig;
+  audio?: ChannelAudioConfig;
+  replyTo?: ChannelReplyRouteConfig;
 };
 
 export type TelegramChannelInput = {
@@ -67,6 +145,8 @@ export type TelegramChannelInput = {
   allowedUpdates?: TelegramAllowedUpdate[];
   limits?: ChannelLimits;
   buffer?: ChannelBufferInput;
+  audio?: ChannelAudioInput;
+  replyTo?: ChannelReplyRouteInput;
 };
 
 export type TelegramChannelConfig = {
@@ -77,6 +157,8 @@ export type TelegramChannelConfig = {
   allowedUpdates: TelegramAllowedUpdate[];
   limits?: ChannelLimits;
   buffer?: ChannelBufferConfig;
+  audio?: ChannelAudioConfig;
+  replyTo?: ChannelReplyRouteConfig;
 };
 
 export type WhatsappChannelInput = {
@@ -85,6 +167,8 @@ export type WhatsappChannelInput = {
   secrets?: string[];
   limits?: ChannelLimits;
   buffer?: ChannelBufferInput;
+  audio?: ChannelAudioInput;
+  replyTo?: ChannelReplyRouteInput;
 };
 
 export type WhatsappChannelConfig = {
@@ -94,9 +178,128 @@ export type WhatsappChannelConfig = {
   secrets: string[];
   limits?: ChannelLimits;
   buffer?: ChannelBufferConfig;
+  audio?: ChannelAudioConfig;
+  replyTo?: ChannelReplyRouteConfig;
+};
+
+export type DiscordChannelInput = {
+  name: string;
+  mode?: DiscordChannelMode;
+  secrets?: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
+  replyTo?: ChannelReplyRouteInput;
+};
+
+export type DiscordChannelConfig = {
+  type: "discord";
+  provider: "discord";
+  name: string;
+  mode: DiscordChannelMode;
+  secrets: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
+  replyTo?: ChannelReplyRouteConfig;
+  audio?: never;
+};
+
+export type SlackChannelInput = {
+  name: string;
+  secrets?: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
+  replyTo?: ChannelReplyRouteInput;
+};
+
+export type SlackChannelConfig = {
+  type: "slack";
+  provider: "slack";
+  name: string;
+  secrets: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
+  replyTo?: ChannelReplyRouteConfig;
+  audio?: never;
+};
+
+export type GenericWebhookChannelInput = {
+  name: string;
+  secrets?: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
+  replyTo?: ChannelReplyRouteInput;
+};
+
+export type GenericWebhookChannelConfig = {
+  type: "webhook";
+  provider: "generic";
+  direction: "inbound";
+  name: string;
+  secrets: string[];
+  limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
+  replyTo?: ChannelReplyRouteConfig;
+  urlSecret?: never;
+  auth?: never;
+  audio?: never;
 };
 
-export type AgentChannel = WebsiteChannelConfig | TelegramChannelConfig | WhatsappChannelConfig;
+export type GenericWebhookOutputChannelInput = {
+  name: string;
+  urlSecret: string;
+  auth?: GenericWebhookOutputAuthInput;
+  secrets?: string[];
+  limits?: ChannelLimits;
+};
+
+export type GenericWebhookOutputChannelConfig = {
+  type: "webhook";
+  provider: "generic";
+  direction: "outbound";
+  name: string;
+  urlSecret: string;
+  auth: GenericWebhookOutputAuthConfig;
+  secrets: string[];
+  limits?: ChannelLimits;
+  buffer?: never;
+  replyTo?: never;
+  audio?: never;
+};
+
+export type AgentChannel =
+  | WebsiteChannelConfig
+  | TelegramChannelConfig
+  | WhatsappChannelConfig
+  | DiscordChannelConfig
+  | SlackChannelConfig
+  | GenericWebhookChannelConfig
+  | GenericWebhookOutputChannelConfig;
+
+export type IntegrationTagsConfig = {
+  enable?: string[];
+  disable?: string[];
+};
+
+export type ComposioManagedIntegrationInput = {
+  name?: string;
+  toolkits: string[];
+  tools?: Record<string, string[]>;
+  tags?: IntegrationTagsConfig;
+  confirmExternalWrites?: boolean;
+};
+
+export type ComposioManagedIntegration = {
+  type: "composio";
+  provider: "composio";
+  mode: "managed";
+  name: string;
+  toolkits: string[];
+  tools?: Record<string, string[]>;
+  tags?: IntegrationTagsConfig;
+  confirmExternalWrites?: boolean;
+};
+
+export type AgentIntegration = ComposioManagedIntegration;
 
 export type AgentDatabaseConfig =
   | {
@@ -210,6 +413,7 @@ export type ToolRenderResult = {
 export type ToolRenderContext<Input = unknown> = {
   input: Input;
   runtime: ToolRuntimeContext;
+  clock: ToolClockContext;
 };
 
 export type ToolRuntimeContext = {
@@ -219,10 +423,20 @@ export type ToolRuntimeContext = {
   database: "sqlite" | "turso" | "none";
 };
 
+export type ToolClockContext = {
+  now: Date;
+  isoTimestamp: string;
+  timeZone: string;
+  localDate: string;
+  localWeekday: string;
+  localDateTime: string;
+};
+
 export type ToolContext = {
   secrets: Record<string, string>;
   signal: AbortSignal;
   runtime: ToolRuntimeContext;
+  clock: ToolClockContext;
   database: DatabaseRunner;
   db: DatabaseRunner;
   storage: {
@@ -254,10 +468,13 @@ export type AgentConfig = {
   name: string;
   runtime: AgentRuntime;
   provider: AgentProvider;
+  timeZone?: string;
   instructions: string;
   secrets: string[];
   tools?: AgentTool[];
+  integrations?: AgentIntegration[];
   channels?: AgentChannel[];
+  transcription?: AgentTranscriptionConfig;
   knowledge?: AgentKnowledgeConfig;
   access: {
     mode: AccessMode;
@@ -278,6 +495,25 @@ export function defineTool<Input = unknown, Output = unknown>(tool: AgentTool<In
   return tool;
 }
 
+export function composioManaged(input: ComposioManagedIntegrationInput): ComposioManagedIntegration {
+  const name = normalizeIntegrationName(input.name ?? "composio", "composio integration name");
+  const toolkits = normalizeToolkitList(input.toolkits, "composioManaged.toolkits");
+  const tools = input.tools ? normalizeComposioToolMap(input.tools, toolkits) : undefined;
+  const tags = input.tags ? normalizeIntegrationTags(input.tags) : undefined;
+  const confirmExternalWrites = input.confirmExternalWrites;
+
+  return {
+    type: "composio",
+    provider: "composio",
+    mode: "managed",
+    name,
+    toolkits,
+    ...(tools ? { tools } : {}),
+    ...(tags ? { tags } : {}),
+    ...(confirmExternalWrites === undefined ? {} : { confirmExternalWrites }),
+  };
+}
+
 export function websiteChannel(input: WebsiteChannelInput): WebsiteChannelConfig {
   return {
     type: "website",
@@ -287,6 +523,8 @@ export function websiteChannel(input: WebsiteChannelInput): WebsiteChannelConfig
     secrets: normalizeChannelSecrets(input.secrets ?? ["AGENTKIT_WEBSITE_CHANNEL_TOKEN"], "website channel"),
     ...(input.limits ? { limits: input.limits } : {}),
     ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, "website channel") } : {}),
+    ...(input.audio ? { audio: normalizeChannelAudio(input.audio, "website channel") } : {}),
+    ...(input.replyTo ? { replyTo: normalizeChannelReplyRoute(input.replyTo, "website channel") } : {}),
   };
 }
 
@@ -302,6 +540,8 @@ export function telegramChannel(input: TelegramChannelInput): TelegramChannelCon
     allowedUpdates: input.allowedUpdates ?? ["message"],
     ...(input.limits ? { limits: input.limits } : {}),
     ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, "telegram channel") } : {}),
+    ...(input.audio ? { audio: normalizeChannelAudio(input.audio, "telegram channel") } : {}),
+    ...(input.replyTo ? { replyTo: normalizeChannelReplyRoute(input.replyTo, "telegram channel") } : {}),
   };
 }
 
@@ -316,12 +556,86 @@ export function whatsappChannel(input: WhatsappChannelInput): WhatsappChannelCon
     ),
     ...(input.limits ? { limits: input.limits } : {}),
     ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, `${input.provider} whatsapp channel`) } : {}),
+    ...(input.audio ? { audio: normalizeChannelAudio(input.audio, `${input.provider} whatsapp channel`) } : {}),
+    ...(input.replyTo ? { replyTo: normalizeChannelReplyRoute(input.replyTo, `${input.provider} whatsapp channel`) } : {}),
+  };
+}
+
+export function discordChannel(input: DiscordChannelInput): DiscordChannelConfig {
+  const mode = input.mode ?? "interactions";
+
+  return {
+    type: "discord",
+    provider: "discord",
+    name: input.name,
+    mode,
+    secrets: normalizeChannelSecrets(input.secrets ?? defaultDiscordChannelSecrets(mode), "discord channel"),
+    ...(input.limits ? { limits: input.limits } : {}),
+    ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, "discord channel") } : {}),
+    ...(input.replyTo ? { replyTo: normalizeChannelReplyRoute(input.replyTo, "discord channel") } : {}),
+  };
+}
+
+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") } : {}),
+    ...(input.replyTo ? { replyTo: normalizeChannelReplyRoute(input.replyTo, "slack channel") } : {}),
+  };
+}
+
+export function webhookChannel(input: GenericWebhookChannelInput): GenericWebhookChannelConfig {
+  return {
+    type: "webhook",
+    provider: "generic",
+    direction: "inbound",
+    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") } : {}),
+    ...(input.replyTo ? { replyTo: normalizeChannelReplyRoute(input.replyTo, "generic webhook channel") } : {}),
   };
 }
 
+export function webhookOutputChannel(input: GenericWebhookOutputChannelInput): GenericWebhookOutputChannelConfig {
+  const auth = normalizeGenericWebhookOutputAuth(input.auth ?? { type: "none" }, "generic webhook output channel");
+  const requiredSecrets = [
+    input.urlSecret,
+    ...genericWebhookOutputAuthSecrets(auth),
+    ...(input.secrets ?? []),
+  ];
+
+  return {
+    type: "webhook",
+    provider: "generic",
+    direction: "outbound",
+    name: input.name,
+    urlSecret: normalizeSecretName(input.urlSecret, "generic webhook output channel urlSecret"),
+    auth,
+    secrets: normalizeChannelSecrets(requiredSecrets, "generic webhook output channel"),
+    ...(input.limits ? { limits: input.limits } : {}),
+  };
+}
+
+function defaultDiscordChannelSecrets(mode: DiscordChannelMode): string[] {
+  return mode === "bot" ? ["DISCORD_BOT_TOKEN"] : ["DISCORD_PUBLIC_KEY"];
+}
+
 function defaultWhatsappChannelSecrets(provider: WhatsappChannelProvider): string[] {
   if (provider === "zapster") {
-    return ["ZAPSTER_API_KEY", "ZAPSTER_WEBHOOK_SECRET"];
+    return ["ZAPSTER_API_KEY", "ZAPSTER_INSTANCE_ID", "ZAPSTER_WEBHOOK_ID", "ZAPSTER_WEBHOOK_TOKEN"];
+  }
+
+  if (provider === "uazapi") {
+    return ["UAZAPI_BASE_URL", "UAZAPI_TOKEN", "UAZAPI_WEBHOOK_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"];
@@ -331,14 +645,125 @@ function normalizeChannelSecrets(secrets: string[], context: string): string[] {
   const uniqueSecrets = new Set<string>();
 
   for (const secret of secrets) {
-    if (!/^[A-Z_][A-Z0-9_]*$/.test(secret)) {
-      throw new Error(`${context} secrets must be environment variable names, not secret values.`);
+    uniqueSecrets.add(normalizeSecretName(secret, `${context} secrets`));
+  }
+
+  return Array.from(uniqueSecrets).sort();
+}
+
+function normalizeSecretName(secret: string, context: string): string {
+  if (!/^[A-Z_][A-Z0-9_]*$/.test(secret)) {
+    if (context.endsWith("secrets")) {
+      throw new Error(`${context} must be environment variable names, not secret values.`);
     }
 
-    uniqueSecrets.add(secret);
+    throw new Error(`${context} must be an environment variable name, not a secret value.`);
   }
 
-  return Array.from(uniqueSecrets).sort();
+  return secret;
+}
+
+function normalizeIntegrationName(value: string, context: string): string {
+  const name = value.trim();
+
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error(`${context} must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens.`);
+  }
+
+  return name;
+}
+
+function normalizeToolkitList(values: string[], context: string): string[] {
+  if (!Array.isArray(values) || values.length === 0) {
+    throw new Error(`${context} must include at least one toolkit slug.`);
+  }
+
+  const toolkits = new Set<string>();
+
+  for (const value of values) {
+    if (typeof value !== "string") {
+      throw new Error(`${context} entries must be toolkit slug strings.`);
+    }
+
+    const toolkit = value.trim().toLowerCase();
+
+    if (!/^[a-z][a-z0-9_-]*$/.test(toolkit)) {
+      throw new Error(`${context} entries must start with a letter and contain only letters, numbers, underscores, and hyphens.`);
+    }
+
+    toolkits.add(toolkit);
+  }
+
+  return Array.from(toolkits).sort();
+}
+
+function normalizeComposioToolMap(values: Record<string, string[]>, toolkits: string[]): Record<string, string[]> | undefined {
+  const toolkitSet = new Set(toolkits);
+  const normalized: Record<string, string[]> = {};
+
+  for (const [rawToolkit, rawTools] of Object.entries(values)) {
+    const toolkit = rawToolkit.trim().toLowerCase();
+
+    if (!toolkitSet.has(toolkit)) {
+      throw new Error(`composioManaged.tools.${rawToolkit} must reference a toolkit listed in composioManaged.toolkits.`);
+    }
+
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+      throw new Error(`composioManaged.tools.${rawToolkit} must include at least one Composio action slug.`);
+    }
+
+    const tools = new Set<string>();
+
+    for (const rawTool of rawTools) {
+      if (typeof rawTool !== "string") {
+        throw new Error(`composioManaged.tools.${rawToolkit} entries must be Composio action slug strings.`);
+      }
+
+      const tool = rawTool.trim().toUpperCase();
+
+      if (!/^[A-Z][A-Z0-9_]*$/.test(tool)) {
+        throw new Error(`composioManaged.tools.${rawToolkit} entries must be uppercase Composio action slugs.`);
+      }
+
+      tools.add(tool);
+    }
+
+    normalized[toolkit] = Array.from(tools).sort();
+  }
+
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function normalizeIntegrationTags(tags: IntegrationTagsConfig): IntegrationTagsConfig {
+  const normalized: IntegrationTagsConfig = {};
+
+  if (tags.enable !== undefined) {
+    normalized.enable = normalizeTagList(tags.enable, "composioManaged.tags.enable");
+  }
+
+  if (tags.disable !== undefined) {
+    normalized.disable = normalizeTagList(tags.disable, "composioManaged.tags.disable");
+  }
+
+  return normalized;
+}
+
+function normalizeTagList(values: string[], context: string): string[] {
+  if (!Array.isArray(values)) {
+    throw new Error(`${context} must be an array of tag strings.`);
+  }
+
+  return Array.from(
+    new Set(
+      values.map((value) => {
+        if (typeof value !== "string" || value.trim().length === 0) {
+          throw new Error(`${context} entries must be non-empty strings.`);
+        }
+
+        return value.trim();
+      }),
+    ),
+  ).sort();
 }
 
 function normalizeChannelBuffer(input: ChannelBufferInput, context: string): ChannelBufferConfig {
@@ -370,6 +795,114 @@ function normalizeChannelBuffer(input: ChannelBufferInput, context: string): Cha
   return buffer;
 }
 
+function normalizeChannelAudio(input: ChannelAudioInput, context: string): ChannelAudioConfig {
+  const mode = input.mode ?? "transcribe";
+
+  if (mode !== "off" && mode !== "reject" && mode !== "transcribe") {
+    throw new Error(`${context} audio.mode must be "off", "reject", or "transcribe".`);
+  }
+
+  if (mode === "off") {
+    return { mode: "off" };
+  }
+
+  if (input.maxDurationSeconds !== undefined) {
+    validatePositiveInteger(input.maxDurationSeconds, `${context} audio.maxDurationSeconds`);
+  }
+
+  if (input.maxBytes !== undefined) {
+    validatePositiveInteger(input.maxBytes, `${context} audio.maxBytes`);
+  }
+
+  return {
+    mode,
+    fallbackMessage: input.fallbackMessage ?? "I received an audio message, but I could not transcribe it. Please send the message as text.",
+    ...(input.maxDurationSeconds !== undefined ? { maxDurationSeconds: input.maxDurationSeconds } : {}),
+    ...(input.maxBytes !== undefined ? { maxBytes: input.maxBytes } : {}),
+  };
+}
+
+function normalizeChannelReplyRoute(input: ChannelReplyRouteInput, context: string): ChannelReplyRouteConfig {
+  const channel = input.channel.trim();
+
+  if (!/^[a-z][a-z0-9-]*$/.test(channel)) {
+    throw new Error(`${context} replyTo.channel must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens.`);
+  }
+
+  return {
+    channel,
+    ...(input.recipientFrom ? { recipientFrom: normalizeJsonPath(input.recipientFrom, `${context} replyTo.recipientFrom`) } : {}),
+  };
+}
+
+function normalizeJsonPath(value: string, context: string): string {
+  const path = value.trim().replace(/^payload\./, "");
+
+  if (!/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(path)) {
+    throw new Error(`${context} must be a dotted JSON field path such as "phone" or "customer.phone".`);
+  }
+
+  return path;
+}
+
+function normalizeGenericWebhookOutputAuth(
+  auth: GenericWebhookOutputAuthInput,
+  context: string,
+): GenericWebhookOutputAuthConfig {
+  if (auth.type === "none") {
+    return { type: "none" };
+  }
+
+  if (auth.type === "bearer") {
+    return {
+      type: "bearer",
+      tokenSecret: normalizeSecretName(auth.tokenSecret, `${context} auth.tokenSecret`),
+    };
+  }
+
+  if (auth.type === "header") {
+    if (!/^[A-Za-z][A-Za-z0-9-]*$/.test(auth.headerName)) {
+      throw new Error(`${context} auth.headerName must be an HTTP header name.`);
+    }
+
+    return {
+      type: "header",
+      headerName: auth.headerName,
+      valueSecret: normalizeSecretName(auth.valueSecret, `${context} auth.valueSecret`),
+    };
+  }
+
+  if (auth.type === "hmac") {
+    if (auth.headerName !== undefined && !/^[A-Za-z][A-Za-z0-9-]*$/.test(auth.headerName)) {
+      throw new Error(`${context} auth.headerName must be an HTTP header name.`);
+    }
+
+    return {
+      type: "hmac",
+      secret: normalizeSecretName(auth.secret, `${context} auth.secret`),
+      ...(auth.headerName ? { headerName: auth.headerName } : {}),
+    };
+  }
+
+  throw new Error(`${context} auth.type must be "none", "bearer", "header", or "hmac".`);
+}
+
+function genericWebhookOutputAuthSecrets(auth: GenericWebhookOutputAuthConfig): string[] {
+  if (auth.type === "bearer") {
+    return [auth.tokenSecret];
+  }
+
+  if (auth.type === "header") {
+    return [auth.valueSecret];
+  }
+
+  if (auth.type === "hmac") {
+    return [auth.secret];
+  }
+
+  return [];
+}
+
 function validatePositiveInteger(value: number, field: string): void {
   if (!Number.isInteger(value) || value <= 0) {
     throw new Error(`${field} must be a positive integer.`);
@@ -379,7 +912,18 @@ function validatePositiveInteger(value: number, field: string): void {
 export { loadAgentCapsule, findAgentCapsuleRoot } from "./runtime/config";
 export { runAgentMessage, runAgentMessageFromCwd } from "./runtime/chat";
 export { listConversationsFromCwd, getConversationFromCwd } from "./runtime/conversations";
-export { runEvalsFromCwd } from "./runtime/evals";
+export { defineEval, runEvalsFromCwd } from "./runtime/evals";
+export type {
+  EvalCase,
+  EvalExpect,
+  EvalResponseExpectation,
+  EvalRunSummary,
+  EvalResult,
+  EvalToolsContainerExpectation,
+  EvalToolsExpectation,
+  EvalTurn,
+  ToolExpectation,
+} from "./runtime/evals";
 export { getConversationTraceFromCwd } from "./runtime/traces";
 export { runToolFromCwd } from "./runtime/tool-runner";
 export { startAgentDevServer } from "./runtime/dev-server";
@@ -390,19 +934,29 @@ export { AgentKitError } from "./runtime/errors";
 export type {
   ChannelAdapter,
   ChannelAdapterId,
+  ChannelAudioAttachment,
   ChannelDeliveryDirection,
   ChannelDeliveryState,
   ChannelEventKind,
   ChannelExternalIdentity,
+  ChannelMediaDownloadInput,
+  ChannelMediaDownloadResult,
   ChannelMessageContentType,
   ChannelMessageRole,
+  ChannelReplyTarget,
   ChannelSendInput,
   ChannelSendResult,
   ChannelStatusInput,
   ChannelStatusResult,
+  ChannelWebhookResponse,
   NormalizedChannelEvent,
   NormalizedChannelMessage,
   RawWebhookEvent,
   WebhookVerificationInput,
   WebhookVerificationResult,
 } from "./runtime/channels";
+export type {
+  TranscriptionAdapter,
+  TranscriptionInput,
+  TranscriptionResult,
+} from "./runtime/transcription";