@andreprado/agentkit 0.1.0-alpha.15 → 0.1.0-alpha.16

package/src/runtime/channels/whatsapp-zapster.ts

@@ -1,5 +1,7 @@
 import type {
   ChannelAdapter,
+  ChannelMediaDownloadInput,
+  ChannelMediaDownloadResult,
   ChannelSendInput,
   ChannelSendResult,
   RawWebhookEvent,
@@ -105,6 +107,22 @@ export const zapsterWhatsappChannelAdapter: ChannelAdapter = {
       },
     };
 
+    if (messageType === "audio" && message.audio) {
+      return [
+        {
+          ...base,
+          kind: "message",
+          message: {
+            role: "user",
+            contentType: "audio",
+            content: "",
+            providerMessageId: message.id,
+            audio: message.audio,
+          },
+        },
+      ];
+    }
+
     if (messageType !== "text") {
       return [
         {
@@ -140,6 +158,9 @@ export const zapsterWhatsappChannelAdapter: ChannelAdapter = {
       },
     ];
   },
+  async downloadMedia(input) {
+    return downloadZapsterMedia(input);
+  },
   async sendMessage(input) {
     return sendZapsterMessage(input);
   },
@@ -169,6 +190,15 @@ type NormalizedZapsterWebhookMessage = {
   contactId?: string;
   type?: string;
   text?: string;
+  audio?: {
+    providerMediaId: string;
+    kind: "voice" | "audio";
+    mimeType?: string;
+    filename?: string;
+    durationSeconds?: number;
+    sizeBytes?: number;
+    downloadUrl?: string;
+  };
 };
 
 function normalizeZapsterOfficialMessage(body: Record<string, unknown>): NormalizedZapsterWebhookMessage | null {
@@ -185,17 +215,48 @@ function normalizeZapsterOfficialMessage(body: Record<string, unknown>): Normali
     contactId: readString(sender, "id"),
     type: readString(data, "type"),
     text: readString(content, "text"),
+    audio: normalizeZapsterAudio(content),
   };
 }
 
 function normalizeZapsterLegacyMessage(body: Record<string, unknown>): NormalizedZapsterWebhookMessage {
   const message = readRecord(body, "message");
+  const audio = readRecord(message, "audio");
 
   return {
     id: readString(message, "id"),
     contactId: readString(message, "from"),
     type: readString(message, "type"),
     text: readString(readRecord(message, "text"), "body"),
+    audio: normalizeZapsterAudio(audio),
+  };
+}
+
+function normalizeZapsterAudio(value: Record<string, unknown>): NormalizedZapsterWebhookMessage["audio"] {
+  const mediaId = readString(value, "id") ?? readString(value, "media_id") ?? readString(value, "mediaId");
+  const downloadUrl =
+    readString(value, "url") ??
+    readString(value, "download_url") ??
+    readString(value, "downloadUrl") ??
+    readString(value, "media_url") ??
+    readString(value, "mediaUrl");
+
+  if (!mediaId && !downloadUrl) {
+    return undefined;
+  }
+
+  return {
+    providerMediaId: mediaId ?? downloadUrl ?? "unknown",
+    kind: readString(value, "ptt") === "true" ? "voice" : "audio",
+    ...(readString(value, "mime_type") ?? readString(value, "mimeType")
+      ? { mimeType: readString(value, "mime_type") ?? readString(value, "mimeType") }
+      : {}),
+    filename: readString(value, "filename") ?? readString(value, "file_name") ?? defaultZapsterAudioFilename(value),
+    ...(readNumber(value, "duration") !== undefined ? { durationSeconds: readNumber(value, "duration") } : {}),
+    ...(readNumber(value, "file_size") ?? readNumber(value, "size")
+      ? { sizeBytes: readNumber(value, "file_size") ?? readNumber(value, "size") }
+      : {}),
+    ...(downloadUrl ? { downloadUrl } : {}),
   };
 }
 
