@alia.onl/sdk 15.7.0 → 19.0.0

package/src/lib/labels.tsx

@@ -1,6 +1,11 @@
 import { createContext, type ReactNode, useContext, useMemo } from 'react';
 import { VOICE_ERROR_MESSAGES, type VoiceErrorCode } from './speech-messages';
-import { englishWorkLog, type Translate } from './work-log-copy';
+import { englishCopy, type Translate } from './copy';
+import { VOICE_CONTROLS_LABELS, type VoiceControlsLabels } from './voice-controls-labels';
+import type { VoiceCloseReason } from './voice-protocol';
+
+/** Why a call could not be opened; the host's `canStartVoice` answers with one. */
+export type VoiceBlockReason = 'sign-in' | 'plan-required' | 'credits-exhausted';
 
 /** Every string the chat UI draws itself. Bloom's own copy follows `BloomProvider locale`. */
 export interface AliaChatLabels {
@@ -11,11 +16,21 @@ export interface AliaChatLabels {
   more: string;
   chatActions: string;
   // Composer
-  placeholder: string;
+  /** The empty composer's prompt, naming the conversation's lead ("Ask Sindi..."). */
+  placeholder: (leadName: string) => string;
   addMenuGroup: string;
   addPhotos: string;
+  /** The add menu's row for documents, where the lead takes them. */
+  addDocuments: string;
   startVoice: string;
-  voiceFailed: string;
+  /** The call bar's words (status, mute, end). */
+  voiceControls: VoiceControlsLabels;
+  /** Why a call ended without failing; `null` for a hang-up (the person knows). */
+  voiceEnded: (reason: VoiceCloseReason) => string | null;
+  /** Said once, and shown in the bar, when the call is about to reach its time limit. */
+  voiceEndingSoon: string;
+  /** Why a call was not opened, told instead of a button that silently does nothing. */
+  voiceBlocked: (reason: VoiceBlockReason) => string;
   /** The field's accessible name. */
   composerMessage: string;
   /** The add button's accessible name. */
@@ -61,30 +76,61 @@ export interface AliaChatLabels {
   stopReading: string;
   // Plan
   planTitle: string;
-  planApprove: string;
-  planCancel: string;
-  planApproved: string;
-  planCancelled: string;
   // Reasoning
   reasoning: string;
   thoughtFor: (seconds: number) => string;
-  // The turn's work log
-  /** The words of the tool log, keyed as the Alia app keys them (see `work-log-copy.ts`). */
-  workLog: Translate;
+  // The words that are not one fixed field
+  /** The words that are not one fixed field (the thread, its cards, the work log), keyed as the Alia app keys them (see `copy.ts`). */
+  t: Translate;
+  /** The language `t` speaks, as a BCP 47 tag: dates, days and prices in the thread are formatted in it. */
+  locale: string;
+  // Conversations (the runtime's own words: toasts and the errors it raises)
+  /** A conversation's title until it has one. */
+  newChat: string;
+  /** A turn could not be sent and the composer got its text back. */
+  sendFailed: string;
+  /** The session ended mid-request. */
+  signInRequired: string;
+  conversationSaveFailed: string;
+  conversationDeleteFailed: string;
+  conversationCreateFailed: string;
+  conversationClearFailed: string;
+  /** An attachment of a kind the chat API does not carry was left out of the turn. */
+  attachmentNotSent: (name: string) => string;
+  /** A photo whose bytes could not be read was left out of the turn. */
+  attachmentUnreadable: (name: string) => string;
   // Research
 }
 
+const ENDED_ENGLISH: Partial<Record<VoiceCloseReason, string>> = {
+  'call-moved-elsewhere': 'The call continues on your other device',
+  'max-duration': 'The call reached its time limit',
+  'idle-timeout': 'The call ended after two minutes of silence',
+  'credits-exhausted': 'The call ended: you ran out of credits',
+  'server-shutdown': 'The call ended while Alia was updating — start a new one',
+};
+
+const BLOCKED_ENGLISH: Record<VoiceBlockReason, string> = {
+  'sign-in': 'Sign in to use voice',
+  'plan-required': 'Voice mode needs a paid plan',
+  'credits-exhausted': "You've run out of credits",
+};
+
 export const DEFAULT_LABELS: AliaChatLabels = {
   clear: 'Clear',
   back: 'Back',
   share: 'Share',
   more: 'More',
   chatActions: 'Chat actions',
-  placeholder: 'Ask Alia...',
+  placeholder: (leadName) => `Ask ${leadName}...`,
   addMenuGroup: 'Add',
   addPhotos: 'Photos',
+  addDocuments: 'Files',
   startVoice: 'Start voice',
-  voiceFailed: "Couldn't start the voice call",
+  voiceControls: VOICE_CONTROLS_LABELS,
+  voiceEnded: (reason) => ENDED_ENGLISH[reason] ?? null,
+  voiceEndingSoon: 'One minute left in this call',
+  voiceBlocked: (reason) => BLOCKED_ENGLISH[reason],
   composerMessage: 'Message',
   composerAddMenu: 'Add to chat',
   composerModes: 'Power level',
@@ -114,13 +160,19 @@ export const DEFAULT_LABELS: AliaChatLabels = {
   readAloud: 'Read aloud',
   stopReading: 'Stop reading',
   planTitle: "Here's my plan",
-  planApprove: 'Approve',
-  planCancel: 'Cancel',
-  planApproved: 'Plan approved',
-  planCancelled: 'Plan cancelled',
   reasoning: 'Reasoning',
   thoughtFor: (seconds) => `Thought for ${seconds} seconds`,
-  workLog: englishWorkLog,
+  t: englishCopy,
+  locale: 'en',
+  newChat: 'New chat',
+  sendFailed: "Your message couldn't be sent",
+  signInRequired: 'Sign in to keep chatting',
+  conversationSaveFailed: 'Failed to save conversation',
+  conversationDeleteFailed: 'Failed to delete conversation',
+  conversationCreateFailed: 'Failed to create conversation',
+  conversationClearFailed: "The conversation couldn't be cleared",
+  attachmentNotSent: (name) => `${name} wasn't sent — only photos can be sent`,
+  attachmentUnreadable: (name) => `${name} couldn't be read and wasn't sent`,
 };
 
 const LabelsContext = createContext<AliaChatLabels>(DEFAULT_LABELS);

package/src/lib/origins.ts

@@ -0,0 +1,15 @@
+/**
+ * The two origins the SDK talks to, defined once. Every URL it builds starts from one of them,
+ * and `@alia.onl/sdk/csp` (`src/csp.ts`) derives the host's CSP from these same values, so an
+ * origin the SDK uses is an origin it declares.
+ */
+
+/** Alia's API: `EXPO_PUBLIC_ALIA_API_URL`, then production. Chat, dictation, speech, voice. */
+export const ALIA_API_URL = process.env.EXPO_PUBLIC_ALIA_API_URL ?? 'https://api.alia.onl';
+
+/**
+ * Alia's web app, which serves the files the SDK shares with every host: Bloom's character
+ * runtime (`/bloom-character/`) and the voice call's worklets (`/sdk/voice-worklets/`), both
+ * with CORS open (`packages/app/worker/index.js`).
+ */
+export const ALIA_WEB_ORIGIN = 'https://alia.onl';

package/src/lib/participants.ts

@@ -0,0 +1,86 @@
+import type { AvatarCharacter } from '@oxy.so/bloom/agent-avatar';
+import type { AliaAgentProfile } from '../runtime/agents';
+import type { Message } from '../runtime/types';
+import { readAgentCharacter } from './agent-character';
+import { ALIA_AVATAR } from './alia-character';
+
+/** Somebody in the conversation who answers: its lead, or an agent the lead consulted. */
+export interface AliaParticipant {
+  id: string;
+  name: string;
+  handle?: string;
+  /** The 3D character it is drawn as. */
+  character: AvatarCharacter;
+  color?: string;
+}
+
+/** The conversation's lead: who greets, whose name is on the composer, who the header shows first. */
+export interface AliaLead extends AliaParticipant {
+  /** Alia herself, rather than an agent the chat was opened on. */
+  isAlia: boolean;
+  /** The agent's own greeting; Alia greets with the chat's labels. */
+  greeting?: string;
+  /** The agent's own starters, offered over the composer of an empty chat. */
+  starters: Array<{ title: string; prompt: string }>;
+}
+
+/** Who is in the conversation, as the header draws it: the lead, then whoever has joined. */
+export interface AliaChatParticipants {
+  lead: AliaLead;
+  /** The consulted agents that have joined the header, in the order they joined. */
+  joined: AliaParticipant[];
+}
+
+/** Alia as a lead. */
+export const ALIA_LEAD: AliaLead = {
+  id: 'alia',
+  name: 'Alia',
+  handle: 'alia',
+  character: ALIA_AVATAR,
+  isAlia: true,
+  starters: [],
+};
+
+/** The lead of a chat: the agent it was opened on (`agent={{ id }}`), or Alia. */
+export function leadOf(profile: AliaAgentProfile | null | undefined): AliaLead {
+  if (!profile) return ALIA_LEAD;
+  return {
+    id: profile.id,
+    name: profile.name,
+    handle: profile.handle,
+    character: readAgentCharacter(profile.character),
+    color: profile.color,
+    isAlia: false,
+    greeting: profile.greeting,
+    starters: profile.starters,
+  };
+}
+
+/** A consulted agent as a message carries it (`agentInfo`). */
+export function participantOf(agentInfo: NonNullable<Message['agentInfo']>): AliaParticipant {
+  return {
+    id: agentInfo.id,
+    name: agentInfo.name,
+    handle: agentInfo.handle,
+    character: readAgentCharacter(agentInfo.character),
+    color: agentInfo.color,
+  };
+}
+
+/**
+ * The agents that answered in `messages`, besides the lead, in the order they first did — each
+ * with whether its first answer is the one being streamed now (it is joining) or one already
+ * written (it was there when the chat opened).
+ */
+export function consultedAgents(
+  messages: readonly Message[],
+  leadId: string,
+): Array<{ participant: AliaParticipant; live: boolean }> {
+  const seen = new Map<string, { participant: AliaParticipant; live: boolean }>();
+  for (const message of messages) {
+    const info = message.agentInfo;
+    if (!info || info.id === leadId || seen.has(info.id)) continue;
+    seen.set(info.id, { participant: participantOf(info), live: message.isStreaming === true });
+  }
+  return [...seen.values()];
+}

package/src/lib/power-level-options.ts

@@ -0,0 +1,66 @@
+import type { ComposerPanelPermissionOption } from '@oxy.so/bloom/composer-panel';
+import { RiComputerLine } from '@oxy.so/bloom/icons/RiComputerLine';
+import { RiFireLine } from '@oxy.so/bloom/icons/RiFireLine';
+import { RiFlashlightLine } from '@oxy.so/bloom/icons/RiFlashlightLine';
+import { RiLightbulbLine } from '@oxy.so/bloom/icons/RiLightbulbLine';
+import { RiRocket2Line } from '@oxy.so/bloom/icons/RiRocket2Line';
+import { RiSparkling2Line } from '@oxy.so/bloom/icons/RiSparkling2Line';
+import { RiSpeedUpLine } from '@oxy.so/bloom/icons/RiSpeedUpLine';
+import { RiVipCrownLine } from '@oxy.so/bloom/icons/RiVipCrownLine';
+import { POWER_LEVELS, type PowerLevel } from '../runtime/power-levels';
+import type { Translate } from './copy';
+
+/**
+ * The power-level selector, in the shape Bloom's composer mode selector takes.
+ *
+ * Alia's users choose how much power a turn gets, never which hosted model answers it: Oxy picks
+ * the model of the chosen level for every request. The selector is `ComposerPill`'s mode picker —
+ * Bloom's own radio menu of a label, a short description and an icon per mode — so the seven
+ * levels read the same way every Bloom mode selector does. Models running on the person's OWN
+ * devices follow the levels: that is their machine, not a model Alia offers, and which devices
+ * are connected is the host's to say.
+ */
+
+type IconComponent = ComposerPanelPermissionOption['icon'];
+
+/** One glyph per level, rising with the power it stands for. */
+export const POWER_LEVEL_ICONS: Record<PowerLevel, IconComponent> = {
+  auto: RiSparkling2Line,
+  instant: RiFlashlightLine,
+  medium: RiSpeedUpLine,
+  high: RiLightbulbLine,
+  xhigh: RiFireLine,
+  pro: RiRocket2Line,
+  ultra: RiVipCrownLine,
+};
+
+/** A model running on one of the person's own devices, offered after the levels. */
+export interface DeviceModel {
+  /** What a request carries as `model` (`local/<runtime>/<model>`). */
+  id: string;
+  /** The tag the person knows it by, e.g. `llama3.1:8b`. */
+  name: string;
+  /** Which of their devices is running it. */
+  deviceLabel: string;
+}
+
+/** The selector's options: the seven levels, then the person's device models. */
+export function buildPowerLevelOptions(
+  t: Translate,
+  deviceModels: readonly DeviceModel[],
+): ComposerPanelPermissionOption[] {
+  return [
+    ...POWER_LEVELS.map((level) => ({
+      id: level,
+      label: t(`powerLevels.${level}.label`),
+      description: t(`powerLevels.${level}.description`),
+      icon: POWER_LEVEL_ICONS[level],
+    })),
+    ...deviceModels.map((model) => ({
+      id: model.id,
+      label: model.name,
+      description: t('powerLevels.onDevice', { device: model.deviceLabel }),
+      icon: RiComputerLine,
+    })),
+  ];
+}

package/src/lib/questions.ts

@@ -4,7 +4,7 @@
 // call: it is stored with the message, survives a reload, and is answered by the person's
 // next message. Pure functions, no React Native, so a host's models and tests can use them.
 
-import type { ChatMessage, ToolInvocation } from '../types';
+import type { Message, ToolInvocation } from '../runtime/types';
 
 /** The tool's name on the wire. */
 export const ASK_USER_QUESTION_TOOL = 'askUserQuestion';
@@ -83,7 +83,7 @@ export function formatAnswers(questions: AskedQuestion[], answers: QuestionAnswe
  * is the answer, so nothing is pending then.
  */
 export function pendingQuestions(
-  messages: readonly Pick<ChatMessage, 'role' | 'toolInvocations'>[],
+  messages: readonly Pick<Message, 'role' | 'toolInvocations'>[],
   isStreaming: boolean,
 ): AskedQuestion[] {
   const last = messages.at(-1);

package/src/lib/task-labels.ts

@@ -1,13 +1,13 @@
-import { englishWorkLog, type Translate } from './work-log-copy';
+import { englishCopy, type Translate } from './copy';
 
 /** Whether the catalogue names this tool itself; otherwise the label is made from its id. */
 function isNamed(kind: 'pill' | 'done', toolName: string): boolean {
   const key = `tasks.tool.${kind}.${toolName}`;
-  return englishWorkLog(key) !== key;
+  return englishCopy(key) !== key;
 }
 
 /** A tool's short label, in the reader's language when a translator is given. */
-export function getToolPillLabel(toolName: string, t: Translate = englishWorkLog): string {
+export function getToolPillLabel(toolName: string, t: Translate = englishCopy): string {
   if (isNamed('pill', toolName)) return t(`tasks.tool.pill.${toolName}`);
 
   // Oxy service tools: oxy_serviceName__toolName → "ServiceName"
@@ -28,7 +28,7 @@ export function getToolPillLabel(toolName: string, t: Translate = englishWorkLog
  * `runningTitle` for this once the task's steps land). Labels that are already names
  * ("Telegram", "Email") read the same either way, so they fall back to the running label.
  */
-export function getToolDoneLabel(toolName: string, t: Translate = englishWorkLog): string {
+export function getToolDoneLabel(toolName: string, t: Translate = englishCopy): string {
   return isNamed('done', toolName)
     ? t(`tasks.tool.done.${toolName}`)
     : getToolPillLabel(toolName, t);

package/src/lib/tool-call-status.ts

@@ -1,4 +1,4 @@
-import type { ToolInvocation } from '../types';
+import type { ToolInvocation } from '../runtime/types';
 
 /**
  * Where a tool call stands:

package/src/lib/tool-icons.ts

@@ -0,0 +1,36 @@
+import type { BloomIconComponent } from '@oxy.so/bloom/icons';
+import { RiCalendarLine } from '@oxy.so/bloom/icons/RiCalendarLine';
+import { RiChat3Line } from '@oxy.so/bloom/icons/RiChat3Line';
+import { RiDatabase2Line } from '@oxy.so/bloom/icons/RiDatabase2Line';
+import { RiFileTextLine } from '@oxy.so/bloom/icons/RiFileTextLine';
+import { RiGlobalLine } from '@oxy.so/bloom/icons/RiGlobalLine';
+import { RiLightbulbFlashLine } from '@oxy.so/bloom/icons/RiLightbulbFlashLine';
+import { RiLink } from '@oxy.so/bloom/icons/RiLink';
+import { RiSearchLine } from '@oxy.so/bloom/icons/RiSearchLine';
+import { RiSendPlaneLine } from '@oxy.so/bloom/icons/RiSendPlaneLine';
+import { RiSettings3Line } from '@oxy.so/bloom/icons/RiSettings3Line';
+import { RiUserLine } from '@oxy.so/bloom/icons/RiUserLine';
+
+/** The glyph a tool's step carries in the thought panel, by tool name. */
+const TOOL_ICONS: ReadonlyMap<string, BloomIconComponent> = new Map([
+  ['webSearch', RiSearchLine],
+  ['scrapeURL', RiLink],
+  ['getTimeline', RiCalendarLine],
+  ['searchKnowledgeBase', RiDatabase2Line],
+  ['webScraper', RiGlobalLine],
+  ['browse', RiGlobalLine],
+  ['sendWhatsAppMessage', RiChat3Line],
+  ['getWhatsAppChats', RiChat3Line],
+  ['getWhatsAppMessages', RiChat3Line],
+  ['sendTelegramMessage', RiSendPlaneLine],
+  ['getCurrentDate', RiCalendarLine],
+  ['generateFile', RiFileTextLine],
+  ['saveUserMemory', RiLightbulbFlashLine],
+  ['updateUserPreferences', RiSettings3Line],
+  ['updateUserContext', RiUserLine],
+]);
+
+/** A tool's glyph; a tool with none of its own reads as the web it reached. */
+export function getToolIcon(toolName: string): BloomIconComponent {
+  return TOOL_ICONS.get(toolName) ?? RiGlobalLine;
+}

package/src/lib/tool-renderers.tsx

@@ -0,0 +1,48 @@
+import { createContext, type ReactNode, useContext } from 'react';
+
+/**
+ * A tool's result as a host's renderer receives it (`docs/agent-embedding.md` §3): the app and the
+ * tool its canonical name names, what it was called with and what it returned.
+ */
+export interface AliaToolResult {
+  /** The app of `oxy_<app>__<tool>` / `self_<app>__<tool>`. */
+  app: string;
+  tool: string;
+  toolCallId: string;
+  input?: Record<string, unknown>;
+  output: unknown;
+  /** The consulted agent that called it; absent for the lead's own calls. */
+  agentId?: string;
+}
+
+/**
+ * The host's own drawings of catalogue tools' results, keyed `<app>:<tool>` — `homiio:searchListings`
+ * for `oxy_homiio__searchListings`. Drawn before the generic tool card, for the lead's calls and a
+ * consulted agent's alike.
+ */
+export type AliaToolRenderers = Readonly<Record<string, (result: AliaToolResult) => ReactNode>>;
+
+/**
+ * `oxy_<app>__<tool>` or `self_<app>__<tool>`: the only names a renderer is keyed from. The app
+ * part is an Oxy app slug; the tool part is whatever follows the separator.
+ */
+const CANONICAL_TOOL = /^(?:oxy|self)_([a-z][a-z0-9-]{0,63})__([A-Za-z0-9_-]+)$/;
+
+/** The app and tool of a canonical catalogue tool name, or `null` for any other name. */
+export function parseCatalogueTool(toolName: string): { app: string; tool: string } | null {
+  const match = CANONICAL_TOOL.exec(toolName);
+  return match ? { app: match[1], tool: match[2] } : null;
+}
+
+/** The renderer key of a tool name (`<app>:<tool>`), or `null` when it is not a catalogue tool. */
+export function toolRendererKey(toolName: string): string | null {
+  const parsed = parseCatalogueTool(toolName);
+  return parsed ? `${parsed.app}:${parsed.tool}` : null;
+}
+
+const RenderersContext = createContext<AliaToolRenderers>({});
+
+export const AliaToolRenderersProvider = RenderersContext.Provider;
+
+/** The host's renderers, `{}` when it brought none. */
+export const useToolRenderers = () => useContext(RenderersContext);

package/src/lib/turn-state.ts

@@ -1,9 +1,9 @@
-import type { ChatMessage } from '../types';
+import type { Message } from '../runtime/types';
 import type { AliaAvatarState } from '../components/AliaAvatar';
 
 /** What a chat turn is doing, from its messages: the one reading the header mark and every button share. */
 export function turnActivityState(
-  messages: ReadonlyArray<ChatMessage>,
+  messages: ReadonlyArray<Message>,
   isStreaming: boolean,
 ): AliaAvatarState {
   if (!isStreaming) return 'idle';

package/src/lib/voice-audio-engine.ts

@@ -11,12 +11,14 @@
  * playback through a local `RTCPeerConnection` loopback) is not built until the
  * measurement says it is needed.
  *
- * The worklets are inline source turned into a Blob URL: the SDK ships raw
- * source and a host bundler would not emit a separate worklet file.
+ * The worklets are one module served by Alia's web app (`./voice-worklets.ts`),
+ * never a `blob:` URL a host's CSP would have to allow as script. Their numbers
+ * (stream rate, frame size, prebuffer) are passed as `processorOptions`.
  */
 
 import { levelOfPcm16, pcm16ToFloat } from './pcm';
 import { VOICE_FRAME_SAMPLES, VOICE_SAMPLE_RATE } from './voice-protocol';
+import { VOICE_WORKLETS_URL } from './voice-worklets';
 import {
   VoiceAudioEngineError,
   type VoiceAudioEngine,
@@ -30,155 +32,6 @@ const PREBUFFER_MS = 80;
 /** A burst shorter than the prebuffer still plays once nothing more arrives for this long. */
 const PREBUFFER_IDLE_MS = 100;
 
-const CAPTURE_PROCESSOR = `
-class AliaVoiceCapture extends AudioWorkletProcessor {
-  constructor() {
-    super();
-    this.ratio = sampleRate / ${VOICE_SAMPLE_RATE};
-    this.t = 0;
-    this.prev = 0;
-    this.frame = new Int16Array(${VOICE_FRAME_SAMPLES});
-    this.filled = 0;
-  }
-  process(inputs) {
-    const input = inputs[0] && inputs[0][0];
-    if (!input || input.length === 0) return true;
-    const n = input.length;
-    while (this.t < n - 1) {
-      const i = Math.floor(this.t);
-      const f = this.t - i;
-      const a = i < 0 ? this.prev : input[i];
-      const b = input[i + 1];
-      let s = a + (b - a) * f;
-      s = s < -1 ? -1 : s > 1 ? 1 : s;
-      this.frame[this.filled++] = s < 0 ? s * 0x8000 : s * 0x7fff;
-      if (this.filled === this.frame.length) {
-        const out = this.frame;
-        this.port.postMessage(out.buffer, [out.buffer]);
-        this.frame = new Int16Array(${VOICE_FRAME_SAMPLES});
-        this.filled = 0;
-      }
-      this.t += this.ratio;
-    }
-    this.t -= n;
-    this.prev = input[n - 1];
-    return true;
-  }
-}
-registerProcessor('alia-voice-capture', AliaVoiceCapture);
-`;
-
-const PLAYBACK_PROCESSOR = `
-class AliaVoicePlayback extends AudioWorkletProcessor {
-  constructor() {
-    super();
-    this.step = ${VOICE_SAMPLE_RATE} / sampleRate;
-    this.queue = [];
-    this.queued = 0;
-    this.pos = 0;
-    this.buffering = true;
-    this.lastChunkAt = 0;
-    this.item = null;
-    this.played = 0;
-    this.sinceReport = 0;
-    this.sumSquares = 0;
-    this.count = 0;
-    this.port.onmessage = (event) => {
-      const message = event.data;
-      if (message.type === 'chunk') {
-        this.queue.push({ itemId: message.itemId, samples: message.samples });
-        this.queued += message.samples.length;
-        this.lastChunkAt = currentTime;
-      } else if (message.type === 'flush') {
-        const playedMs = this.item === null ? null : (this.played / ${VOICE_SAMPLE_RATE}) * 1000;
-        this.port.postMessage({ type: 'flushed', itemId: this.item, playedMs });
-        this.queue = [];
-        this.queued = 0;
-        this.pos = 0;
-        this.buffering = true;
-        this.item = null;
-        this.played = 0;
-      }
-    };
-  }
-  report(force) {
-    if (!force && this.sinceReport < sampleRate / 20) return;
-    const rms = this.count === 0 ? 0 : Math.sqrt(this.sumSquares / this.count);
-    this.port.postMessage({
-      type: 'progress',
-      itemId: this.item,
-      playedMs: (this.played / ${VOICE_SAMPLE_RATE}) * 1000,
-      rms,
-    });
-    this.sinceReport = 0;
-    this.sumSquares = 0;
-    this.count = 0;
-  }
-  process(_inputs, outputs) {
-    const out = outputs[0][0];
-    if (this.buffering) {
-      const ready =
-        this.queued >= ${(VOICE_SAMPLE_RATE * PREBUFFER_MS) / 1000} ||
-        (this.queued > 0 && currentTime - this.lastChunkAt > ${PREBUFFER_IDLE_MS / 1000});
-      if (!ready) {
-        out.fill(0);
-        for (let c = 1; c < outputs[0].length; c++) outputs[0][c].fill(0);
-        return true;
-      }
-      this.buffering = false;
-    }
-    for (let k = 0; k < out.length; k++) {
-      const head = this.queue[0];
-      if (!head) {
-        out[k] = 0;
-        if (!this.buffering) {
-          this.buffering = true;
-          this.report(true);
-          this.port.postMessage({ type: 'idle' });
-        }
-        continue;
-      }
-      if (head.itemId !== this.item) {
-        this.item = head.itemId;
-        this.played = 0;
-        this.port.postMessage({ type: 'started', itemId: head.itemId });
-      }
-      const i = Math.floor(this.pos);
-      const f = this.pos - i;
-      const a = head.samples[i];
-      const b = i + 1 < head.samples.length ? head.samples[i + 1] : a;
-      const s = a + (b - a) * f;
-      out[k] = s;
-      this.sumSquares += s * s;
-      this.count++;
-      this.pos += this.step;
-      const consumed = Math.floor(this.pos);
-      if (consumed > 0) {
-        const taken = Math.min(consumed, head.samples.length);
-        this.played += taken;
-        this.queued -= taken;
-        if (consumed >= head.samples.length) {
-          this.queue.shift();
-          this.pos = 0;
-        } else {
-          head.samples = head.samples.subarray(consumed);
-          this.pos -= consumed;
-        }
-      }
-    }
-    for (let c = 1; c < outputs[0].length; c++) outputs[0][c].set(out);
-    this.sinceReport += out.length;
-    this.report(false);
-    return true;
-  }
-}
-registerProcessor('alia-voice-playback', AliaVoicePlayback);
-`;
-
-function moduleUrl(source: string): string {
-  return URL.createObjectURL(new Blob([source], { type: 'application/javascript' }));
-}
-
 function deviceError(caught: unknown): VoiceAudioEngineError {
   const name = (caught as { name?: unknown } | null)?.name;
   if (name === 'NotAllowedError' || name === 'SecurityError' || name === 'PermissionDeniedError')
@@ -229,16 +82,10 @@ export function createVoiceAudioEngine(): VoiceAudioEngine {
       }
 
       context = new AudioContextCtor({ latencyHint: 'interactive' });
-      const captureUrl = moduleUrl(CAPTURE_PROCESSOR);
-      const playbackUrl = moduleUrl(PLAYBACK_PROCESSOR);
       try {
-        await context.audioWorklet.addModule(captureUrl);
-        await context.audioWorklet.addModule(playbackUrl);
+        await context.audioWorklet.addModule(VOICE_WORKLETS_URL);
       } catch {
         throw new VoiceAudioEngineError('voice-unavailable');
-      } finally {
-        URL.revokeObjectURL(captureUrl);
-        URL.revokeObjectURL(playbackUrl);
       }
       await context.resume().catch(() => undefined);
 
@@ -247,6 +94,10 @@ export function createVoiceAudioEngine(): VoiceAudioEngine {
         numberOfInputs: 1,
         numberOfOutputs: 0,
         channelCount: 1,
+        processorOptions: {
+          streamSampleRate: VOICE_SAMPLE_RATE,
+          frameSamples: VOICE_FRAME_SAMPLES,
+        },
       });
       capture.port.onmessage = (event: MessageEvent<ArrayBuffer>) => {
         if (stopped) return;
@@ -260,6 +111,11 @@ export function createVoiceAudioEngine(): VoiceAudioEngine {
         numberOfInputs: 0,
         numberOfOutputs: 1,
         outputChannelCount: [context.destination.channelCount || 2],
+        processorOptions: {
+          streamSampleRate: VOICE_SAMPLE_RATE,
+          prebufferMs: PREBUFFER_MS,
+          prebufferIdleMs: PREBUFFER_IDLE_MS,
+        },
       });
       playback.port.onmessage = (event: MessageEvent) => {
         const message = event.data as