@alia.onl/sdk 15.7.0 → 19.0.0

package/src/hooks/useTimelineWindow.ts

@@ -0,0 +1,256 @@
+import {
+  type Message,
+  TAIL,
+  TOP,
+  type TimelineAnchor,
+  type TimelinePosition,
+  collapseToTail,
+  pinAnchor,
+  resolveStart,
+  revealAbove,
+  sameTimelineShape,
+  timelinePositions,
+} from '../runtime/model';
+import type { AiChatThreadHandle } from '@oxy.so/bloom/ai-chat';
+import { useCallback, useLayoutEffect, useMemo, useRef, useState, type RefObject } from 'react';
+import type { LayoutChangeEvent, NativeScrollEvent, NativeSyntheticEvent } from 'react-native';
+
+/**
+ * The list, handed back as the SAME array for as long as only what its
+ * messages say has changed (`sameTimelineShape`).
+ *
+ * The array it returns may hold an older copy of the message being streamed
+ * into, so it is for deriving structure — ids, roles, stamps, speakers — and
+ * never for drawing text.
+ */
+export function useTimelineShape<
+  T extends Pick<Message, 'id' | 'role' | 'createdAt' | 'agentInfo'>,
+>(list: readonly T[]): readonly T[] {
+  const shape = useRef(list);
+  if (!sameTimelineShape(shape.current, list)) shape.current = list;
+  return shape.current;
+}
+
+interface Options {
+  /** Every row's id, in reading order. Keep its identity stable across tokens. */
+  ids: readonly string[];
+  /**
+   * What a saved position belongs to — the conversation — or `null` for a view
+   * that is not remembered (a cursor jump's window of the past).
+   */
+  scrollKey: string | null;
+  /** The conversation's messages have loaded; a restore waits for it. */
+  ready: boolean;
+  /** Index of a cursor jump's target row, or -1. It is always mounted. */
+  focusIndex: number;
+  /** A turn is streaming; the window is never folded under it. */
+  turnInFlight: boolean;
+  atBottomThreshold: number;
+  threadRef: RefObject<AiChatThreadHandle | null>;
+  /** Ask for the page of history above the first loaded row. */
+  onLoadHistory?: () => void;
+  onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+}
+
+/**
+ * What is still to be done to the scroll once the rows it needs are laid out.
+ * A restore remembers the list it was set against: that list may still be the
+ * previous conversation's, and only a list that changed after it can say the
+ * saved row is really gone.
+ */
+type PendingScroll =
+  | { kind: 'end' }
+  | { kind: 'offset'; position: TimelinePosition; setAgainst: readonly string[] };
+
+/**
+ * A restore is waiting for its conversation's rows: the row it was saved
+ * against is not on screen, and the list has not changed since it was set. A
+ * list that did change without bringing that row back means the row is gone
+ * (edited away, regenerated), and the restore falls back to the newest turn.
+ */
+function awaitingRows(pending: { current: PendingScroll | null }, ids: readonly string[]): boolean {
+  const todo = pending.current;
+  if (todo?.kind !== 'offset' || ids.includes(todo.position.probeId)) return false;
+  if (ids === todo.setAgainst) return true;
+  pending.current = { kind: 'end' };
+  return false;
+}
+
+/** The state before the first key: nothing mounted yet, so nothing to remember. */
+const MOUNTING = Symbol('mounting');
+
+const nextFrame = (run: () => void): void => {
+  if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run);
+  else setTimeout(run, 0);
+};
+
+/**
+ * Which rows the thread mounts, and the scroll that goes with them: the window
+ * over a long history, and the position a conversation is returned to.
+ *
+ * ## The window
+ *
+ * The newest `INITIAL_ROWS` rows mount first. Near the top, Bloom's
+ * `onStartReached` reveals `PAGE_ROWS` more — or, with none left, asks for the
+ * thread's history — and `maintainStartPosition` holds the reader on the row
+ * they were reading while either lands above. The window folds back to its
+ * opening size only when the reader is at the bottom and nothing is streaming.
+ * See `runtime/thread/timeline.ts` for why it is this and not virtualization.
+ *
+ * ## The position
+ *
+ * Leaving a conversation — by navigating away or by switching the screen to
+ * another — saves the offset, whether the reader was at the bottom, and the
+ * window's anchor. Coming back restores the anchor first, so the same rows are
+ * mounted above the reader, and the offset once they have laid out. Coming
+ * back from a cursor jump does not restore: "back to latest" means the latest.
+ */
+export function useTimelineWindow({
+  ids,
+  scrollKey,
+  ready,
+  focusIndex,
+  turnInFlight,
+  atBottomThreshold,
+  threadRef,
+  onLoadHistory,
+  onScroll,
+}: Options) {
+  const [state, setState] = useState<{ key: string | null; anchor: TimelineAnchor }>({
+    key: scrollKey,
+    anchor: TAIL,
+  });
+  // The render after a key change and before its effect: the new conversation
+  // starts from the newest rows until the effect says otherwise.
+  const anchor = state.key === scrollKey ? state.anchor : TAIL;
+  const start = useMemo(() => resolveStart(anchor, ids, focusIndex), [anchor, ids, focusIndex]);
+
+  const setAnchor = useCallback(
+    (next: TimelineAnchor) => setState((current) => ({ key: current.key, anchor: next })),
+    [],
+  );
+
+  /** This render's facts, for callbacks and cleanups that outlive it. */
+  const latest = useRef({ ids, start, anchor, ready, turnInFlight, onLoadHistory });
+  useLayoutEffect(() => {
+    latest.current = { ids, start, anchor, ready, turnInFlight, onLoadHistory };
+  });
+
+  /** The last position the thread reported for the current key. */
+  const lastOffset = useRef<number | null>(null);
+  const atBottom = useRef(true);
+  const pending = useRef<PendingScroll | null>(null);
+  const previousKey = useRef<string | null | typeof MOUNTING>(MOUNTING);
+
+  useLayoutEffect(() => {
+    const cameFrom = previousKey.current;
+    previousKey.current = scrollKey;
+    lastOffset.current = null;
+    atBottom.current = true;
+    // Returning from a jump is a request for the present, not for the past.
+    // A reader who left from the bottom comes back to the newest page, which
+    // is where they were; only a position mid-thread brings its rows back.
+    const read =
+      scrollKey !== null && cameFrom !== null ? timelinePositions.read(scrollKey) : undefined;
+    const saved = read?.atBottom === false ? read : undefined;
+    pending.current =
+      scrollKey === null
+        ? null
+        : saved === undefined
+          ? { kind: 'end' }
+          : { kind: 'offset', position: saved, setAgainst: ids };
+    setState({ key: scrollKey, anchor: saved?.anchor ?? TAIL });
+
+    return () => {
+      if (scrollKey === null) return;
+      const { ids: rows, start: first, anchor: kept } = latest.current;
+      if (rows.length === 0) return;
+      timelinePositions.save(scrollKey, {
+        anchor: kept,
+        offset: lastOffset.current ?? 0,
+        atBottom: atBottom.current,
+        probeId: rows[first],
+      });
+    };
+  }, [scrollKey]);
+
+  /**
+   * Pin the opening window to its first row once the rows exist, so a turn
+   * appended at the bottom grows the window rather than sliding it — a slide
+   * would unmount the top row under a reader who is mid-thread. Re-pinned the
+   * same way when the pinned row has gone (the list was replaced) — except
+   * while a restore waits for its conversation's rows: the rows on screen are
+   * still the last conversation's, and the anchor being restored is not in
+   * them yet.
+   */
+  useLayoutEffect(() => {
+    if (ids.length === 0 || awaitingRows(pending, ids)) return;
+    const stale = anchor.kind === 'tail' || (anchor.kind === 'row' && !ids.includes(anchor.id));
+    if (!stale) return;
+    setState((current) =>
+      current.key === scrollKey && current.anchor === anchor
+        ? { key: current.key, anchor: pinAnchor(ids, start) }
+        : current,
+    );
+  }, [ids, anchor, start, scrollKey]);
+
+  const handleStartReached = useCallback(() => {
+    const { ids: rows, start: first, onLoadHistory: loadHistory } = latest.current;
+    const next = revealAbove(rows, first);
+    if (next !== null) {
+      setAnchor(next);
+      return;
+    }
+    setAnchor(TOP);
+    loadHistory?.();
+  }, [setAnchor]);
+
+  const handleScroll = useCallback(
+    (event: NativeSyntheticEvent<NativeScrollEvent>) => {
+      const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent;
+      lastOffset.current = contentOffset.y;
+      const wasAtBottom = atBottom.current;
+      atBottom.current =
+        contentSize.height - contentOffset.y - layoutMeasurement.height <= atBottomThreshold;
+      if (atBottom.current && !wasAtBottom && !latest.current.turnInFlight) {
+        const { ids: rows, start: first } = latest.current;
+        const folded = collapseToTail(rows, first);
+        if (folded !== null) {
+          pending.current = { kind: 'end' };
+          setAnchor(folded);
+        }
+      }
+      onScroll?.(event);
+    },
+    [atBottomThreshold, onScroll, setAnchor],
+  );
+
+  /**
+   * The rows have laid out: carry out whatever scroll was waiting for them.
+   * A frame later, so it lands after the thread's own reaction to the same
+   * layout (on web it follows to the end on its first one).
+   */
+  const handleListLayout = useCallback(
+    (_event: LayoutChangeEvent) => {
+      const { ids: rows, ready: loaded } = latest.current;
+      if (pending.current === null || !loaded || rows.length === 0) return;
+      if (awaitingRows(pending, rows)) return;
+      const todo = pending.current;
+      pending.current = null;
+      nextFrame(() => {
+        if (todo.kind === 'end') threadRef.current?.scrollToEnd({ animated: false });
+        else threadRef.current?.scrollToOffset({ offset: todo.position.offset });
+      });
+    },
+    [threadRef],
+  );
+
+  return {
+    /** Index of the first mounted row. */
+    start,
+    /** For `AiChatThread`: absent when there is nothing above to reveal or load. */
+    onStartReached: start > 0 || onLoadHistory !== undefined ? handleStartReached : undefined,
+    onScroll: handleScroll,
+    onListLayout: handleListLayout,
+  };
+}

