@alia.onl/sdk 15.7.0 → 19.0.0

package/src/lib/citations.ts

@@ -1,4 +1,4 @@
-import type { ToolInvocation } from '../types';
+import type { ToolInvocation } from '../runtime/types';
 import { domainOf } from './domain';
 
 export interface CitationSource {
@@ -87,7 +87,7 @@ export function normalizeCitationMarkers(text: string, knownIds?: Iterable<numbe
 
 /**
  * The accessible name of one citation: what a screen reader says for the
- * link, and what `CustomMarkdown` puts in the link's title.
+ * link, and what `ReplyMarkdown` puts in the link's title.
  */
 export function citationLabel(source: CitationSource): string {
   return `Source ${source.id}: ${source.title}`;
@@ -113,3 +113,80 @@ export function linkifyCitations(text: string, sources: CitationSource[]): strin
     return `[${n}](${source.url} "${title}")`;
   });
 }
+
+/** One entry of a rendered references section. */
+export interface ReferenceEntry {
+  id: number;
+  title: string;
+  url: string;
+  domain: string;
+}
+
+/**
+ * Where the references section starts: the API writes `## References` after a
+ * rule; the heading is matched loosely so an older answer, or one
+ * written in Spanish by the model itself, splits the same way.
+ */
+const REFERENCES_HEADING_RE =
+  /(?:^|\n)(?:---\s*\n+)?#{1,3}\s*(?:References|Referencias|Sources|Fuentes)\s*:?\s*(?:\n|$)/i;
+
+/** `[n] [Title](url)` (new) or `[n] Title` + a URL line (legacy). */
+const REFERENCE_LINE_RE = /^\s*\[(\d{1,3})\]\s*(.*)$/;
+// The title may carry escaped brackets (`React \[Wikipedia\]`), which the
+// API writes for a title that contains them.
+const MARKDOWN_LINK_RE = /^\[((?:\\.|[^\]\\])*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)\s*$/;
+const URL_RE = /https?:\/\/[^\s)]+/;
+
+/**
+ * Split an answer into its body and the entries of its references section.
+ *
+ * `references` is `null` when the section is absent or none of its lines
+ * parse, in which case the caller renders the whole text as Markdown and
+ * nothing is lost. Known sources fill in a title or URL a legacy line lacks.
+ */
+export function splitReferences(
+  text: string,
+  sources: CitationSource[] = [],
+): { body: string; references: ReferenceEntry[] | null } {
+  const match = REFERENCES_HEADING_RE.exec(text);
+  if (!match) return { body: text, references: null };
+
+  const body = text.slice(0, match.index).replace(/\s+$/, '');
+  const section = text.slice(match.index + match[0].length);
+  const byId = new Map(sources.map((s) => [s.id, s]));
+
+  const entries: ReferenceEntry[] = [];
+  let current: { id: number; rest: string } | null = null;
+  const flush = () => {
+    if (!current) return;
+    const known = byId.get(current.id);
+    const rest = current.rest.trim();
+    const link = MARKDOWN_LINK_RE.exec(rest);
+    let url = link ? link[2] : (URL_RE.exec(rest)?.[0] ?? known?.url ?? '');
+    let title = link ? link[1] : rest.replace(URL_RE, '').replace(/\s+/g, ' ').trim();
+    if (!url && known) url = known.url;
+    if (!title) title = known?.title ?? (url ? domainOf(url, { stripWww: true }) : '');
+    if (url)
+      entries.push({
+        id: current.id,
+        title: title.replace(/\\([[\]])/g, '$1'),
+        url,
+        domain: domainOf(url, { stripWww: true }),
+      });
+    current = null;
+  };
+
+  for (const line of section.split('\n')) {
+    const m = REFERENCE_LINE_RE.exec(line);
+    if (m) {
+      flush();
+      current = { id: Number(m[1]), rest: m[2] };
+    } else if (current && line.trim().length > 0) {
+      // A legacy entry's URL sits on the indented line after the title.
+      current.rest += ` ${line.trim()}`;
+    }
+  }
+  flush();
+
+  return entries.length > 0 ? { body, references: entries } : { body: text, references: null };
+}

