@alexkroman1/aai 0.3.0

package/ui/_components/error_banner.tsx

@@ -0,0 +1,18 @@
+// Copyright 2025 the AAI authors. MIT license.
+
+import type { Signal } from "@preact/signals";
+import type * as preact from "preact";
+import type { SessionError } from "../types.ts";
+
+export function ErrorBanner({
+  error,
+}: {
+  error: Signal<SessionError | null>;
+}): preact.JSX.Element | null {
+  if (!error.value) return null;
+  return (
+    <div class="mx-4 mt-3 px-3 py-2 rounded-aai border border-aai-error/40 bg-aai-error/8 text-[13px] leading-[130%] text-aai-error">
+      {error.value.message}
+    </div>
+  );
+}

package/ui/_components/message_bubble.tsx

@@ -0,0 +1,21 @@
+// Copyright 2025 the AAI authors. MIT license.
+import type * as preact from "preact";
+import type { Message } from "../types.ts";
+
+export function MessageBubble({ message }: { message: Message }): preact.JSX.Element {
+  const isUser = message.role === "user";
+  if (isUser) {
+    return (
+      <div class="flex flex-col w-full items-end">
+        <div class="max-w-[min(82%,64ch)] bg-aai-surface-faint border border-aai-border px-3 py-2 rounded-aai whitespace-pre-wrap wrap-break-word text-sm font-normal leading-[150%] text-aai-text">
+          {message.text}
+        </div>
+      </div>
+    );
+  }
+  return (
+    <div class="whitespace-pre-wrap wrap-break-word text-sm font-normal leading-[150%] text-aai-text">
+      {message.text}
+    </div>
+  );
+}

package/ui/_components/message_list.tsx

@@ -0,0 +1,61 @@
+// Copyright 2025 the AAI authors. MIT license.
+
+import { computed, useSignalEffect } from "@preact/signals";
+import type { VNode } from "preact";
+import { useRef } from "preact/hooks";
+import { useSession } from "../signals.ts";
+import { MessageBubble } from "./message_bubble.tsx";
+import { ThinkingIndicator } from "./thinking_indicator.tsx";
+import { ToolCallBlock } from "./tool_call_block.tsx";
+import { Transcript } from "./transcript.tsx";
+
+export function MessageList() {
+  const { session } = useSession();
+  const scrollRef = useRef<HTMLDivElement>(null);
+
+  const showThinking = computed(() => {
+    if (session.state.value !== "thinking") return false;
+    const last = session.toolCalls.value.at(-1);
+    if (last?.status === "pending") return false;
+    const lastMsg = session.messages.value.at(-1);
+    return !lastMsg || lastMsg.role === "user" || !!last;
+  });
+
+  useSignalEffect(() => {
+    session.messages.value;
+    session.toolCalls.value;
+    session.userUtterance.value;
+    session.state.value;
+    scrollRef.current?.scrollIntoView({ behavior: "smooth" });
+  });
+
+  const messages = session.messages.value;
+  const toolCalls = session.toolCalls.value;
+
+  // Render each message followed by its tool calls.
+  const items: VNode[] = [];
+  let tci = 0;
+  for (let i = 0; i < messages.length; i++) {
+    items.push(<MessageBubble key={`msg-${i}`} message={messages[i]!} />);
+    while (tci < toolCalls.length && toolCalls[tci]!.afterMessageIndex <= i) {
+      items.push(<ToolCallBlock key={toolCalls[tci]!.toolCallId} toolCall={toolCalls[tci]!} />);
+      tci++;
+    }
+  }
+  // Any remaining tool calls (still pending, no following message yet).
+  while (tci < toolCalls.length) {
+    items.push(<ToolCallBlock key={toolCalls[tci]!.toolCallId} toolCall={toolCalls[tci]!} />);
+    tci++;
+  }
+
+  return (
+    <div role="log" class="flex-1 overflow-y-auto [scrollbar-width:none] bg-aai-surface">
+      <div class="flex flex-col gap-4.5 p-4">
+        {items}
+        <Transcript userUtterance={session.userUtterance} />
+        {showThinking.value && <ThinkingIndicator />}
+        <div ref={scrollRef} />
+      </div>
+    </div>
+  );
+}