package/src/hooks/useVoiceLauncher.ts

@@ -0,0 +1,180 @@
+/**
+ * The host side of a voice call, shared by every surface that offers one.
+ *
+ * It owns whether a call is open, the state it reports back (for the ambient
+ * wave, the sound effects and the transcript), the gate before one opens (plan,
+ * credits, sign-in: the host answers, the SDK tells the person), and the end of
+ * a call that is no longer the screen's — another screen on show, another
+ * conversation, another account. `sessionProps` is everything `VoiceSession`
+ * needs; the sheet, `AliaChatScreen` and the Alia app all spread it.
+ *
+ * Nothing here imports the call or its audio engine.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { toast } from '@oxy.so/bloom/toast';
+import { useLabels, type VoiceBlockReason } from '../lib/labels';
+import { isRequestFor, useVoiceCallRequests } from '../lib/voice-call-request';
+import type { VoiceNotice, VoiceSessionProps, VoiceSessionState } from '../types';
+
+export interface UseVoiceLauncherOptions {
+  /** Alia API base URL. */
+  apiUrl?: string;
+  /** The conversation open on this screen, which is where the call lives. */
+  conversationId?: string;
+  /**
+   * Called after the gate, when no conversation is open: creates (and shows) the one the call
+   * will live in and returns its id, or `undefined` when it could not be made (the call then
+   * does not open). Every call has a conversation, so its transcript has a home. The call opens
+   * on the screen that shows that conversation: this one, or the one the host navigates to.
+   */
+  resolveConversation?: () => Promise<string | undefined>;
+  /** Whose call it would be. A live call ends when the account, or the open conversation, changes. */
+  accountId?: string | null;
+  /** The agent the call talks to; omitted, Alia. */
+  agentId?: string;
+  /** Language spoken (BCP-47); omitted, the platform's. */
+  locale?: string;
+  /** Which of the product's two voices answers. */
+  voice?: 'male' | 'female';
+  /** Alia stored messages of the call in the conversation: refresh the thread. */
+  onMessagesSaved?: VoiceSessionProps['onMessagesSaved'];
+  /**
+   * The gate before a call opens: why it may not (no account, no plan, no credits), or `null`.
+   * The person is told (`labels.voiceBlocked`); `onVoiceBlocked` adds what only the host can do.
+   */
+  canStartVoice?: () => VoiceBlockReason | null;
+  /** The call was not opened for `reason`: sign the person in, open the plans… */
+  onVoiceBlocked?: (reason: VoiceBlockReason) => void;
+  /** Where the call's notices go; omitted, Bloom's toast. */
+  onNotice?: (notice: VoiceNotice) => void;
+  /** A call is over, however it ended: refresh credits, the thread… */
+  onCallEnded?: () => void;
+  /** Whether the screen holding the call is the one on show. A live call ends when it is not. */
+  isFocused?: boolean;
+}
+
+export interface VoiceLauncher {
+  /** A call is open (or being opened). */
+  isActive: boolean;
+  /** What the call reports back; `null` until it is under way. */
+  state: VoiceSessionState | null;
+  /** Open a call, after the gate. Does nothing while one is open or the screen is not on show. */
+  start: () => Promise<void>;
+  /** End the call. */
+  end: () => void;
+  /** Spread onto `VoiceSession` (or `AliaVoiceCall`). */
+  sessionProps: VoiceSessionProps;
+}
+
+/** Bloom's toast, by kind: the default home of a call's notices. */
+export function toastNotice({ kind, text }: VoiceNotice): void {
+  if (kind === 'error') toast.error(text);
+  else if (kind === 'warning') toast.warning(text);
+  else toast.info(text);
+}
+
+export function useVoiceLauncher(options: UseVoiceLauncherOptions = {}): VoiceLauncher {
+  const labels = useLabels();
+  const {
+    apiUrl,
+    conversationId,
+    resolveConversation,
+    accountId = null,
+    agentId,
+    locale,
+    voice,
+    onMessagesSaved,
+    canStartVoice,
+    onVoiceBlocked,
+    onNotice,
+    onCallEnded,
+    isFocused = true,
+  } = options;
+  const [isActive, setIsActive] = useState(false);
+  const [state, setState] = useState<VoiceSessionState | null>(null);
+  const latest = useRef({
+    canStartVoice,
+    onVoiceBlocked,
+    onNotice,
+    onCallEnded,
+    resolveConversation,
+    labels,
+  });
+  latest.current = {
+    canStartVoice,
+    onVoiceBlocked,
+    onNotice,
+    onCallEnded,
+    resolveConversation,
+    labels,
+  };
+
+  const notify = useCallback((notice: VoiceNotice) => {
+    (latest.current.onNotice ?? toastNotice)(notice);
+  }, []);
+
+  const end = useCallback(() => {
+    setIsActive(false);
+    setState(null);
+    latest.current.onCallEnded?.();
+  }, []);
+
+  const start = useCallback(async () => {
+    if (isActive || !isFocused) return;
+    const reason = latest.current.canStartVoice?.() ?? null;
+    if (reason !== null) {
+      notify({
+        kind: reason === 'credits-exhausted' ? 'error' : 'info',
+        text: latest.current.labels.voiceBlocked(reason),
+      });
+      latest.current.onVoiceBlocked?.(reason);
+      return;
+    }
+    // The gate first: a call that may not open must not leave an empty conversation behind.
+    const home = conversationId ?? (await latest.current.resolveConversation?.());
+    if (home === undefined) return;
+    // The call opens where its conversation is shown (see `useVoiceCallRequests`): here, at once,
+    // when it already is; wherever the host takes the new conversation, when it was just made.
+    useVoiceCallRequests.getState().ask(home, accountId);
+  }, [isActive, isFocused, conversationId, accountId, notify]);
+
+  const request = useVoiceCallRequests((store) => store.request);
+  useEffect(() => {
+    if (isActive || !isFocused || !isRequestFor(request, conversationId, accountId)) return;
+    useVoiceCallRequests.getState().clear();
+    setIsActive(true);
+  }, [request, isActive, isFocused, conversationId, accountId]);
+
+  // A call belongs to one account and one conversation, on the screen that shows it: it ends when
+  // the screen goes out of focus, the account changes, or the screen moves to another conversation.
+  const openedIn = useRef<{ conversationId: string | undefined; accountId: string | null }>(
+    undefined,
+  );
+  useEffect(() => {
+    if (!isActive) {
+      openedIn.current = undefined;
+      return;
+    }
+    openedIn.current ??= { conversationId, accountId };
+    const call = openedIn.current;
+    if (!isFocused || call.accountId !== accountId || call.conversationId !== conversationId) end();
+  }, [isActive, isFocused, accountId, conversationId, end]);
+
+  const sessionProps = useMemo<VoiceSessionProps>(
+    () => ({
+      ...(apiUrl === undefined ? {} : { apiUrl }),
+      ...(conversationId === undefined ? {} : { conversationId }),
+      ...(agentId === undefined ? {} : { agentId }),
+      ...(locale === undefined ? {} : { locale }),
+      ...(voice === undefined ? {} : { voice }),
+      ...(onMessagesSaved === undefined ? {} : { onMessagesSaved }),
+      onNotice: notify,
+      onStateChange: setState,
+      onEnd: end,
+    }),
+    [apiUrl, conversationId, agentId, locale, voice, onMessagesSaved, notify, end],
+  );
+
+  return { isActive, state, start, end, sessionProps };
+}