package/src/lib/clipboard.ts

@@ -0,0 +1,23 @@
+import { toast } from '@oxy.so/bloom/toast';
+import * as Clipboard from 'expo-clipboard';
+import type { Translate } from './copy';
+
+/**
+ * Copy `text`, and say which happened.
+ *
+ * The result is the clipboard's own: `setStringAsync` resolves `false` on web when the browser
+ * refuses (no permission, no focus, an insecure origin) and rejects on native when the module is
+ * missing. Either way the answer is `false` and an error toast, and Bloom's copy button, which
+ * confirms only on `true`, stays a copy glyph instead of announcing "Copied!" over nothing.
+ */
+export async function copyText(text: string, t: Translate): Promise<boolean> {
+  let copied: boolean;
+  try {
+    copied = (await Clipboard.setStringAsync(text)) !== false;
+  } catch {
+    copied = false;
+  }
+  if (copied) toast.success(t('chat.copiedToClipboard'));
+  else toast.error(t('chat.copyFailed'));
+  return copied;
+}

package/src/lib/content-utils.ts

@@ -1,3 +1,5 @@
+import { processMessage } from '../runtime/thread/message-processor';
+
 /** A single part of a multi-part chat message content array. */
 export interface ContentPart {
   type: string;
@@ -22,6 +24,14 @@ export function getTextFromContent(content: MessageContent | null | undefined):
   return String(content || '');
 }
 
+/**
+ * A message's words as the thread draws them: its text parts, without the tags other platforms
+ * use (Telegram's), which a reply written for one can still carry.
+ */
+export function messageText(message: { content: MessageContent | null | undefined }): string {
+  return processMessage(message.content ? getTextFromContent(message.content) : '', 'app').text;
+}
+
 /**
  * Extract image URLs from multi-part message content.
  */

package/src/lib/copy-en.ts