package/ui/_components/state_indicator.tsx

@@ -0,0 +1,17 @@
+// Copyright 2025 the AAI authors. MIT license.
+
+import type { Signal } from "@preact/signals";
+import type * as preact from "preact";
+import type { AgentState } from "../types.ts";
+
+export function StateIndicator({ state }: { state: Signal<AgentState> }): preact.JSX.Element {
+  return (
+    <div class="inline-flex items-center justify-center gap-1.5 text-[13px] font-medium leading-[130%] text-aai-text-muted capitalize">
+      <div
+        class="w-2 h-2 rounded-full"
+        style={{ background: `var(--color-aai-state-${state.value})` }}
+      />
+      {state}
+    </div>
+  );
+}

package/ui/_components/thinking_indicator.tsx

@@ -0,0 +1,19 @@
+// Copyright 2025 the AAI authors. MIT license.
+import type * as preact from "preact";
+
+export function ThinkingIndicator(): preact.JSX.Element {
+  return (
+    <div class="flex items-center gap-2 text-aai-text-dim text-sm font-medium min-h-5">
+      {[0, 0.16, 0.32].map((delay) => (
+        <div
+          key={delay}
+          class="w-1.5 h-1.5 rounded-full bg-aai-text-dim"
+          style={{
+            animation: "aai-bounce 1.4s infinite ease-in-out both",
+            animationDelay: `${delay}s`,
+          }}
+        />
+      ))}
+    </div>
+  );
+}

package/ui/_components/tool_call_block.tsx

