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

package/src/runtime/transcription.ts

@@ -0,0 +1,483 @@
+import type { AgentTranscriptionConfig, TranscriptionProviderName } from "../index";
+
+export type ResolvedTranscriptionConfig = {
+  enabled: boolean;
+  provider: TranscriptionProviderName;
+  model: string;
+  secret: string | null;
+  language: string | null;
+  prompt: string | null;
+  limits: {
+    maxDurationSeconds?: number;
+    maxBytes?: number;
+  };
+  rawAudioTtlSeconds: number | null;
+};
+
+export type TranscriptionInput = {
+  config: ResolvedTranscriptionConfig;
+  secrets: Record<string, string>;
+  audio: Uint8Array;
+  filename: string;
+  mimeType?: string;
+  durationSeconds?: number;
+  providerMetadata?: Record<string, unknown>;
+};
+
+export type TranscriptionFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+export type TranscriptionResult =
+  | {
+      ok: true;
+      text: string;
+      provider: TranscriptionProviderName;
+      model: string;
+      language?: string;
+      durationSeconds?: number;
+      providerMetadata?: Record<string, unknown>;
+    }
+  | {
+      ok: false;
+      retryable: boolean;
+      code:
+        | "transcription_disabled"
+        | "transcription_secret_missing"
+        | "transcription_model_unsupported"
+        | "transcription_audio_too_large"
+        | "transcription_audio_too_long"
+        | "transcription_audio_format_unsupported"
+        | "transcription_provider_unavailable"
+        | "transcription_failed";
+      message: string;
+      provider?: TranscriptionProviderName;
+      model?: string;
+      providerMetadata?: Record<string, unknown>;
+    };
+
+export type TranscriptionAdapter = {
+  provider: TranscriptionProviderName;
+  models: string[];
+  supportedMimeTypes: string[];
+  supportedExtensions: string[];
+  maxBytes: number;
+  requiredSecret(config: ResolvedTranscriptionConfig): string | null;
+  transcribe(input: TranscriptionInput, fetcher?: TranscriptionFetch): Promise<TranscriptionResult>;
+};
+
+const DEFAULT_MAX_BYTES = 25_000_000;
+const OPENAI_MODELS = ["gpt-4o-mini-transcribe", "gpt-4o-transcribe", "whisper-1"];
+const GROQ_MODELS = ["whisper-large-v3-turbo", "whisper-large-v3", "distil-whisper-large-v3-en"];
+const OPENAI_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"];
+const GROQ_EXTENSIONS = ["flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"];
+const OPENAI_MIME_TYPES = [
+  "audio/mpeg",
+  "audio/mp3",
+  "audio/mp4",
+  "audio/mpga",
+  "audio/m4a",
+  "audio/wav",
+  "audio/webm",
+  "video/mp4",
+];
+const GROQ_MIME_TYPES = [
+  ...OPENAI_MIME_TYPES,
+  "audio/flac",
+  "audio/ogg",
+  "audio/opus",
+  "application/ogg",
+];
+
+export function resolveTranscriptionConfig(config: AgentTranscriptionConfig | undefined): ResolvedTranscriptionConfig {
+  if (!config) {
+    return {
+      enabled: false,
+      provider: "test",
+      model: "fake",
+      secret: null,
+      language: null,
+      prompt: null,
+      limits: {},
+      rawAudioTtlSeconds: null,
+    };
+  }
+
+  return {
+    enabled: true,
+    provider: config.provider,
+    model: config.model,
+    secret: config.secret ?? defaultTranscriptionSecret(config.provider),
+    language: config.language ?? null,
+    prompt: config.prompt ?? null,
+    limits: {
+      ...(config.limits?.maxDurationSeconds !== undefined
+        ? { maxDurationSeconds: config.limits.maxDurationSeconds }
+        : {}),
+      ...(config.limits?.maxBytes !== undefined ? { maxBytes: config.limits.maxBytes } : {}),
+    },
+    rawAudioTtlSeconds: config.rawAudioTtlSeconds ?? 3600,
+  };
+}
+
+export async function transcribeAudio(
+  input: TranscriptionInput,
+  fetcher: TranscriptionFetch = fetch,
+): Promise<TranscriptionResult> {
+  if (!input.config.enabled) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_disabled",
+      message: "Audio transcription is not configured for this Agent Capsule.",
+    };
+  }
+
+  const adapter = transcriptionAdapterFor(input.config.provider);
+
+  if (!adapter) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_model_unsupported",
+      message: `No transcription adapter is registered for ${input.config.provider}.`,
+      provider: input.config.provider,
+      model: input.config.model,
+    };
+  }
+
+  const validation = validateTranscriptionInput(adapter, input);
+
+  if (!validation.ok) {
+    return validation;
+  }
+
+  return adapter.transcribe(input, fetcher);
+}
+
+export function transcriptionAdapterFor(provider: TranscriptionProviderName): TranscriptionAdapter | null {
+  if (provider === "test") {
+    return testTranscriptionAdapter;
+  }
+
+  if (provider === "openai") {
+    return openaiTranscriptionAdapter;
+  }
+
+  if (provider === "groq") {
+    return groqTranscriptionAdapter;
+  }
+
+  return null;
+}
+
+export function defaultTranscriptionSecret(provider: TranscriptionProviderName): string | null {
+  if (provider === "openai") {
+    return "OPENAI_API_KEY";
+  }
+
+  if (provider === "groq") {
+    return "GROQ_API_KEY";
+  }
+
+  return null;
+}
+
+function validateTranscriptionInput(adapter: TranscriptionAdapter, input: TranscriptionInput): TranscriptionResult {
+  if (!adapter.models.includes(input.config.model)) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_model_unsupported",
+      message: `${input.config.provider} transcription model ${input.config.model} is not supported by AgentKit.`,
+      provider: input.config.provider,
+      model: input.config.model,
+    };
+  }
+
+  const maxBytes = Math.min(input.config.limits.maxBytes ?? adapter.maxBytes, adapter.maxBytes);
+  if (input.audio.byteLength > maxBytes) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_audio_too_large",
+      message: `Audio file is ${input.audio.byteLength} bytes, which exceeds the configured ${maxBytes} byte limit.`,
+      provider: input.config.provider,
+      model: input.config.model,
+    };
+  }
+
+  if (
+    input.durationSeconds !== undefined &&
+    input.config.limits.maxDurationSeconds !== undefined &&
+    input.durationSeconds > input.config.limits.maxDurationSeconds
+  ) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_audio_too_long",
+      message: `Audio is ${input.durationSeconds}s, which exceeds the configured ${input.config.limits.maxDurationSeconds}s limit.`,
+      provider: input.config.provider,
+      model: input.config.model,
+    };
+  }
+
+  if (!isSupportedAudioFormat(adapter, input.filename, input.mimeType)) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_audio_format_unsupported",
+      message: `${input.config.provider} does not support audio format ${input.mimeType ?? extensionFor(input.filename) ?? "unknown"}.`,
+      provider: input.config.provider,
+      model: input.config.model,
+    };
+  }
+
+  const secret = adapter.requiredSecret(input.config);
+  if (secret && !input.secrets[secret]) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_secret_missing",
+      message: `Secret ${secret} is not set for audio transcription.`,
+      provider: input.config.provider,
+      model: input.config.model,
+    };
+  }
+
+  return {
+    ok: true,
+    text: "",
+    provider: input.config.provider,
+    model: input.config.model,
+  };
+}
+
+const testTranscriptionAdapter: TranscriptionAdapter = {
+  provider: "test",
+  models: ["fake"],
+  supportedMimeTypes: ["audio/wav", "audio/ogg", "audio/mpeg", "audio/webm", "application/octet-stream"],
+  supportedExtensions: ["wav", "ogg", "mp3", "webm", "bin"],
+  maxBytes: DEFAULT_MAX_BYTES,
+  requiredSecret() {
+    return null;
+  },
+  async transcribe(input) {
+    const text = decodeFixtureTranscript(input.audio) ?? "fake audio transcript";
+
+    return {
+      ok: true,
+      text,
+      provider: "test",
+      model: input.config.model,
+      ...(input.config.language ? { language: input.config.language } : {}),
+      ...(input.durationSeconds !== undefined ? { durationSeconds: input.durationSeconds } : {}),
+    };
+  },
+};
+
+const openaiTranscriptionAdapter: TranscriptionAdapter = {
+  provider: "openai",
+  models: OPENAI_MODELS,
+  supportedMimeTypes: OPENAI_MIME_TYPES,
+  supportedExtensions: OPENAI_EXTENSIONS,
+  maxBytes: DEFAULT_MAX_BYTES,
+  requiredSecret(config) {
+    return config.secret;
+  },
+  async transcribe(input, fetcher = fetch) {
+    return transcribeViaOpenAiCompatibleEndpoint({
+      input,
+      fetcher,
+      url: "https://api.openai.com/v1/audio/transcriptions",
+      apiKey: input.secrets[input.config.secret ?? ""],
+      provider: "openai",
+    });
+  },
+};
+
+const groqTranscriptionAdapter: TranscriptionAdapter = {
+  provider: "groq",
+  models: GROQ_MODELS,
+  supportedMimeTypes: GROQ_MIME_TYPES,
+  supportedExtensions: GROQ_EXTENSIONS,
+  maxBytes: DEFAULT_MAX_BYTES,
+  requiredSecret(config) {
+    return config.secret;
+  },
+  async transcribe(input, fetcher = fetch) {
+    return transcribeViaOpenAiCompatibleEndpoint({
+      input,
+      fetcher,
+      url: "https://api.groq.com/openai/v1/audio/transcriptions",
+      apiKey: input.secrets[input.config.secret ?? ""],
+      provider: "groq",
+    });
+  },
+};
+
+async function transcribeViaOpenAiCompatibleEndpoint(input: {
+  input: TranscriptionInput;
+  fetcher: TranscriptionFetch;
+  url: string;
+  apiKey: string | undefined;
+  provider: TranscriptionProviderName;
+}): Promise<TranscriptionResult> {
+  if (!input.apiKey) {
+    const secret = input.input.config.secret ?? defaultTranscriptionSecret(input.provider) ?? "TRANSCRIPTION_API_KEY";
+
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_secret_missing",
+      message: `Secret ${secret} is not set for audio transcription.`,
+      provider: input.provider,
+      model: input.input.config.model,
+    };
+  }
+
+  const form = new FormData();
+  form.set("model", input.input.config.model);
+  form.set(
+    "file",
+    new Blob([arrayBufferForBlob(input.input.audio)], { type: input.input.mimeType ?? "application/octet-stream" }),
+    input.input.filename,
+  );
+  form.set("response_format", "json");
+
+  if (input.input.config.language) {
+    form.set("language", input.input.config.language);
+  }
+
+  if (input.input.config.prompt) {
+    form.set("prompt", input.input.config.prompt);
+  }
+
+  let response: Response;
+
+  try {
+    response = await input.fetcher(input.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${input.apiKey}`,
+      },
+      body: form,
+    });
+  } catch (error) {
+    return {
+      ok: false,
+      retryable: true,
+      code: "transcription_provider_unavailable",
+      message: `Transcription provider request failed before a response: ${redactSecret(
+        error instanceof Error ? error.message : String(error),
+        input.apiKey,
+      )}`,
+      provider: input.provider,
+      model: input.input.config.model,
+    };
+  }
+
+  const payload = await response.json().catch(() => null);
+
+  if (!response.ok) {
+    const message = readProviderError(payload) ?? `Transcription provider returned HTTP ${response.status}.`;
+
+    return {
+      ok: false,
+      retryable: response.status === 429 || response.status >= 500,
+      code: response.status === 429 || response.status >= 500 ? "transcription_provider_unavailable" : "transcription_failed",
+      message: redactSecret(message, input.apiKey),
+      provider: input.provider,
+      model: input.input.config.model,
+      providerMetadata: {
+        status: response.status,
+      },
+    };
+  }
+
+  const text = isRecord(payload) && typeof payload.text === "string" ? payload.text.trim() : "";
+
+  if (!text) {
+    return {
+      ok: false,
+      retryable: false,
+      code: "transcription_failed",
+      message: "Transcription provider returned an empty transcript.",
+      provider: input.provider,
+      model: input.input.config.model,
+      providerMetadata: {
+        status: response.status,
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    text,
+    provider: input.provider,
+    model: input.input.config.model,
+    ...(input.input.config.language ? { language: input.input.config.language } : {}),
+    ...(input.input.durationSeconds !== undefined ? { durationSeconds: input.input.durationSeconds } : {}),
+    providerMetadata: {
+      status: response.status,
+    },
+  };
+}
+
+function isSupportedAudioFormat(adapter: TranscriptionAdapter, filename: string, mimeType?: string): boolean {
+  const normalizedMimeType = mimeType?.toLowerCase();
+
+  if (normalizedMimeType && adapter.supportedMimeTypes.includes(normalizedMimeType)) {
+    return true;
+  }
+
+  const extension = extensionFor(filename);
+
+  return Boolean(extension && adapter.supportedExtensions.includes(extension));
+}
+
+function extensionFor(filename: string): string | null {
+  const match = /\.([a-z0-9]+)$/i.exec(filename);
+  return match ? match[1].toLowerCase() : null;
+}
+
+function decodeFixtureTranscript(audio: Uint8Array): string | null {
+  try {
+    const text = new TextDecoder().decode(audio).trim();
+    return text.length > 0 && /^[\t\n\r -~\u00a0-\uffff]+$/.test(text) ? text : null;
+  } catch {
+    return null;
+  }
+}
+
+function arrayBufferForBlob(audio: Uint8Array): ArrayBuffer {
+  const copy = new Uint8Array(audio.byteLength);
+  copy.set(audio);
+  return copy.buffer;
+}
+
+function readProviderError(payload: unknown): string | null {
+  if (!isRecord(payload)) {
+    return null;
+  }
+
+  if (typeof payload.error === "string") {
+    return payload.error;
+  }
+
+  if (isRecord(payload.error) && typeof payload.error.message === "string") {
+    return payload.error.message;
+  }
+
+  if (typeof payload.message === "string") {
+    return payload.message;
+  }
+
+  return null;
+}
+
+function redactSecret(value: string, secret: string): string {
+  return secret ? value.replaceAll(secret, "<redacted>") : value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/src/templates/blank.ts

@@ -124,13 +124,18 @@ Answer clearly, ask for missing context when needed, and do not claim to have pe
       },
       {
         path: "evals/smoke.eval.ts",
-        contents: `export default {
+        contents: `import { defineEval } from "@andreprado/agentkit";
+
+export default defineEval({
   name: "smoke",
   input: "Say hello in one short sentence.",
   expect: {
-    contains: "hello",
+    response: {
+      caseInsensitiveContains: "hello",
+      maxLength: 160,
+    },
   },
-};
+});
 `,
       },
       {

package/src/templates/dentista.ts

@@ -83,6 +83,7 @@ export default defineAgent({
     name: "test",
     model: "fake",
   },
+  timeZone: "America/Sao_Paulo",
   instructions: "./prompts/instructions.md",
   secrets: [],
   tools: [listarHorariosDisponiveis, consultarConsulta, agendarConsulta, alterarConsulta],
@@ -282,7 +283,7 @@ export const listarHorariosDisponiveis = defineTool<ListarHorariosInput, { data:
   },
   async execute(input, ctx) {
     const date = normalizeDate(input.data);
-    const dateError = validateAppointmentDate(date);
+    const dateError = validateAppointmentDate(date, ctx.clock.now);
 
     if (dateError) {
       return {
@@ -409,6 +410,7 @@ export const agendarConsulta = defineTool<AgendarConsultaInput, AgendaOutput>({
       data,
       horario,
       confirmadoPeloCliente: input.confirmadoPeloCliente,
+      now: ctx.clock.now,
     });
 
     if (!validation.ok) {
@@ -482,6 +484,7 @@ export const alterarConsulta = defineTool<AlterarConsultaInput, AgendaOutput>({
       data,
       horario,
       confirmadoPeloCliente: input.confirmadoPeloCliente,
+      now: ctx.clock.now,
     });
 
     if (!contact.ok) {
@@ -575,9 +578,9 @@ export const alterarConsulta = defineTool<AlterarConsultaInput, AgendaOutput>({
 
 async function validateScheduleRequest(
   db: DatabaseRunner,
-  input: { data: string; horario: string; confirmadoPeloCliente: boolean },
+  input: { data: string; horario: string; confirmadoPeloCliente: boolean; now: Date },
 ): Promise<{ ok: boolean; mensagem: string; disponiveis: string[] }> {
-  const dateError = validateAppointmentDate(input.data);
+  const dateError = validateAppointmentDate(input.data, input.now);
 
   if (dateError) {
     return {
@@ -698,7 +701,7 @@ function normalizeTime(input: string): string {
   return \`\${match[1].padStart(2, "0")}:\${match[2]}\`;
 }
 
-function validateAppointmentDate(data: string): string | null {
+function validateAppointmentDate(data: string, now: Date): string | null {
   if (!/^\\d{4}-\\d{2}-\\d{2}$/.test(data)) {
     return "Use a data no formato YYYY-MM-DD.";
   }
@@ -710,20 +713,20 @@ function validateAppointmentDate(data: string): string | null {
     return "Esta data nao existe. Confirme a data com o cliente.";
   }
 
-  if (data < todayInClinicTimezone()) {
+  if (data < todayInClinicTimezone(now)) {
     return "Nao agende consultas em datas passadas.";
   }
 
   return null;
 }
 
-function todayInClinicTimezone(): string {
+function todayInClinicTimezone(now: Date): string {
   const parts = new Intl.DateTimeFormat("en-US", {
     timeZone: CLINIC_TIME_ZONE,
     year: "numeric",
     month: "2-digit",
     day: "2-digit",
-  }).formatToParts(new Date());
+  }).formatToParts(now);
   const byType = Object.fromEntries(parts.map((part) => [part.type, part.value]));
   return \`\${byType.year}-\${byType.month}-\${byType.day}\`;
 }
@@ -838,13 +841,18 @@ Quando o cliente quiser alterar a própria consulta:
       },
       {
         path: "evals/smoke.eval.ts",
-        contents: `export default {
+        contents: `import { defineEval } from "@andreprado/agentkit";
+
+export default defineEval({
   name: "smoke",
   input: "Oi, quero marcar uma consulta.",
   expect: {
-    contains: "nome",
+    response: {
+      containsAny: ["nome", "Nome"],
+      notRegex: ["API_KEY|secret|token"],
+    },
   },
-};
+});
 `,
       },
       {

package/src/templates/skills/agentkit-build-agent/SKILL.md

@@ -13,11 +13,12 @@ Use this when the owner asks for an agent in plain language.
 2. If `AGENT_SPEC.md` does not exist, create it from the owner's plain-language request with `npm run agentkit -- spec init --brief "<owner request>"`. If it exists, update it directly before changing behavior.
 3. Infer the first useful local version from the owner's brief and the spec. Do not ask the owner to fill a form.
 4. Edit `prompts/instructions.md` for behavior, boundaries, intake questions, escalation rules, and tool-use policy.
-5. Add tools only when the agent needs action, live data, authorization-sensitive data, or durable writes.
-6. Add database tables to `schema.sql` or ordered `migrations/*.sql` when the agent owns records.
-7. Add `sync.ts` and `seed.sql` with `npm run agentkit -- sync init` when the agent depends on external catalogs or recurring imports.
-8. Add or update evals for the main flow. Prefer multi-turn `turns` evals for real conversations.
-9. Keep the capsule runnable on `test/fake` unless the owner has chosen a real provider.
+5. For scheduling, deadlines, reminders, or any relative-date behavior, set `timeZone` in `agentkit.config.ts` to the business/user timezone. AgentKit injects the current date, weekday, timestamp, and timezone dynamically at runtime; do not hardcode today's date in prompts.
+6. Add tools only when the agent needs action, live data, authorization-sensitive data, or durable writes.
+7. Add database tables to `schema.sql` or ordered `migrations/*.sql` when the agent owns records.
+8. Add `sync.ts` and `seed.sql` with `npm run agentkit -- sync init` when the agent depends on external catalogs or recurring imports.
+9. Add or update evals for the main flow. Prefer multi-turn `turns` evals for real conversations.
+10. Keep the capsule runnable on `test/fake` unless the owner has chosen a real provider.
 
 ## Templates
 

package/src/templates/skills/agentkit-build-agent/templates/appointment-intake.instructions.md

@@ -13,8 +13,9 @@ Required intake:
 - Any urgency or special constraints
 
 Rules:
+- Interpret today, tomorrow, weekdays, and vague time windows using the AgentKit runtime date context.
+- If the user's scheduling timezone may differ from the business timezone, confirm the timezone before booking.
 - Do not diagnose, promise outcomes, or provide emergency guidance beyond directing urgent cases to appropriate human or emergency support.
 - Do not create, change, or cancel an appointment without explicit user confirmation.
 - Do not invent availability.
 - Use the scheduling tools for availability and writes.
-

package/src/templates/skills/agentkit-capsule/SKILL.md

@@ -57,6 +57,6 @@ npm run eval
 - Keep `.env`, `.agentkit/`, and `node_modules/` out of commits.
 - Keep secret names in `.env.schema`; keep secret values in ignored `.env` or hosted managed secrets.
 - Keep the first useful version runnable with `test/fake` unless the owner explicitly chooses a real provider.
+- For scheduling or relative-date agents, set `timeZone` in `agentkit.config.ts`; AgentKit injects the current date, weekday, timestamp, and timezone dynamically at runtime.
 - Ask follow-up questions only when missing information blocks a safe local implementation.
 - Tell the owner when testing used `test/fake` instead of a real provider.
-

package/src/templates/skills/agentkit-channels/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: agentkit-channels
-description: Use when adding, connecting, testing, buffering, or debugging AgentKit website, Telegram, or WhatsApp channels, including channel config helpers, provider secrets, webhook setup, channel tests, delivery logs, and burst-message buffers.
+description: Use when adding, connecting, testing, buffering, transcribing audio, or debugging AgentKit website, Telegram, or WhatsApp channels, including channel config helpers, provider secrets, webhook setup, channel tests, delivery logs, burst-message buffers, and transcription provider secrets.
 ---
 
 # AgentKit Channels
@@ -16,6 +16,39 @@ Channels receive user messages. Tools let the agent call external systems. Keep
 5. Connect channel resources through the CLI.
 6. Test, doctor, and inspect delivery logs.
 
+## Audio Transcription
+
+Enable transcription at the agent level and opt in per channel with `audio.mode: "transcribe"`.
+
+```ts
+export default defineAgent({
+  // ...
+  transcription: {
+    provider: "groq",
+    model: "whisper-large-v3-turbo",
+    secret: "GROQ_API_KEY",
+    language: "pt",
+    limits: {
+      maxDurationSeconds: 180,
+      maxBytes: 20_000_000,
+    },
+  },
+  channels: [
+    telegramChannel({
+      name: "support-telegram",
+      audio: { mode: "transcribe" },
+    }),
+  ],
+});
+```
+
+V1 providers:
+
+- `openai`: `gpt-4o-mini-transcribe`, `gpt-4o-transcribe`, `whisper-1`; default secret `OPENAI_API_KEY`.
+- `groq`: `whisper-large-v3-turbo`, `whisper-large-v3`, `distil-whisper-large-v3-en`; default secret `GROQ_API_KEY`.
+
+Telegram voice notes are usually OGG/Opus, so use Groq for the default Telegram voice-note path in V1. Zapster audio needs a usable HTTPS Zapster media download URL in the webhook payload; arbitrary hosts are rejected before bearer auth is sent. Hosted channel creation requires the transcription secret automatically when the channel enables transcription. Webhooks only enqueue audio jobs; download and transcription run in the retryable channel worker before the agent run.
+
 ## Buffering
 
 Enable `buffer.mode: "debounce"` when clients send several short messages in a row and the agent should answer once.