@@ -0,0 +1,284 @@
+/**
+ * The chat's own English, keyed the way the Alia app's catalogue keys it, so the app hands its
+ * translator in (`labels.t`) and a host without one reads English. Generated from the app's
+ * `locales/en.json` and kept by hand from here: a key a component asks for belongs here.
+ */
+export type CopyEntry = string | { zero?: string; one?: string; other: string };
+
+export const COPY_EN: Readonly<Record<string, CopyEntry>> = {
+  'automations.cron.dailyAt': 'Daily at {{time}}',
+  'automations.cron.dayPlural.0': 'Sundays',
+  'automations.cron.dayPlural.1': 'Mondays',
+  'automations.cron.dayPlural.2': 'Tuesdays',
+  'automations.cron.dayPlural.3': 'Wednesdays',
+  'automations.cron.dayPlural.4': 'Thursdays',
+  'automations.cron.dayPlural.5': 'Fridays',
+  'automations.cron.dayPlural.6': 'Saturdays',
+  'automations.cron.daysAt': '{{days}} at {{time}}',
+  'automations.cron.everyHour': 'Every hour',
+  'automations.cron.everyHours': 'Every {{count}} hours',
+  'automations.cron.everyMinutes': { one: 'Every minute', other: 'Every {{count}} minutes' },
+  'automations.cron.weekdaysAt': 'Weekdays at {{time}}',
+  'automations.cron.weekendsAt': 'Weekends at {{time}}',
+  'automations.trigger.anyApp': 'Any app',
+  'automations.trigger.anyEvent': 'Any event',
+  'automations.trigger.manual': 'Manual request',
+  'automations.trigger.unscheduled': 'Unscheduled',
+  'chat.agentRun.by': 'by %{name}',
+  'chat.agentRun.complete': 'Task complete',
+  'chat.agentRun.completed': 'Completed',
+  'chat.agentRun.credits': '%{count} credits',
+  'chat.agentRun.error': 'Error',
+  'chat.agentRun.failed': 'Failed',
+  'chat.agentRun.planItems': '%{done}/%{total} plan items',
+  'chat.agentRun.planSummary': 'Plan summary',
+  'chat.agentRun.steps': '%{count} steps',
+  'chat.agentRun.taskComplete': 'Task complete',
+  'chat.agentRun.taskFailed': 'Task failed',
+  'chat.agentRun.unknown': 'Unknown',
+  'chat.agentRun.working': 'Agent working',
+  'chat.backToLatest': 'Back to the latest',
+  'chat.blockFailed': "This part of the answer couldn't be shown.",
+  'chat.bloom.context.freeSpace': 'Free space',
+  'chat.bloom.context.mcp': 'MCP tools',
+  'chat.bloom.context.memory': 'Memory',
+  'chat.bloom.context.messages': 'Messages',
+  'chat.bloom.context.skills': 'Skills',
+  'chat.bloom.context.system': 'System prompt',
+  'chat.bloom.context.title': 'Context window',
+  'chat.bloom.context.tools': 'Tools',
+  'chat.bloom.createdFile': 'Created',
+  'chat.bloom.limits.close': 'Close credits panel',
+  'chat.bloom.limits.dailyFree': 'Daily free credits',
+  'chat.bloom.limits.planUsage': 'Plan usage limits',
+  'chat.bloom.limits.resetsDaily': 'Resets every 24 hours',
+  'chat.bloom.limits.resetsInHours': 'Resets in {{hours}} hr {{minutes}} min',
+  'chat.bloom.limits.resetsInMinutes': 'Resets in {{minutes}} min',
+  'chat.bloom.limits.resetsSoon': 'Resets soon',
+  'chat.bloom.limits.window': '{{hours}}-hour limit',
+  'chat.bloom.limits.windowFresh': 'Resets {{hours}} hours after your next message',
+  'chat.bloom.noResults': 'No results',
+  'chat.bloom.researched': 'Researched',
+  'chat.bloom.researching': 'Researching',
+  'chat.bloom.resultCount': { one: '1 result', other: '{{count}} results' },
+  'chat.bloom.scrollToLatest': 'Scroll to latest messages',
+  'chat.bloom.searchCount': { one: '1 search', other: '{{count}} searches' },
+  'chat.bloom.searchFailed': 'Search failed',
+  'chat.bloom.searchedWeb': 'Searched the web for',
+  'chat.bloom.sourceCount': { one: '1 source', other: '{{count}} sources' },
+  'chat.bloom.taskFailed': 'Returned an error',
+  'chat.bloom.taskInput': 'With',
+  'chat.bloom.taskStopped': "Didn't finish",
+  'chat.bloom.visited': 'Visited',
+  'chat.bloom.writingFile': 'Writing',
+  'chat.copied': 'Copied!',
+  'chat.copiedToClipboard': 'Copied to clipboard',
+  'chat.copy': 'Copy',
+  'chat.copyFailed': "Couldn't copy to the clipboard",
+  'chat.dislike': 'Dislike',
+  'chat.edit': 'Edit',
+  'chat.feedbackFailed': "Your feedback couldn't be saved.",
+  'chat.like': 'Like',
+  'chat.loadingHistory': 'Loading earlier messages…',
+  'chat.newConversationAccept': 'Start a new one',
+  'chat.newConversationDismiss': 'Not now',
+  'chat.newConversationOffer': 'Start a new conversation?',
+  'chat.newStretch': 'New conversation',
+  'chat.readAloud': 'Read Aloud',
+  'chat.readAloudFailed': "Couldn't read this aloud",
+  'chat.regenerate': 'Regenerate',
+  'chat.retry': 'Retry',
+  'chat.richBlocks.source': 'Source: {{source}}',
+  'chat.searchThreadAgent': 'Agent',
+  'chat.searchThreadEmpty': 'Nothing matched.',
+  'chat.searchThreadFailed': 'The search could not be run.',
+  'chat.searchThreadHint':
+    'Search everything you have said to this agent, across every conversation.',
+  'chat.searchThreadPlaceholder': 'Search this thread',
+  'chat.searchThreadSearching': 'Searching…',
+  'chat.searchThreadYou': 'You',
+  'chat.sources': 'Sources',
+  'chat.stopReading': 'Stop reading',
+  'chat.thanksFeedback': 'Thanks for your feedback!',
+  'chat.thinking': 'Thinking',
+  'chat.today': 'Today',
+  'chat.toolCard.openTask': 'Open scheduled task %{objective}',
+  'chat.toolCard.paused': 'Paused',
+  'chat.toolCard.scheduled': 'Scheduled',
+  'chat.turnActions': 'Message actions',
+  'chat.consultFailed': "%{name} couldn't answer.",
+  'chat.shareFailed': "Couldn't create the share link.",
+  'chat.sharedFailed': "Couldn't load this conversation.",
+  'chat.sharedGone': 'This shared conversation is no longer available.',
+  'chat.turnFailed': "Alia couldn't answer right now.",
+  'chat.turnFailedRetryHint': 'Try again.',
+  'chat.turnInterrupted': 'Alia was interrupted before finishing.',
+  'chat.working': 'Working',
+  'chat.yesterday': 'Yesterday',
+  'common.close': 'Close',
+  'composer.cancelEdit': 'Cancel',
+  'composer.editPlaceholder': 'Edit your message',
+  'composer.editingMessage': 'Editing message',
+  'faircoin.indexed':
+    'Indexed price from the WFAIR/USDC pool on Base — FairCoin has no exchange listing',
+  'faircoin.liquidity': 'Liquidity',
+  'faircoin.marketCap': 'Market cap',
+  'faircoin.name': 'FairCoin',
+  'faircoin.noChart': 'Only one sample so far — not enough to draw a line.',
+  'faircoin.noPrice': 'No price',
+  'faircoin.noPriceHint': 'The WFAIR/USDC pool had no indexed price when this was asked.',
+  'faircoin.noSamples': 'No samples for this period yet.',
+  'faircoin.range.1y': '1Y',
+  'faircoin.range.24h': '24h',
+  'faircoin.range.30d': '30D',
+  'faircoin.range.7d': '7D',
+  'faircoin.range.all': 'All',
+  'faircoin.scale.billion': 'B',
+  'faircoin.scale.million': 'M',
+  'faircoin.scale.thousand': 'K',
+  'faircoin.scale.trillion': 'T',
+  'faircoin.source': 'From %{source}',
+  'faircoin.symbol': 'FAIR',
+  'faircoin.unavailable': 'No history for %{ranges}',
+  'faircoin.updated': 'Updated %{time}',
+  'faircoin.volume': '24h volume',
+  'market.dayHigh': 'Day high',
+  'market.dayLow': 'Day low',
+  'market.marketCap': 'Market cap',
+  'market.noChart': 'Not enough history to chart this range',
+  'market.noPrice': 'No quote available',
+  'market.open': 'Open',
+  'market.range.1D': '1D',
+  'market.range.1M': '1M',
+  'market.range.1Y': '1Y',
+  'market.range.5D': '5D',
+  'market.range.5Y': '5Y',
+  'market.range.6M': '6M',
+  'market.range.MAX': 'MAX',
+  'market.range.YTD': 'YTD',
+  'market.volume': 'Volume (24h)',
+  'panels.canvas.image': 'Image',
+  'panels.canvas.unsupported': 'Unsupported component type: {{type}}',
+  'panels.chart.share': 'Share',
+  'panels.chart.value': 'Value',
+  'panels.code.copied': 'Code copied',
+  'panels.code.copy': 'Copy code',
+  'panels.form.enter': 'Enter {{field}}',
+  'panels.form.select': 'Select…',
+  'panels.form.submit': 'Submit',
+  'powerLevels.auto.description': 'Picks the right level for each message',
+  'powerLevels.auto.label': 'Auto',
+  'powerLevels.high.description': 'Thinks harder on tougher questions',
+  'powerLevels.high.label': 'High',
+  'powerLevels.instant.description': 'Fastest and cheapest, for quick answers',
+  'powerLevels.instant.label': 'Instant',
+  'powerLevels.medium.description': 'Quick and capable, for everyday tasks',
+  'powerLevels.medium.label': 'Medium',
+  'powerLevels.onDevice': 'On %{device}',
+  'powerLevels.pro.description': 'Frontier models; slower and costs more',
+  'powerLevels.pro.label': 'Pro',
+  'powerLevels.ultra.description': 'Most capable; slowest and costs the most',
+  'powerLevels.ultra.label': 'Ultra',
+  'powerLevels.xhigh.description': 'Thinks even harder; a little slower',
+  'powerLevels.xhigh.label': 'XHigh',
+  'tasks.tool.done.agentSearch': 'Searched agents',
+  'tasks.tool.done.browse': 'Browsed',
+  'tasks.tool.done.codeInterpreter': 'Ran code',
+  'tasks.tool.done.consultAgent': 'Consulted an agent',
+  'tasks.tool.done.fileEdit': 'Edited file',
+  'tasks.tool.done.generateFile': 'Generated file',
+  'tasks.tool.done.shellExec': 'Ran command',
+  'tasks.tool.done.loadTools': 'Loaded tools',
+  'tasks.tool.done.userMemory': 'Remembered',
+  'tasks.tool.done.webScraper': 'Read page',
+  'tasks.tool.pill.agentSearch': 'Searching agents',
+  'tasks.tool.pill.browse': 'Browsing',
+  'tasks.tool.pill.codeInterpreter': 'Running code',
+  'tasks.tool.pill.consultAgent': 'Consulting an agent',
+  'tasks.tool.pill.fileEdit': 'Editing file',
+  'tasks.tool.pill.generateFile': 'Generating file',
+  'tasks.tool.pill.sendDiscord': 'Discord',
+  'tasks.tool.pill.sendEmail': 'Email',
+  'tasks.tool.pill.sendSignal': 'Signal',
+  'tasks.tool.pill.sendSlack': 'Slack',
+  'tasks.tool.pill.sendTelegramMessage': 'Telegram',
+  'tasks.tool.pill.shellExec': 'Running command',
+  'tasks.tool.pill.loadTools': 'Loading tools',
+  'tasks.tool.pill.userMemory': 'Remembering',
+  'tasks.tool.pill.webScraper': 'Reading page',
+  'tasks.tool.pill.webSearch': 'Web search',
+  'thought.activity': 'Activity',
+  'thought.audit.agent': 'Agent: {{name}}',
+  'thought.audit.fileGenerated': 'File generated',
+  'thought.audit.plan': 'Plan',
+  'thought.audit.planSteps': { one: '1 step', other: '{{count}} steps' },
+  'thought.audit.researchComplete': 'Research complete',
+  'thought.audit.researchIncomplete': 'Research incomplete',
+  'thought.audit.researchPhase.decomposing': 'Research: breaking down the question',
+  'thought.audit.researchPhase.finalizing': 'Research: finishing up',
+  'thought.audit.researchPhase.follow_up': 'Research: following up',
+  'thought.audit.researchPhase.reading': 'Research: reading articles',
+  'thought.audit.researchPhase.searching': 'Research: searching sources',
+  'thought.audit.researchPhase.synthesizing': 'Research: synthesizing findings',
+  'thought.audit.researching': 'Researching',
+  'thought.cancelled': 'Stopped',
+  'thought.done': 'Done',
+  'thought.failed': 'Failed',
+  'thought.failedAfter': 'Failed after {{elapsed}}',
+  'thought.filesAndSources': 'Files and sources',
+  'thought.input': 'Input',
+  'thought.loadFailed': "This conversation couldn't be loaded",
+  'thought.loading': 'Loading this conversation…',
+  'thought.messageGone': 'This message is no longer in the conversation',
+  'thought.noActivity': 'No actions recorded yet',
+  'thought.noOutputs': 'No files generated',
+  'thought.noSources': 'No sources used',
+  'thought.noSteps': 'No steps to display',
+  'thought.openOutput': 'Open {{name}} in the canvas',
+  'thought.output': 'Output',
+  'thought.outputs': 'Outputs',
+  'thought.reasoning': 'Reasoning',
+  'thought.references': 'References',
+  'thought.sourceLabel': 'Source {{n}}: {{title}}',
+  'thought.sources': 'Sources',
+  'thought.steps': 'Steps',
+  'thought.stoppedAfter': 'Stopped after {{elapsed}}',
+  'thought.thinking': 'Thinking',
+  'thought.thinkingFor': 'Thinking for {{seconds}}s...',
+  'thought.thoughtFor': 'Thought for {{seconds}} seconds',
+  'thought.title': 'Thought',
+  'thought.tool.browse': 'Browsing the web',
+  'thought.tool.generateFile': 'Generating file',
+  'thought.tool.getCurrentDate': 'Getting current date',
+  'thought.tool.getTimeline': 'Getting timeline',
+  'thought.tool.getWhatsAppChats': 'Loading WhatsApp chats',
+  'thought.tool.getWhatsAppMessages': 'Reading WhatsApp messages',
+  'thought.tool.saveUserMemory': 'Saving to memory',
+  'thought.tool.scrapeURL': 'Reading URL',
+  'thought.tool.searchKnowledgeBase': 'Searching knowledge base',
+  'thought.tool.sendTelegramMessage': 'Sending Telegram message',
+  'thought.tool.sendWhatsAppMessage': 'Sending WhatsApp message',
+  'thought.tool.updateUserContext': 'Updating context',
+  'thought.tool.updateUserPreferences': 'Updating preferences',
+  'thought.tool.webScraper': 'Reading web page',
+  'thought.tool.webSearch': 'Searching the web',
+  'thought.viewDetails': 'View details',
+  'thought.websites': 'Websites',
+  'thought.worked': 'Worked',
+  'thought.workedFor': 'Worked for {{elapsed}}',
+  'thought.working': 'Working…',
+  'thought.workingFor': 'Working for {{elapsed}}…',
+  'thought.writing': 'Writing',
+  'usageLimit.inputDisabledPlaceholder': 'Usage limit reached',
+  'weather.condition.clear': 'Clear',
+  'weather.condition.cloudy': 'Cloudy',
+  'weather.condition.drizzle': 'Drizzle',
+  'weather.condition.fog': 'Fog',
+  'weather.condition.partly-cloudy': 'Partly cloudy',
+  'weather.condition.rain': 'Rain',
+  'weather.condition.showers': 'Showers',
+  'weather.condition.snow': 'Snow',
+  'weather.condition.snow-showers': 'Snow showers',
+  'weather.condition.thunderstorm': 'Thunderstorm',
+  'weather.toggleUnit': 'Switch temperature unit',
+};