@@ -0,0 +1,110 @@
+// Copyright 2025 the AAI authors. MIT license.
+import type * as preact from "preact";
+import { useState } from "preact/hooks";
+import type { ToolCallInfo } from "../types.ts";
+import {
+  BoltIcon,
+  ChatBubbleIcon,
+  DownloadIcon,
+  ExternalLinkIcon,
+  SearchIcon,
+  TerminalIcon,
+} from "./tool_icons.tsx";
+
+type IconComponent = (props: { class?: string }) => preact.JSX.Element;
+
+type ToolConfig = {
+  Icon: IconComponent;
+  title: string;
+  subtitle: (args: Record<string, unknown>) => string;
+};
+
+const TOOL_CONFIG: Record<string, ToolConfig> = {
+  web_search: {
+    Icon: SearchIcon,
+    title: "Web Search",
+    subtitle: (args) => String(args.query ?? ""),
+  },
+  visit_webpage: {
+    Icon: ExternalLinkIcon,
+    title: "Visit Page",
+    subtitle: (args) => String(args.url ?? ""),
+  },
+  run_code: {
+    Icon: TerminalIcon,
+    title: "Run Code",
+    subtitle: (args) => {
+      const code = String(args.code ?? "");
+      const firstLine = code.split("\n")[0] ?? "";
+      return firstLine.length > 80 ? `${firstLine.slice(0, 80)}...` : firstLine;
+    },
+  },
+  fetch_json: {
+    Icon: DownloadIcon,
+    title: "Fetch JSON",
+    subtitle: (args) => String(args.url ?? ""),
+  },
+  user_input: {
+    Icon: ChatBubbleIcon,
+    title: "Asking User",
+    subtitle: (args) => String(args.question ?? ""),
+  },
+};
+
+const DEFAULT_CONFIG: ToolConfig = {
+  Icon: BoltIcon,
+  title: "",
+  subtitle: (args) => {
+    const summary = JSON.stringify(args);
+    return summary.length > 80 ? `${summary.slice(0, 80)}...` : summary;
+  },
+};
+
+function formatResult(result: string): string {
+  try {
+    return JSON.stringify(JSON.parse(result), null, 2);
+  } catch {
+    return result;
+  }
+}
+
+export function ToolCallBlock({ toolCall }: { toolCall: ToolCallInfo }): preact.JSX.Element {
+  const [isOpen, setOpen] = useState(false);
+  const config = TOOL_CONFIG[toolCall.toolName] ?? DEFAULT_CONFIG;
+  const isPending = toolCall.status === "pending";
+  const title = config.title || toolCall.toolName;
+
+  return (
+    <div class="flex flex-col">
+      <div
+        class="flex items-center gap-2 px-3 py-2 rounded-aai border border-aai-border bg-aai-surface-faint cursor-pointer select-none"
+        onClick={() => !isPending && setOpen(!isOpen)}
+      >
+        <config.Icon class="w-4 h-4 text-aai-text-dim shrink-0" />
+        <span class={`text-sm font-medium text-aai-text ${isPending ? "tool-shimmer" : ""}`}>
+          {title}
+        </span>
+        <span class="text-sm text-aai-text-dim truncate flex-1 min-w-0">
+          {config.subtitle(toolCall.args)}
+        </span>
+        {!isPending && toolCall.result && (
+          <span class="text-xs text-aai-text-dim shrink-0">{isOpen ? "\u25BE" : "\u25B8"}</span>
+        )}
+      </div>
+      {isOpen && (
+        <div class="border-x border-b border-aai-border rounded-b-aai bg-aai-surface max-h-64 overflow-auto">
+          {toolCall.toolName === "run_code" && toolCall.args.code && (
+            <pre class="text-xs text-aai-text p-2 whitespace-pre-wrap border-b border-aai-border font-mono">
+              {String(toolCall.args.code)}
+            </pre>
+          )}
+          {toolCall.result && (
+            <pre class="text-xs text-aai-text-dim p-2 whitespace-pre-wrap">
+              {formatResult(toolCall.result)}
+            </pre>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}

package/ui/_components/tool_icons.tsx

@@ -0,0 +1,101 @@
+// Copyright 2025 the AAI authors. MIT license.
+import type * as preact from "preact";
+
+type IconProps = { class?: string };
+
+/** Magnifying glass icon for web_search. */
+export function SearchIcon(props: IconProps): preact.JSX.Element {
+  return (
+    <svg
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      class={props.class}
+    >
+      <circle cx="7" cy="7" r="4.5" />
+      <path d="M10.5 10.5L14 14" stroke-linecap="round" />
+    </svg>
+  );
+}
+
+/** External link icon for visit_webpage. */
+export function ExternalLinkIcon(props: IconProps): preact.JSX.Element {
+  return (
+    <svg
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      class={props.class}
+    >
+      <path d="M6 2H3a1 1 0 00-1 1v10a1 1 0 001 1h10a1 1 0 001-1v-3" stroke-linecap="round" />
+      <path d="M9 2h5v5" stroke-linecap="round" stroke-linejoin="round" />
+      <path d="M14 2L7 9" stroke-linecap="round" />
+    </svg>
+  );
+}
+
+/** Terminal icon for run_code. */
+export function TerminalIcon(props: IconProps): preact.JSX.Element {
+  return (
+    <svg
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      class={props.class}
+    >
+      <rect x="1" y="2" width="14" height="12" rx="1.5" />
+      <path d="M4 6l3 2.5L4 11" stroke-linecap="round" stroke-linejoin="round" />
+      <path d="M9 11h3" stroke-linecap="round" />
+    </svg>
+  );
+}
+
+/** Download icon for fetch_json. */
+export function DownloadIcon(props: IconProps): preact.JSX.Element {
+  return (
+    <svg
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      class={props.class}
+    >
+      <path d="M8 2v9" stroke-linecap="round" />
+      <path d="M4.5 8L8 11.5 11.5 8" stroke-linecap="round" stroke-linejoin="round" />
+      <path d="M2 13h12" stroke-linecap="round" />
+    </svg>
+  );
+}
+
+/** Chat bubble icon for user_input. */
+export function ChatBubbleIcon(props: IconProps): preact.JSX.Element {
+  return (
+    <svg
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      class={props.class}
+    >
+      <path d="M2 3a1 1 0 011-1h10a1 1 0 011 1v7a1 1 0 01-1 1H5l-3 3V3z" stroke-linejoin="round" />
+    </svg>
+  );
+}
+
+/** Bolt/lightning icon for default/unknown tools. */
+export function BoltIcon(props: IconProps): preact.JSX.Element {
+  return (
+    <svg
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      class={props.class}
+    >
+      <path d="M9 1L3 9h5l-1 6 6-8H8l1-6z" stroke-linejoin="round" />
+    </svg>
+  );
+}

package/ui/_components/transcript.tsx

@@ -0,0 +1,20 @@
+// Copyright 2025 the AAI authors. MIT license.
+
+import type { Signal } from "@preact/signals";
+import type * as preact from "preact";
+import { ThinkingIndicator } from "./thinking_indicator.tsx";
+
+export function Transcript({
+  userUtterance,
+}: {
+  userUtterance: Signal<string | null>;
+}): preact.JSX.Element | null {
+  if (userUtterance.value === null) return null;
+  return (
+    <div class="flex flex-col items-end w-full">
+      <div class="max-w-[min(82%,64ch)] whitespace-pre-wrap wrap-break-word text-sm leading-[150%] text-aai-text-muted bg-aai-surface-faint border border-aai-border px-3 py-2 rounded-aai ml-auto">
+        {userUtterance.value || <ThinkingIndicator />}
+      </div>
+    </div>
+  );
+}

package/ui/audio.ts

@@ -0,0 +1,170 @@
+// Copyright 2025 the AAI authors. MIT license.
+import { MIC_BUFFER_SECONDS } from "./types.ts";
+
+/** Configuration for creating a {@linkcode VoiceIO} instance. */
+export type VoiceIOOptions = {
+  /** Sample rate in Hz expected by the STT engine (e.g. 16000). */
+  sttSampleRate: number;
+  /** Sample rate in Hz used by the TTS engine (e.g. 22050). */
+  ttsSampleRate: number;
+  /** Source URL or data URI for the capture AudioWorklet processor. */
+  captureWorkletSrc: string;
+  /** Source URL or data URI for the playback AudioWorklet processor. */
+  playbackWorkletSrc: string;
+  /** Callback invoked with buffered PCM16 microphone data to send to the server. */
+  onMicData: (pcm16: ArrayBuffer) => void;
+  /** Callback invoked with the current playback position in samples. */
+  onPlaybackProgress?: (samplesPlayed: number) => void;
+};
+
+/**
+ * Audio I/O interface for voice capture and playback.
+ *
+ * Manages microphone capture via an AudioWorklet, resampling to the STT
+ * sample rate, and TTS audio playback through a second AudioWorklet. Implements
+ * {@linkcode AsyncDisposable} for resource cleanup.
+ */
+export type VoiceIO = AsyncDisposable & {
+  /** Enqueue a PCM16 audio buffer for playback through the TTS pipeline. */
+  enqueue(pcm16Buffer: ArrayBuffer): void;
+  /** Signal that all TTS audio for the current turn has been enqueued.
+   *  Resolves when the worklet has finished playing all buffered audio. */
+  done(): Promise<void>;
+  /** Immediately stop playback and discard any buffered TTS audio. */
+  flush(): void;
+  /** Release all audio resources (microphone, AudioContext, worklets). */
+  close(): Promise<void>;
+};
+
+async function loadWorklet(ctx: AudioContext, source: string): Promise<void> {
+  await ctx.audioWorklet.addModule(source);
+}
+
+/**
+ * Create a {@linkcode VoiceIO} instance that captures microphone audio and
+ * plays back TTS audio using the Web Audio API.
+ *
+ * The AudioContext runs at the TTS sample rate for playback fidelity.
+ * Captured audio is resampled to the STT rate when the rates differ.
+ *
+ * @param opts - Voice I/O configuration options.
+ * @returns A promise that resolves to a {@linkcode VoiceIO} handle.
+ * @throws If microphone access is denied or AudioWorklet registration fails.
+ */
+export async function createVoiceIO(opts: VoiceIOOptions): Promise<VoiceIO> {
+  const { sttSampleRate, ttsSampleRate, captureWorkletSrc, playbackWorkletSrc, onMicData } = opts;
+
+  // Use TTS rate for the context — playback fidelity is more perceptible.
+  // Capture path resamples to STT rate if they differ.
+  const contextRate = ttsSampleRate;
+  const ctx = new AudioContext({
+    sampleRate: contextRate,
+    latencyHint: "playback",
+  });
+  await ctx.resume();
+
+  // Single AudioContext owns both capture and playback — required for AEC.
+  const stream = await navigator.mediaDevices.getUserMedia({
+    audio: {
+      sampleRate: contextRate,
+      echoCancellation: true,
+      noiseSuppression: true,
+      autoGainControl: true,
+    },
+  });
+
+  try {
+    await Promise.all([loadWorklet(ctx, captureWorkletSrc), loadWorklet(ctx, playbackWorkletSrc)]);
+  } catch (err: unknown) {
+    for (const t of stream.getTracks()) t.stop();
+    await ctx.close().catch(() => {});
+    throw err;
+  }
+
+  const mic = ctx.createMediaStreamSource(stream);
+  const capNode = new AudioWorkletNode(ctx, "capture-processor", {
+    channelCount: 1,
+    channelCountMode: "explicit",
+    processorOptions: { contextRate, sttSampleRate },
+  });
+  mic.connect(capNode);
+
+  // Worklet outputs PCM16 at the STT rate — just batch and send.
+  const chunkSizeBytes = Math.floor(sttSampleRate * MIC_BUFFER_SECONDS) * 2;
+  const capBuf = new Uint8Array(chunkSizeBytes * 2);
+  let capOffset = 0;
+
+  capNode.port.postMessage({ event: "start" });
+
+  capNode.port.onmessage = (e: MessageEvent) => {
+    if (e.data.event !== "chunk") return;
+    const chunk = new Uint8Array(e.data.buffer as ArrayBuffer);
+
+    capBuf.set(chunk, capOffset);
+    capOffset += chunk.byteLength;
+
+    if (capOffset >= chunkSizeBytes) {
+      onMicData(capBuf.slice(0, capOffset).buffer);
+      capOffset = 0;
+    }
+  };
+
+  let playNode: AudioWorkletNode | null = null;
+  let onPlaybackStop: (() => void) | null = null;
+  const lifecycle = new AbortController();
+  const { onPlaybackProgress } = opts;
+
+  function ensurePlayNode(): AudioWorkletNode {
+    if (playNode) return playNode;
+    const node = new AudioWorkletNode(ctx, "playback-processor", {
+      processorOptions: { sampleRate: contextRate },
+    });
+    node.connect(ctx.destination);
+    node.port.onmessage = (e: MessageEvent) => {
+      if (e.data.event === "stop") {
+        node.disconnect();
+        if (playNode === node) playNode = null;
+        onPlaybackStop?.();
+        onPlaybackStop = null;
+      } else if (e.data.event === "progress") {
+        onPlaybackProgress?.(e.data.readPos);
+      }
+    };
+    playNode = node;
+    return node;
+  }
+
+  const io: VoiceIO = {
+    enqueue(pcm16Buffer: ArrayBuffer) {
+      if (lifecycle.signal.aborted) return;
+      if (pcm16Buffer.byteLength === 0) return;
+      const node = ensurePlayNode();
+      node.port.postMessage({ event: "write", buffer: new Uint8Array(pcm16Buffer) }, [pcm16Buffer]);
+    },
+
+    done() {
+      if (!playNode) return Promise.resolve();
+      return new Promise<void>((resolve) => {
+        onPlaybackStop = resolve;
+        playNode!.port.postMessage({ event: "done" });
+      });
+    },
+
+    flush() {
+      if (playNode) playNode.port.postMessage({ event: "interrupt" });
+    },
+
+    async close() {
+      if (lifecycle.signal.aborted) return;
+      lifecycle.abort();
+      capNode.port.postMessage({ event: "stop" });
+      for (const t of stream.getTracks()) t.stop();
+      await ctx.close().catch(() => {});
+    },
+
+    async [Symbol.asyncDispose]() {
+      await io.close();
+    },
+  };
+  return io;
+}

package/ui/components.ts

@@ -0,0 +1,49 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * Preact UI components for the voice agent interface.
+ *
+ * Re-exports from _components/ with explicit type annotations so JSR can
+ * generate .d.ts without needing to analyze source files.
+ */
+
+import type { Signal } from "@preact/signals";
+import type * as preact from "preact";
+import { App as _App } from "./_components/app.tsx";
+import { ChatView as _ChatView } from "./_components/chat_view.tsx";
+import { ErrorBanner as _ErrorBanner } from "./_components/error_banner.tsx";
+import { MessageBubble as _MessageBubble } from "./_components/message_bubble.tsx";
+import { StateIndicator as _StateIndicator } from "./_components/state_indicator.tsx";
+import { ThinkingIndicator as _ThinkingIndicator } from "./_components/thinking_indicator.tsx";
+import { ToolCallBlock as _ToolCallBlock } from "./_components/tool_call_block.tsx";
+import { Transcript as _Transcript } from "./_components/transcript.tsx";
+import type { AgentState, Message, SessionError, ToolCallInfo } from "./types.ts";
+
+/** Displays the current agent state as a colored indicator. */
+export const StateIndicator: (props: { state: Signal<AgentState> }) => preact.JSX.Element =
+  _StateIndicator;
+
+/** Displays an error message banner when an error is present. */
+export const ErrorBanner: (props: {
+  error: Signal<SessionError | null>;
+}) => preact.JSX.Element | null = _ErrorBanner;
+
+/** Renders a single chat message bubble. */
+export const MessageBubble: (props: { message: Message }) => preact.JSX.Element = _MessageBubble;
+
+/** Renders a collapsible tool call block. */
+export const ToolCallBlock: (props: { toolCall: ToolCallInfo }) => preact.JSX.Element =
+  _ToolCallBlock;
+
+/** Displays the live user utterance from STT/VAD. */
+export const Transcript: (props: {
+  userUtterance: Signal<string | null>;
+}) => preact.JSX.Element | null = _Transcript;
+
+/** Animated indicator shown while the agent is processing. */
+export const ThinkingIndicator: () => preact.JSX.Element = _ThinkingIndicator;
+
+/** Full chat view showing messages, transcript, and thinking state. */
+export const ChatView: () => preact.JSX.Element = _ChatView;
+
+/** Default top-level app component with start screen and chat view. */
+export const App: () => preact.JSX.Element = _App;

package/ui/components_mod.ts

@@ -0,0 +1,37 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * Preact UI components for AAI voice agents.
+ *
+ * Provides ready-made components, session context, and mount helpers.
+ *
+ * @example
+ * ```tsx
+ * import { App, mount } from "@aai/ui/components";
+ *
+ * mount(App, { target: "#app" });
+ * ```
+ *
+ * @module
+ */
+
+export {
+  App,
+  ChatView,
+  ErrorBanner,
+  MessageBubble,
+  StateIndicator,
+  ThinkingIndicator,
+  ToolCallBlock,
+  Transcript,
+} from "./components.ts";
+export type { MountHandle, MountOptions, MountTheme } from "./mount.tsx";
+
+export { mount } from "./mount.tsx";
+export type { MountConfig } from "./mount_context.ts";
+export { useMountConfig } from "./mount_context.ts";
+export type { SessionSignals } from "./signals.ts";
+export {
+  createSessionControls,
+  SessionProvider,
+  useSession,
+} from "./signals.ts";

package/ui/mod.ts

@@ -0,0 +1,48 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * Browser client library for AAI voice agents.
+ *
+ * Provides WebSocket session management, audio capture/playback,
+ * and Preact UI components. For narrower imports, use the sub-path exports:
+ *
+ * - `@aai/ui/session` — WebSocket session only (no Preact dependency)
+ * - `@aai/ui/components` — Preact components, mount helpers, and signals
+ *
+ * @example
+ * ```tsx
+ * import { App, mount } from "@aai/ui";
+ *
+ * mount(App, { target: "#app" });
+ * ```
+ *
+ * @module
+ */
+
+export {
+  App,
+  ChatView,
+  createSessionControls,
+  ErrorBanner,
+  MessageBubble,
+  type MountConfig,
+  type MountHandle,
+  type MountOptions,
+  type MountTheme,
+  mount,
+  SessionProvider,
+  type SessionSignals,
+  StateIndicator,
+  ThinkingIndicator,
+  Transcript,
+  useMountConfig,
+  useSession,
+} from "./components_mod.ts";
+export {
+  type AgentState,
+  createVoiceSession,
+  type Message,
+  type SessionError,
+  type SessionErrorCode,
+  type SessionOptions,
+  type VoiceSession,
+} from "./session_mod.ts";