package/src/hooks/useVoiceRoom.ts

@@ -24,8 +24,7 @@ import type { VoiceAudioEngine } from '../lib/voice-audio-engine-types';
 import { VoiceCall, type VoiceCallSnapshot, type VoiceSocketFactory } from '../lib/voice-call';
 import { VoiceLevelChannel, type VoiceLevelSource } from '../lib/voice-levels';
 import type { ProductVoice, VoiceCloseReason } from '../lib/voice-protocol';
-
-const API_URL = process.env.EXPO_PUBLIC_ALIA_API_URL ?? 'https://api.alia.onl';
+import { ALIA_API_URL } from '../lib/origins';
 
 export interface UseVoiceRoomOptions {
   apiUrl?: string;
@@ -44,8 +43,6 @@ export interface UseVoiceRoomOptions {
   lang?: string;
   /** Alia stored messages of the call: refresh the thread. */
   onMessagesSaved?: (conversationId: string, messageIds: readonly string[]) => void;
-  /** A tool filed an action for the person's OK; its card is in the conversation. */
-  onApprovalRequested?: (toolName: string) => void;
   /** Test seams: the device's audio and the socket. */
   createAudioEngine?: () => VoiceAudioEngine;
   openSocket?: VoiceSocketFactory;
@@ -120,7 +117,7 @@ export function useVoiceRoom(options: UseVoiceRoomOptions = {}) {
     if (live !== undefined && live !== 'ended' && live !== 'error') return;
     const current = optionsRef.current;
     const call = new VoiceCall({
-      apiUrl: current.apiUrl || API_URL,
+      apiUrl: current.apiUrl || ALIA_API_URL,
       getToken,
       conversationId: current.conversationId ?? newConversationId(),
       ...(current.agentId === undefined ? {} : { agentId: current.agentId }),
@@ -134,7 +131,6 @@ export function useVoiceRoom(options: UseVoiceRoomOptions = {}) {
       },
       onMessagesSaved: (conversationId, ids) =>
         optionsRef.current.onMessagesSaved?.(conversationId, ids),
-      onApprovalRequested: (toolName) => optionsRef.current.onApprovalRequested?.(toolName),
     });
     callRef.current = call;
     await call.start();

package/src/index.ts

@@ -3,17 +3,39 @@
 // Reusable chat UI, voice, and streaming components for Oxy apps
 
 // ── Main components ──
-export type { AliaChatAgent, AliaChatState } from './components/AliaChatContent';
+export { AliaChatContent } from './components/AliaChatContent';
+export type {
+  AliaChatAgentRef,
+  AliaChatChrome,
+  AliaChatContentProps,
+  AliaChatState,
+} from './components/AliaChatContent';
+export { AliaParticipants, joinFlights, useParticipants } from './components/AliaParticipants';
+export type { AliaParticipantsProps, UseParticipantsOptions } from './components/AliaParticipants';
+export { AliaParticipantsHeader } from './components/AliaParticipantsHeader';
+export type { AliaParticipantsHeaderProps } from './components/AliaParticipantsHeader';
+export { ALIA_LEAD, leadOf } from './lib/participants';
+export type { AliaChatParticipants, AliaLead, AliaParticipant } from './lib/participants';
+export { ANCHORS, leadToProfile } from './lib/flights';
+export { parseCatalogueTool, toolRendererKey } from './lib/tool-renderers';
+export type { AliaToolRenderers, AliaToolResult } from './lib/tool-renderers';
+export { AliaAskProvider, useAskAgent } from './components/AliaAskProvider';
+export type { AliaAsk, AliaAskAgents, AliaAskProviderProps } from './components/AliaAskProvider';
+export { AliaSharedConversation } from './components/AliaSharedConversation';
+export type { AliaSharedConversationProps } from './components/AliaSharedConversation';
+export type { AliaAddMenu } from './lib/add-menu';
+export type { AliaVoiceOptions } from './hooks/useChatVoice';
 export { AliaChatSheet } from './components/AliaChatSheet';
 export type { AliaChatSheetProps, AliaChatSheetRef } from './components/AliaChatSheet';
-export type { AliaTurn } from './components/AliaChatContent';
+export type { AliaTurn } from './hooks/useChatComposer';
 export { AliaChatScreen } from './components/AliaChatScreen';
 export type { AliaChatScreenProps } from './components/AliaChatScreen';
 
 // ── Chat UI components ──
 export { ALIA_CHARACTER_RUNTIME_URL } from './lib/character-runtime';
 export { DEFAULT_LABELS } from './lib/labels';
-export type { AliaChatLabels } from './lib/labels';
+export { AliaChatLabelsProvider, useLabels } from './lib/labels';
+export type { AliaChatLabels, VoiceBlockReason } from './lib/labels';
 export { VoiceModeIcon } from './components/VoiceModeIcon';
 export { AmbientField, PARALLAX_DURATION, PARALLAX_EASE } from './components/AmbientField';
 export type { AmbientFieldProps } from './components/AmbientField';
@@ -27,6 +49,16 @@ export { IdentityMark } from './components/IdentityMark';
 export type { IdentityMarkProps, IdentityMarkState } from './components/IdentityMark';
 export { AliaMarkdown } from './components/Markdown';
 export type { AliaMarkdownProps, RenderCodeBlock } from './components/Markdown';
+export { ReplyMarkdown } from './components/ReplyMarkdown';
+export { AliaThread } from './components/thread/AliaThread';
+export type { AliaThreadProps, NewConversationOfferProps } from './components/thread/AliaThread';
+export { ThoughtPanel } from './components/thought/ThoughtPanel';
+export type { ThoughtPanelProps } from './components/thought/ThoughtPanel';
+export type { OutputActions } from './components/thought/FilesAndSources';
+export { CanvasComponent } from './components/canvas/CanvasComponent';
+export { restoreOpenerFocus } from './lib/focus-return';
+export { buildPowerLevelOptions, POWER_LEVEL_ICONS } from './lib/power-level-options';
+export type { DeviceModel } from './lib/power-level-options';
 export { AliaWelcomeMessage } from './components/AliaWelcomeMessage';
 export { PlanPreviewCard } from './components/PlanPreviewCard';
 export { AskedQuestions, QuestionCard } from './components/QuestionCard';
@@ -49,11 +81,8 @@ export {
 } from './lib/questions';
 export type { AskedOption, AskedQuestion, QuestionAnswer } from './lib/questions';
 
-// ── Chat hook ──
-export { useAliaChat } from './hooks/useAliaChat';
-export type { UseAliaChatOptions, UseAliaChatReturn } from './hooks/useAliaChat';
-export { AliaChatStreamError } from './lib/chat-stream';
-export type { AliaChatFailure } from './lib/chat-stream';
+// ── Conversation runtime: the one data layer under the sheet, the screen and the Alia app ──
+export * from './runtime';
 
 // ── Read aloud and dictation (no call, no audio engine) ──
 export { useTTS } from './hooks/useTTS';
@@ -67,36 +96,21 @@ export type { VoiceErrorCode } from './lib/speech-messages';
 export { SpeechClipError } from './lib/speech-synthesis';
 export type { SpeechClipErrorCode } from './lib/speech-synthesis';
 
-// ── Model catalogue (GET /catalogue) ──
-// Exported so a consumer building its own picker reads the real models the
-// server offers; the SDK itself ships no model identifier.
-export {
-  fetchCatalogue,
-  parseCatalogue,
-  resolveSelection,
-  resolveModelId,
-  clearCatalogueCache,
-} from './lib/catalogue';
-export type { Catalogue, CatalogueEntry, ModelSelection, ReasoningEffort } from './lib/catalogue';
-
 // ── Types ──
 export type {
-  ChatMessage,
-  ToolInvocation,
   AliaAttachment,
   AliaSuggestion,
   ResearchProgress,
   ResearchSource,
-  PendingPlan,
+  MessagePlan,
   PlanStep,
 } from './types';
 
-// ── Voice capability contract (the implementation lives in `./voice`) ──
-export type {
-  VoiceSessionComponent,
-  VoiceSessionProps,
-  VoiceSessionState,
-} from './types';
+// ── Voice: part of the conversation screen; the host brings callbacks (see `AliaVoiceOptions`) ──
+export type { VoiceNotice, VoiceSessionProps, VoiceSessionState } from './types';
+export { AliaVoiceCall } from './components/voice/AliaVoiceCall';
+export { useVoiceLauncher, toastNotice } from './hooks/useVoiceLauncher';
+export type { UseVoiceLauncherOptions, VoiceLauncher } from './hooks/useVoiceLauncher';
 
 // ── UI Primitives (NativeWind) ──
 export { cn, formatFileSize } from './lib/utils';

package/src/lib/activity-store.ts

@@ -6,7 +6,7 @@ type Sources = Readonly<Record<string, AliaAvatarState>>;
 /**
  * What Alia is doing, from every place that can know. Two sources feed it and neither owns it:
  *
- * - `local`: the turns running in THIS app, one entry per `useAliaChat` instance (the sheet);
+ * - `local`: the turns running in THIS app, one entry per `useConversationThread` instance;
  * - `remote`: runs the server reports for the person, one entry per agent session, so a button
  *   reacts to work that is not in any open chat.
  *

package/src/lib/add-menu.ts

@@ -0,0 +1,7 @@
+import type { ComposerPanelAddMenuGroup } from '@oxy.so/bloom/composer-panel';
+
+/** The rows of the composer's add menu, and what pressing one does. */
+export interface AliaAddMenu {
+  groups: readonly ComposerPanelAddMenuGroup[];
+  onSelect: (rowId: string) => void;
+}

package/src/lib/call-thread.ts

@@ -0,0 +1,33 @@
+/**
+ * What the thread shows while a call is open: the text messages it held when
+ * the call started, then the call's messages.
+ *
+ * A call message the server has stored is shown AS STORED — the copy a reload
+ * or a resume shows, with its tools' arguments and results, which the call's
+ * socket never carries. Same id either way (the call names every message by the
+ * id it is stored under), so swapping one for the other never adds a message.
+ */
+
+import type { Message } from '../runtime/types';
+import type { VoiceMessage } from '../types';
+
+export function callThread(
+  before: readonly Message[],
+  call: readonly VoiceMessage[],
+  stored: readonly Message[] | undefined,
+): Message[] {
+  const storedById = new Map((stored ?? []).map((message) => [message.id, message]));
+  return [...before, ...call.map((message) => storedById.get(message.id) ?? fromCall(message))];
+}
+
+function fromCall(message: VoiceMessage): Message {
+  return {
+    id: message.id,
+    role: message.role,
+    content: message.content,
+    toolInvocations: message.toolInvocations,
+    createdAt: new Date(message.timestamp).toISOString(),
+    source: 'voice' as const,
+    speaker: message.speaker,
+  };
+}

package/src/lib/character-runtime.ts

@@ -1,10 +1,12 @@
+import { ALIA_WEB_ORIGIN } from './origins';
+
 /**
  * Where the 3D character runtime (Alia's avatar) is served from when the host does not say.
  *
  * The runtime is ~214 MB of engine and data, so the chat loads it from Alia's own web origin
  * instead of asking every app to host a copy. That origin serves it with CORS open
- * (`packages/app/worker/index.js`), which a cross-origin module import needs; an app with a
- * strict CSP allows it in `script-src` and `connect-src`. A host that serves its own copy
- * passes `characterRuntimeUrl`.
+ * (`packages/app/worker/index.js`), which a cross-origin module import needs; a host with a
+ * CSP allows it with `@alia.onl/sdk/csp`. A host that serves its own copy passes
+ * `characterRuntimeUrl`.
  */
-export const ALIA_CHARACTER_RUNTIME_URL = 'https://alia.onl/bloom-character/runtime.mjs';
+export const ALIA_CHARACTER_RUNTIME_URL = `${ALIA_WEB_ORIGIN}/bloom-character/runtime.mjs`;