package/src/lib/copy.ts

@@ -0,0 +1,32 @@
+import { COPY_EN, type CopyEntry } from './copy-en';
+
+/**
+ * A translator keyed the way the Alia app's own catalogue keys its strings, so the app hands its
+ * `t` straight in (`labels.t`). The words the chat draws that are not one fixed `labels` field —
+ * the thread, its cards, the thought panel, the work log — are asked for by key.
+ */
+export type Translate = (key: string, params?: Record<string, unknown>) => string;
+
+function entryFor(entry: CopyEntry, count: number | undefined): string {
+  if (typeof entry === 'string') return entry;
+  if (count === 0 && entry.zero !== undefined) return entry.zero;
+  if (count === 1 && entry.one !== undefined) return entry.one;
+  return entry.other;
+}
+
+/** `{{name}}` and `%{name}` both name a parameter, as in the app's catalogue. */
+const PLACEHOLDER = /\{\{\s*(\w+)\s*\}\}|%\{(\w+)\}/g;
+
+/**
+ * The default translator: the English in `copy-en.ts`, with `{{count}}` plurals and parameters.
+ * A key it does not know answers itself, so a missing string is visible rather than blank.
+ */
+export const englishCopy: Translate = (key, params) => {
+  const entry = COPY_EN[key];
+  if (entry === undefined) return key;
+  const count = typeof params?.count === 'number' ? params.count : undefined;
+  return entryFor(entry, count).replace(PLACEHOLDER, (placeholder, a?: string, b?: string) => {
+    const value = params?.[(a ?? b) as string];
+    return value === undefined ? placeholder : String(value);
+  });
+};