@@ -249,6 +310,8 @@ export type ZapsterSendMessageRequest = {
 type ZapsterFetch = (url: string, init: RequestInit) => Promise<Response>;
 
 const ZAPSTER_SEND_MESSAGE_URL = "https://api.zapsterapi.com/v1/wa/messages";
+const ZAPSTER_DEFAULT_MEDIA_HOSTS = ["api.zapsterapi.com"];
+const ZAPSTER_MAX_DOWNLOAD_BYTES = 25_000_000;
 
 export function buildZapsterSendMessageRequest(input: ChannelSendInput): ZapsterSendMessageRequest {
   return buildZapsterSendMessageRequestInternal(input, "<redacted>");
@@ -381,6 +444,239 @@ export async function sendZapsterMessage(
   };
 }
 
+export async function downloadZapsterMedia(
+  input: ChannelMediaDownloadInput,
+  fetcher: ZapsterFetch = fetch,
+): Promise<ChannelMediaDownloadResult> {
+  const apiKey = input.secrets.ZAPSTER_API_KEY;
+  const audio = input.message.audio;
+
+  if (!apiKey) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "channel_secret_missing",
+      message: "Secret ZAPSTER_API_KEY is missing.",
+    };
+  }
+
+  if (!audio?.downloadUrl) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "channel_audio_download_unavailable",
+      message: "Zapster audio payload did not include a media download URL.",
+    };
+  }
+
+  const mediaUrl = validateZapsterMediaDownloadUrl(audio.downloadUrl);
+
+  if (!mediaUrl.ok) {
+    return mediaUrl;
+  }
+
+  let response: Response;
+
+  try {
+    response = await fetcher(mediaUrl.url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    });
+  } catch (error) {
+    return {
+      ok: false,
+      retryable: true,
+      code: "channel_provider_unavailable",
+      message: `Zapster media download failed before a response: ${redactString(
+        error instanceof Error ? error.message : String(error),
+        [apiKey, mediaUrl.url],
+      )}`,
+    };
+  }
+
+  if (!response.ok) {
+    return {
+      ok: false,
+      retryable: response.status === 429 || response.status >= 500,
+      code: response.status === 429 || response.status >= 500
+        ? "channel_provider_unavailable"
+        : "channel_media_download_failed",
+      message: `Zapster media download returned HTTP ${response.status}.`,
+      providerMetadata: {
+        status: response.status,
+      },
+    };
+  }
+
+  const maxDownloadBytes = input.maxBytes ?? ZAPSTER_MAX_DOWNLOAD_BYTES;
+  const bytes = await readResponseBytesWithLimit(response, maxDownloadBytes);
+
+  if (!bytes.ok) {
+    return bytes;
+  }
+
+  return {
+    ok: true,
+    audio: bytes.audio,
+    filename: audio.filename ?? `${audio.providerMediaId}.ogg`,
+    ...(audio.mimeType ? { mimeType: audio.mimeType } : {}),
+    ...(audio.durationSeconds !== undefined ? { durationSeconds: audio.durationSeconds } : {}),
+    sizeBytes: bytes.audio.byteLength,
+    providerMetadata: {
+      status: response.status,
+    },
+  };
+}
+
+function validateZapsterMediaDownloadUrl(rawUrl: string):
+  | {
+      ok: true;
+      url: string;
+    }
+  | {
+      ok: false;
+      retryable: false;
+      code: "channel_audio_download_unavailable";
+      message: string;
+    } {
+  let url: URL;
+
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return {
+      ok: false,
+      retryable: false,
+      code: "channel_audio_download_unavailable",
+      message: "Zapster audio download URL is not a valid URL.",
+    };
+  }
+
+  if (url.protocol !== "https:") {
+    return {
+      ok: false,
+      retryable: false,
+      code: "channel_audio_download_unavailable",
+      message: "Zapster audio download URL must use HTTPS.",
+    };
+  }
+
+  const hostname = url.hostname.toLowerCase();
+  const allowed = ZAPSTER_DEFAULT_MEDIA_HOSTS.some((host) => hostname === host || hostname.endsWith(`.${host}`));
+
+  if (!allowed) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "channel_audio_download_unavailable",
+      message: "Zapster audio download URL host is not allowed.",
+    };
+  }
+
+  url.username = "";
+  url.password = "";
+
+  return {
+    ok: true,
+    url: url.href,
+  };
+}
+
+async function readResponseBytesWithLimit(
+  response: Response,
+  maxBytes: number,
+): Promise<
+  | {
+      ok: true;
+      audio: Uint8Array;
+    }
+  | {
+      ok: false;
+      retryable: false;
+      code: "channel_audio_too_large";
+      message: string;
+      providerMetadata?: Record<string, unknown>;
+    }
+> {
+  const contentLength = response.headers.get("content-length");
+  const declaredBytes = contentLength ? Number(contentLength) : undefined;
+
+  if (declaredBytes !== undefined && Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "channel_audio_too_large",
+      message: `Audio response declares ${declaredBytes} bytes, which exceeds the configured ${maxBytes} byte limit.`,
+      providerMetadata: {
+        sizeBytes: declaredBytes,
+      },
+    };
+  }
+
+  if (!response.body) {
+    const audio = new Uint8Array(await response.arrayBuffer());
+
+    if (audio.byteLength > maxBytes) {
+      return {
+        ok: false,
+        retryable: false,
+        code: "channel_audio_too_large",
+        message: `Audio response is ${audio.byteLength} bytes, which exceeds the configured ${maxBytes} byte limit.`,
+        providerMetadata: {
+          sizeBytes: audio.byteLength,
+        },
+      };
+    }
+
+    return { ok: true, audio };
+  }
+
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let totalBytes = 0;
+
+  try {
+    while (true) {
+      const chunk = await reader.read();
+
+      if (chunk.done) {
+        break;
+      }
+
+      totalBytes += chunk.value.byteLength;
+
+      if (totalBytes > maxBytes) {
+        await reader.cancel().catch(() => undefined);
+        return {
+          ok: false,
+          retryable: false,
+          code: "channel_audio_too_large",
+          message: `Audio response exceeded the configured ${maxBytes} byte limit while downloading.`,
+          providerMetadata: {
+            sizeBytes: totalBytes,
+          },
+        };
+      }
+
+      chunks.push(chunk.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const audio = new Uint8Array(totalBytes);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    audio.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  return { ok: true, audio };
+}
+
 function buildZapsterSendMessageRequestInternal(
   input: ChannelSendInput,
   instanceId: string,
@@ -494,6 +790,29 @@ function readString(value: Record<string, unknown>, key: string): string | undef
   return typeof field === "string" && field.length > 0 ? field : undefined;
 }
 
+function readNumber(value: Record<string, unknown>, key: string): number | undefined {
+  const field = value[key];
+  return typeof field === "number" && Number.isFinite(field) ? field : undefined;
+}
+
+function defaultZapsterAudioFilename(value: Record<string, unknown>): string {
+  const mimeType = readString(value, "mime_type") ?? readString(value, "mimeType");
+
+  if (mimeType?.includes("ogg")) {
+    return "audio.ogg";
+  }
+
+  if (mimeType?.includes("mpeg") || mimeType?.includes("mp3")) {
+    return "audio.mp3";
+  }
+
+  if (mimeType?.includes("wav")) {
+    return "audio.wav";
+  }
+
+  return "audio.ogg";
+}
+
 function isPositiveIntegerHeader(value: string | null): value is string {
   return typeof value === "string" && /^[1-9]\d*$/.test(value);
 }

package/src/runtime/channels.ts

@@ -1,13 +1,17 @@
 import type { AgentChannel, ChannelProvider, ChannelType } from "../index";
 
 export type ChannelMessageRole = "user" | "assistant";
-export type ChannelMessageContentType = "text";
+export type ChannelMessageContentType = "text" | "audio";
 export type ChannelEventKind = "message" | "delivery_status" | "unsupported";
 export type ChannelDeliveryDirection = "inbound" | "outbound";
 export type ChannelDeliveryState =
   | "webhook_received"
   | "received"
   | "validated"
+  | "audio_received"
+  | "audio_downloaded"
+  | "transcribing"
+  | "transcribed"
   | "duplicate"
   | "buffered"
   | "queued"
@@ -45,11 +49,22 @@ export type ChannelExternalIdentity = {
   redactedDisplay?: string;
 };
 
+export type ChannelAudioAttachment = {
+  providerMediaId: string;
+  kind: "voice" | "audio";
+  mimeType?: string;
+  filename?: string;
+  durationSeconds?: number;
+  sizeBytes?: number;
+  downloadUrl?: string;
+};
+
 export type NormalizedChannelMessage = {
   role: ChannelMessageRole;
   contentType: ChannelMessageContentType;
   content: string;
   providerMessageId?: string;
+  audio?: ChannelAudioAttachment;
 };
 
 export type NormalizedChannelEvent = ChannelAdapterId & {
@@ -87,6 +102,36 @@ export type ChannelSendInput = ChannelAdapterId & {
   secrets: Record<string, string>;
 };
 
+export type ChannelMediaDownloadInput = ChannelAdapterId & {
+  channelId: string;
+  message: NormalizedChannelMessage;
+  secrets: Record<string, string>;
+  maxBytes?: number;
+};
+
+export type ChannelMediaDownloadResult =
+  | {
+      ok: true;
+      audio: Uint8Array;
+      filename: string;
+      mimeType?: string;
+      durationSeconds?: number;
+      sizeBytes?: number;
+      providerMetadata?: Record<string, unknown>;
+    }
+  | {
+      ok: false;
+      retryable: boolean;
+      code:
+        | "channel_secret_missing"
+        | "channel_audio_download_unavailable"
+        | "channel_audio_too_large"
+        | "channel_provider_unavailable"
+        | "channel_media_download_failed";
+      message: string;
+      providerMetadata?: Record<string, unknown>;
+    };
+
 export type ChannelSendResult =
   | {
       ok: true;
@@ -120,6 +165,7 @@ export type ChannelStatusResult = {
 export type ChannelAdapter = ChannelAdapterId & {
   requiredSecrets: string[];
   normalizeInbound(input: RawWebhookEvent): Promise<NormalizedChannelEvent[]> | NormalizedChannelEvent[];
+  downloadMedia?(input: ChannelMediaDownloadInput): Promise<ChannelMediaDownloadResult>;
   sendMessage(input: ChannelSendInput): Promise<ChannelSendResult>;
   verifyWebhook?(input: WebhookVerificationInput): Promise<WebhookVerificationResult> | WebhookVerificationResult;
   getStatus?(input: ChannelStatusInput): Promise<ChannelStatusResult> | ChannelStatusResult;

package/src/runtime/config.ts

@@ -16,6 +16,8 @@ import type {
   TelegramAllowedUpdate,
   AgentKnowledgeEmbeddingProvider,
   ChannelBufferMode,
+  ChannelAudioMode,
+  TranscriptionProviderName,
 } from "../index";
 import { AgentKitError } from "./errors";
 import { isValidTimeZone } from "./prompt-context";
@@ -28,8 +30,10 @@ 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_BUFFER_MODES = new Set<ChannelBufferMode>(["off", "debounce"]);
+const CHANNEL_AUDIO_MODES = new Set<ChannelAudioMode>(["off", "reject", "transcribe"]);
 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"]);
 const CHANNEL_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
 const SECRET_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -230,7 +234,8 @@ function validateAgentConfig(value: unknown): asserts value is AgentConfig {
     }
   }
 
-  validateChannels(value.channels, value.runtime as AgentRuntime);
+  validateTranscriptionConfig(value.transcription);
+  validateChannels(value.channels, value.runtime as AgentRuntime, Boolean(value.transcription));
   validateKnowledgeConfig(value.knowledge);
 
   if (!isRecord(value.access) || !ACCESS_MODES.has(value.access.mode as AccessMode)) {
@@ -253,6 +258,46 @@ function validateAgentConfig(value: unknown): asserts value is AgentConfig {
   validateFilesConfig(value.storage.files);
 }
 
+function validateTranscriptionConfig(value: unknown): void {
+  if (value === undefined) {
+    return;
+  }
+
+  if (!isRecord(value)) {
+    throw invalidConfig("transcription must be an object when provided.");
+  }
+
+  if (!TRANSCRIPTION_PROVIDERS.has(value.provider as TranscriptionProviderName)) {
+    throw invalidConfig(`transcription.provider must be one of: ${Array.from(TRANSCRIPTION_PROVIDERS).join(", ")}.`);
+  }
+
+  expectString(value.model, "transcription.model");
+
+  if (value.secret !== undefined) {
+    expectString(value.secret, "transcription.secret");
+    validateSecretNames([value.secret], "transcription.secret");
+  }
+
+  if (value.language !== undefined) {
+    expectString(value.language, "transcription.language");
+  }
+
+  if (value.prompt !== undefined) {
+    expectString(value.prompt, "transcription.prompt");
+  }
+
+  if (value.limits !== undefined) {
+    if (!isRecord(value.limits)) {
+      throw invalidConfig("transcription.limits must be an object when provided.");
+    }
+
+    validateOptionalPositiveInteger(value.limits.maxDurationSeconds, "transcription.limits.maxDurationSeconds");
+    validateOptionalPositiveInteger(value.limits.maxBytes, "transcription.limits.maxBytes");
+  }
+
+  validateOptionalPositiveInteger(value.rawAudioTtlSeconds, "transcription.rawAudioTtlSeconds");
+}
+
 function validateKnowledgeConfig(value: unknown): void {
   if (value === undefined) {
     return;
@@ -381,7 +426,7 @@ function validateKnowledgeRetrieval(value: unknown): void {
   }
 }
 
-function validateChannels(value: unknown, runtime: AgentRuntime): void {
+function validateChannels(value: unknown, runtime: AgentRuntime, hasTranscriptionConfig: boolean): void {
   if (value === undefined) {
     return;
   }
@@ -397,7 +442,7 @@ function validateChannels(value: unknown, runtime: AgentRuntime): void {
   const names = new Set<string>();
 
   for (const [index, channel] of value.entries()) {
-    validateChannel(channel, index);
+    validateChannel(channel, index, hasTranscriptionConfig);
 
     if (names.has(channel.name)) {
       throw invalidConfig(`channels[${index}].name must be unique within the Agent Capsule.`);
@@ -407,7 +452,7 @@ function validateChannels(value: unknown, runtime: AgentRuntime): void {
   }
 }
 
-function validateChannel(value: unknown, index: number): asserts value is AgentChannel {
+function validateChannel(value: unknown, index: number, hasTranscriptionConfig: boolean): asserts value is AgentChannel {
   if (!isRecord(value)) {
     throw invalidConfig(`channels[${index}] must be an object.`);
   }
@@ -432,6 +477,7 @@ function validateChannel(value: unknown, index: number): asserts value is AgentC
   validateSecretNames(value.secrets, `channels[${index}].secrets`);
   validateChannelLimits(value.limits, index);
   validateChannelBuffer(value.buffer, index);
+  validateChannelAudio(value.audio, index, hasTranscriptionConfig);
 
   if (value.type === "website") {
     validateWebsiteChannel(value, index);
@@ -446,6 +492,31 @@ function validateChannel(value: unknown, index: number): asserts value is AgentC
   validateWhatsappChannel(value, index);
 }
 
+function validateChannelAudio(value: unknown, index: number, hasTranscriptionConfig: boolean): void {
+  if (value === undefined) {
+    return;
+  }
+
+  if (!isRecord(value)) {
+    throw invalidConfig(`channels[${index}].audio must be an object when provided.`);
+  }
+
+  if (!CHANNEL_AUDIO_MODES.has(value.mode as ChannelAudioMode)) {
+    throw invalidConfig(`channels[${index}].audio.mode must be "off", "reject", or "transcribe".`);
+  }
+
+  if (value.mode === "transcribe" && !hasTranscriptionConfig) {
+    throw invalidConfig(`channels[${index}].audio.mode "transcribe" requires top-level transcription config.`);
+  }
+
+  if (value.mode !== "off") {
+    expectString(value.fallbackMessage, `channels[${index}].audio.fallbackMessage`);
+  }
+
+  validateOptionalPositiveInteger(value.maxDurationSeconds, `channels[${index}].audio.maxDurationSeconds`);
+  validateOptionalPositiveInteger(value.maxBytes, `channels[${index}].audio.maxBytes`);
+}
+
 function validateWebsiteChannel(value: Record<string, unknown>, index: number): void {
   if (value.provider !== "agentkit") {
     throw invalidConfig(`channels[${index}].provider must be "agentkit" when type is "website".`);
@@ -562,6 +633,16 @@ function validateSecretNames(secrets: string[], field: string): void {
   }
 }
 
+function validateOptionalPositiveInteger(value: unknown, field: string): void {
+  if (value === undefined) {
+    return;
+  }
+
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw invalidConfig(`${field} must be a positive integer when provided.`);
+  }
+}
+
 function expectRequiredSecrets(value: unknown, requiredSecrets: string[], field: string): void {
   const declaredSecrets = new Set(Array.isArray(value) ? value : []);
   const missingSecrets = requiredSecrets.filter((secret) => !declaredSecrets.has(secret));

package/src/runtime/core/manifest.ts

@@ -4,6 +4,7 @@ import type { AgentConfig, AgentTool } from "../../index";
 import type { LoadedAgentCapsule } from "../config";
 import { resolveKnowledgeConfig } from "../knowledge/config";
 import { KNOWLEDGE_SEARCH_TOOL_NAME } from "../knowledge/tool";
+import { resolveTranscriptionConfig } from "../transcription";
 
 export type ManifestSchema = {
   source: string;
@@ -28,6 +29,19 @@ export type SharedAgentManifest = {
     timeoutMs: number | null;
   }>;
   channels: NonNullable<AgentConfig["channels"]>;
+  transcription: {
+    enabled: boolean;
+    provider: string | null;
+    model: string | null;
+    secret: string | null;
+    language: string | null;
+    prompt: string | null;
+    limits: {
+      maxDurationSeconds: number | null;
+      maxBytes: number | null;
+    };
+    rawAudioTtlSeconds: number | null;
+  };
   knowledge: {
     enabled: boolean;
     sources: Array<{
@@ -80,6 +94,7 @@ export function buildSharedAgentManifest(
   const database = buildDatabaseManifest(capsule, options.databaseSchema ?? null);
   const files = buildFilesManifest(capsule);
   const knowledge = resolveKnowledgeConfig(capsule.config);
+  const transcription = resolveTranscriptionConfig(capsule.config.transcription);
 
   requiredSecrets.add("AGENTKIT_PRIVATE_TOKEN");
 
@@ -100,6 +115,10 @@ export function buildSharedAgentManifest(
     requiredSecrets.add(knowledge.embedding.secret);
   }
 
+  if (transcription.secret) {
+    requiredSecrets.add(transcription.secret);
+  }
+
   for (const tool of capsule.config.tools ?? []) {
     for (const secret of tool.secrets ?? []) {
       requiredSecrets.add(secret);
@@ -130,6 +149,19 @@ export function buildSharedAgentManifest(
       timeoutMs: tool.timeoutMs ?? null,
     })),
     channels: capsule.config.channels ?? [],
+    transcription: {
+      enabled: transcription.enabled,
+      provider: transcription.enabled ? transcription.provider : null,
+      model: transcription.enabled ? transcription.model : null,
+      secret: transcription.secret,
+      language: transcription.language,
+      prompt: transcription.prompt,
+      limits: {
+        maxDurationSeconds: transcription.limits.maxDurationSeconds ?? null,
+        maxBytes: transcription.limits.maxBytes ?? null,
+      },
+      rawAudioTtlSeconds: transcription.rawAudioTtlSeconds,
+    },
     knowledge: {
       enabled: knowledge.enabled,
       sources: knowledge.sources.map((source) => ({