package/src/lib/document-picker.ts

@@ -0,0 +1,31 @@
+import * as DocumentPicker from 'expo-document-picker';
+
+export type DocumentPickerResult = {
+  uri: string;
+  name: string;
+  size: number;
+  mimeType: string;
+};
+
+/** The platform's document picker, several at once; nothing when the person cancels or it fails. */
+export async function pickDocuments(): Promise<DocumentPickerResult[] | undefined> {
+  try {
+    const result = await DocumentPicker.getDocumentAsync({
+      type: '*/*',
+      multiple: true,
+      copyToCacheDirectory: true,
+    });
+
+    if (result.canceled === false && result.assets && result.assets.length > 0) {
+      return result.assets.map((asset) => ({
+        uri: asset.uri,
+        name: asset.name,
+        size: asset.size || 0,
+        mimeType: asset.mimeType || 'application/octet-stream',
+      }));
+    }
+  } catch (error) {
+    console.warn('Failed to pick document:', error);
+  }
+  return undefined;
+}

package/src/lib/flights.ts

@@ -1,24 +1,33 @@
 import { createContext, useContext } from 'react';
 import type { AvatarFlights, AvatarFlightSpec } from '@oxy.so/bloom/avatar-flight';
 
-import { ALIA_AVATAR } from '../components/AliaAvatar';
+import type { AliaParticipant } from './participants';
 
-/** Where Alia's avatar is in the chat: large in the greeting, then small in the header's profile. */
-export const ALIA_ANCHORS = { welcome: 'alia:welcome', profile: 'alia:profile' } as const;
+/**
+ * Where the conversation's avatars are: the lead's, large in the greeting; everybody's, small in
+ * the header's participants; and a consulted agent's, beside the reply it is writing.
+ */
+export const ANCHORS = {
+  welcome: 'lead:welcome',
+  profile: 'participants',
+  reply: (agentId: string) => `reply:${agentId}`,
+} as const;
 
-/** The greeting's avatar flies up into the header's profile as the conversation begins. */
-export const ALIA_TO_PROFILE: AvatarFlightSpec = {
-  key: 'alia',
-  character: ALIA_AVATAR,
-  from: ALIA_ANCHORS.welcome,
-  to: ALIA_ANCHORS.profile,
-  duration: 800,
-};
+/** The greeting's avatar flies up into the header's participants as the conversation begins. */
+export function leadToProfile(lead: AliaParticipant): AvatarFlightSpec {
+  return {
+    key: 'lead',
+    character: lead.character,
+    from: ANCHORS.welcome,
+    to: ANCHORS.profile,
+    duration: 800,
+  };
+}
 
 const FlightsContext = createContext<AvatarFlights | null>(null);
 
-/** The chat's avatar flights, for the greeting and the header that share them. */
+/** The chat's avatar flights, for the greeting, the thread and the header that share them. */
 export const AliaFlightsProvider = FlightsContext.Provider;
 
-/** `null` outside a chat: the greeting and the header then draw their avatars without flying. */
+/** `null` outside a chat: the greeting, the replies and the header then draw their avatars without flying. */
 export const useAliaFlights = () => useContext(FlightsContext);

package/src/lib/focus-return.ts

@@ -0,0 +1,66 @@
+import { Platform } from 'react-native';
+
+/**
+ * Where keyboard focus goes back to when the execution panel closes.
+ *
+ * The panel is opened from a row in the conversation — a tool step, the
+ * sources row, the reasoning trigger — and on the web the desktop rail is not
+ * a dialog: nothing moves focus into it and nothing would move it back. So a
+ * screen-reader or keyboard user who opened it and pressed Escape was left
+ * with focus wherever the browser had put it, which after a click on a
+ * `Pressable` is `body` in Safari. The opener is remembered here at open time
+ * and focused again at close.
+ *
+ * One slot, module-level: there is one panel, and the store's own selection
+ * already says which message it is about. A DOM element in the store would
+ * also be a DOM element in a persisted store's state tree, which it must not
+ * be.
+ */
+type Focusable = { focus: () => void };
+
+let opener: Focusable | null = null;
+
+function isFocusable(value: unknown): value is Focusable {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { focus?: unknown }).focus === 'function'
+  );
+}
+
+/**
+ * Remember what opened the panel. A caller with a ref to its own control
+ * passes it; one without (a memoised row whose ref would be one more prop)
+ * lets this read the element that is focused right now, which on the web is
+ * the button that was just activated by keyboard, and the button or `body`
+ * after a pointer press depending on the browser. Nothing is remembered on
+ * native, where focus does not work this way.
+ */
+export function rememberOpener(candidate?: unknown): void {
+  if (isFocusable(candidate)) {
+    opener = candidate;
+    return;
+  }
+  if (
+    Platform.OS === 'web' &&
+    typeof document !== 'undefined' &&
+    isFocusable(document.activeElement)
+  ) {
+    opener = document.activeElement;
+    return;
+  }
+  opener = null;
+}
+
+/** Focus the remembered opener, once, and forget it. */
+export function restoreOpenerFocus(): void {
+  const target = opener;
+  opener = null;
+  if (target === null) return;
+  try {
+    target.focus();
+  } catch {
+    // An element that has since left the document cannot take focus; there
+    // is nowhere better to send it.
+  }
+}

package/src/lib/keyboard.native.tsx

@@ -1,6 +1,25 @@
 // Native: re-export react-native-keyboard-controller components
+import Animated, { useAnimatedStyle } from 'react-native-reanimated';
+import { useReanimatedKeyboardAnimation } from 'react-native-keyboard-controller';
+
 export {
   KeyboardAwareScrollView,
   KeyboardAvoidingView,
   KeyboardProvider,
 } from 'react-native-keyboard-controller';
+
+/**
+ * The room under a bottom-anchored control for the gesture bar, while the gesture bar is what lies
+ * under it.
+ *
+ * With the keyboard up, a keyboard-avoiding host already ends at the keyboard's top edge, and the
+ * keyboard covers the gesture bar. Keeping this room then counts the bar twice: the chat's composer
+ * floated a bar's height above the keyboard, with the transcript showing through the gap (Pixel 8a).
+ * It follows the keyboard's own animation, so the control settles onto the keyboard as it rises
+ * instead of jumping after.
+ */
+export function KeyboardSafeAreaFloor({ inset }: { inset: number }) {
+  const { progress } = useReanimatedKeyboardAnimation();
+  const style = useAnimatedStyle(() => ({ height: inset * (1 - progress.value) }), [inset]);
+  return <Animated.View style={style} />;
+}

package/src/lib/keyboard.tsx

@@ -5,6 +5,7 @@ import {
   type ScrollViewProps,
   KeyboardAvoidingView as RNKeyboardAvoidingView,
   type KeyboardAvoidingViewProps as RNKeyboardAvoidingViewProps,
+  View,
 } from 'react-native';
 
 // Accept native-only props so shared components don't cause TS errors
@@ -41,3 +42,11 @@ export { KeyboardAwareScrollView, KeyboardAvoidingView };
 export function KeyboardProvider({ children }: { children: React.ReactNode }) {
   return <>{children}</>;
 }
+
+/**
+ * The room under a bottom-anchored control for the system's bottom bar. The web's keyboard resizes
+ * the page rather than covering it, so that room never has to give way to it (see the native file).
+ */
+export function KeyboardSafeAreaFloor({ inset }: { inset: number }) {
+  return <View style={{ height: inset }} />;
+}