@alia.onl/sdk 7.2.9 → 10.0.0

package/CHANGELOG.md

@@ -1,6 +1,41 @@
 # @alia.onl/sdk
 
-## 7.2.9
+## 10.0.0
+
+### Peers: `@oxy.so/core` `^3.0.0`, `@oxy.so/services` `^8.0.0`
+
+**Breaking.** Core 3 is the namespaced Oxy client (`oxyServices.session`,
+`oxyServices.users`, …): the SDK now reads the session token as
+`oxyServices.session.accessToken` instead of `getAccessToken()` /
+`httpService`, so it runs only on a host with core 3 and services 8 — one app
+holds one Oxy SDK. Nothing in the SDK's own API changes.
+
+### `AliaMarkdown` builds its parser once
+
+`react-native-markdown-display` evaluates its `markdownit`,
+`allowedImageHandlers` and `topLevelMaxExceededItem` defaults on every render,
+so each render of each block built a Markdown parser and rebuilt its renderer
+and styles. `AliaMarkdown` now passes one shared parser and those defaults'
+own values, created once. Output is unchanged; a 1,000-message thread holds
+7 MiB less heap in the app.
+
+### Voice errors have codes
+
+Additive. `useSpeechToText` returns `errorCode` beside `error`, and
+`useVoiceRoom` returns `errorCode` and `turnErrorCode` beside `error` and
+`turnError`: a `VoiceErrorCode` (exported from both entries with
+`VOICE_ERROR_MESSAGES`, the English copy) so an app can say what went wrong in
+its own language. The English strings are unchanged.
+
+`VoiceControls` takes `labels` (defaults in `VOICE_CONTROLS_LABELS`) for every
+word it shows, and its mute and end buttons are named buttons for screen
+readers, mute as a toggle.
+
+`useSpeechToText` unmounted mid-dictation now also clears `useSTTStore`. It used
+to abort the recognizer but leave the store reading `isRecording: true`, which
+`useAmbientWave` then drew as dictation for as long as the page lived.
+
+## 9.0.0
 
 ### The full-screen chat clears the gesture bar and the keyboard
 
@@ -12,11 +47,112 @@ measures its own position in the window (keyboard-controller's
 already ends above the inset, the inset is not added on top of the keyboard. The
 avoiding view `PromptInput` carries measured its parent-relative layout and so
 never lifted inside the screen. The web `KeyboardAvoidingView` accepts and
-ignores `automaticOffset`.
-
-`AliaChatScreen` is a full-screen route: render it where no tab bar or other
-bottom chrome is drawn. Its keyboard lift needs the app wrapped in
-keyboard-controller's `KeyboardProvider` (re-exported by this package).
+ignores `automaticOffset`. Also released for 7.x as 7.2.9.
+
+### Real models, and no model identifier in the package
+
+Alia has no models of its own: `GET /catalogue` now lists the real models Oxy
+serves (`publisher/model`), with the server's `defaultModelId` and
+`featuredIds`. The SDK follows it, and the product modes and routing profiles
+(`mode:*`, `route:*`) are gone from it.
+
+**Breaking:**
+
+- `PREFERRED_CHAT_MODEL_ID` and `PREFERRED_VOICE_MODEL_ID` are removed. With no
+  `model`, `useAliaChat`, the voice turn sender, `useTTS` and `useVoiceRoom` send
+  no `model` and the server's default (chat or speech) answers.
+- `parseCatalogue` and `fetchCatalogue` return a `Catalogue`
+  (`{ entries, defaultModelId, featuredIds }`), and `CatalogueEntry` is the new
+  model shape (`name`, `publisher`, `contextWindow`, `reasoningEfforts`,
+  `pricing`, …). `CatalogueEntryKind` is removed.
+- `resolveSelection(requestedId, catalogue)` and `resolveModelId(apiUrl,
+  requestedId?)` take no preferred id; an identifier the catalogue no longer
+  lists resolves to `undefined` (omit `model`) instead of a substitute.
+- The `alia.model_switch` stream event is no longer accepted; the server no
+  longer sends it.
+
+**Added:** `AliaMarkdown` takes `renderCodeBlock` to draw fenced code with the
+host's own code card (the Alia app passes Bloom's `CodeBlock`).
+
+### The consumer-backend path is documented
+
+Documentation only; no code, wire or default changed, and no version is cut for
+it.
+
+The package now has a README. It says which endpoint `useAliaChat` calls and
+why it is `/v1/chat/completions` rather than `/alia/chat`: this package ships
+raw source and compiles into apps on origins Alia does not enumerate, and
+`/alia/chat` answers CORS preflights only for Alia's own origins. It then
+documents the path that works from any origin today — `useAliaChat({ apiUrl })`
+pointed at the consumer's own backend, which calls `POST /alia/chat`
+server-to-server, forwards the user's Oxy token, and streams the SSE body back
+unchanged — with a minimal relay. The `apiUrl` option's JSDoc says the same in
+short. Issue #244 records the two other shapes and why neither is available
+yet.
+
+## 8.0.0
+
+### Voice runs on the device
+
+Dictation and voice calls work again. Both used Alia endpoints that called
+speech providers directly — `POST /v1/voice/transcribe` and a LiveKit room from
+`POST /v1/voice/token` — and both have been refusing since Alia's inference
+moved behind Oxy, which serves chat and speech synthesis but no transcription or
+realtime session. Those endpoints are removed from the API.
+
+- **`useSpeechToText`** recognizes on the device (Web Speech API on web,
+  `expo-speech-recognition` on iOS/Android). Its shape is unchanged —
+  `startRecording`, `stopAndTranscribe`, `cancel`, the three states,
+  `useSTTStore` metering — and it gains `lang` and `isSupported`.
+- **`useVoiceRoom`** is a turn loop: on-device listening with end-of-utterance
+  detection, each utterance sent through the chat path (`sendTurn`, by default
+  `createAliaVoiceTurnSender`, which posts `/v1/chat/completions` with
+  `responseMode: 'voice'`), the answer spoken sentence by sentence through
+  `/v1/audio/speech`, and barge-in. `connect`, `disconnect`, `roomState`,
+  `agentState`, `messages`, `isMuted`, `toggleMute` and `error` keep their
+  meaning; it adds `turnError` and the options `sendTurn`, `chatModel`, `lang`,
+  `endOfUtteranceMs` and `bargeIn`.
+- The call asks `/v1/audio/speech` for the product voices `male` / `female`;
+  it no longer sends upstream voice names.
+
+**Breaking:**
+
+- `livekit-client` is no longer a peer dependency; `expo-speech-recognition`
+  is a new one (the root entry's dictation reaches it on native), and a native
+  app needs a new build with its config plugin.
+- `useVoiceRoom().room` is a `VoiceLevelSource` (live capture and playback
+  levels), not a LiveKit `Room`; `useAudioLevelMonitor` takes that.
+- `livekit-client` is gone from the package entirely; nothing in either entry
+  reaches it (`check:entries` asserts that).
+- The cohost is removed. `useVoiceRoom` no longer returns `cohostActive`,
+  `roundComplete`, `enableCohost`, `disableCohost` or `continueCohost`, and
+  `currentSpeaker` is `'primary' | 'user' | null`. `VoiceControls` no longer
+  takes `cohostActive`, `currentSpeaker`, `roundComplete`, `onEnableCohost`,
+  `onDisableCohost` or `onContinueCohost`, and draws no cohost button or
+  "Continue conversation" prompt. `ChatMessage.speaker` and
+  `VoiceMessage.speaker` are `'primary'` only, and the message list draws no
+  "Cohost" label.
+- `useSpeechToText` no longer takes `apiUrl` or `accessToken`; dictation never
+  talks to the Alia API. Pass `lang` or nothing.
+- The pre-Bloom composer is no longer public. `PromptInput`,
+  `PromptInputTextarea`, `PromptInputActions`, `PromptInputSubmitButton`,
+  `PromptInputMicButton`, `PromptInputAddMenu`, `PromptInputAttachments`,
+  `PromptInputAutocomplete`, `PromptInputContext`, `usePromptInput`,
+  `useIsFullscreen`, `ChatTextInput` and the types `PromptInputProps`,
+  `PromptInputContextType`, `Attachment` and `Completion` are removed from the
+  root entry. `AliaChatScreen` / `AliaChatSheet` still draw their composer;
+  build your own from the primitives if you composed one from these parts.
+- Dependencies trimmed: `@tanstack/react-query`,
+  `@tanstack/react-query-persist-client` and
+  `@tanstack/query-async-storage-persister` are no longer dependencies (no
+  module imported them), and `socket.io-client` and `expo-font` are no longer
+  peer dependencies (likewise unused). Keep them in your app if your app uses
+  them itself.
+
+**Server side, alongside this release:** the `alia_sk_*` developer keys are
+retired and refused by the Alia API. The SDK never used them — it sends the
+signed-in user's Oxy session — but a backend that relays the SDK's requests
+with such a key must forward the user's Oxy token instead (see the README).
 
 ## 7.2.8
 

package/README.md

@@ -0,0 +1,242 @@
+# @alia.onl/sdk
+
+Alia's chat SDK for React Native and Expo apps built on Oxy: the chat sheet and
+screen, the streaming hook, speech in and out, and the primitives they are made
+of. It renders inside the one `OxyProvider` your app already mounts and sends
+the signed-in user's Oxy session with every request; it never holds a token of
+its own.
+
+The package ships **raw TypeScript source** — `main`, `types` and every
+`exports` entry point at `src/`. Your bundler compiles it with the rest of your
+app, which is why the section on endpoints below matters more than it would for
+a prebuilt library.
+
+## Install
+
+```sh
+bun add @alia.onl/sdk
+```
+
+`react`, `react-native`, `@oxy.so/core`, `@oxy.so/services` and the Expo modules
+listed under `peerDependencies` in `package.json` are yours to install. Metro
+must resolve package `exports` (`resolver.unstable_enablePackageExports = true`,
+the default in Expo SDK 53+), because every icon import is a subpath.
+
+Two entry points:
+
+- `@alia.onl/sdk` — text chat, dictation, read-aloud, catalogue, primitives.
+- `@alia.onl/sdk/voice` — `VoiceSession` and `useVoiceRoom`, the voice call.
+  Pass `VoiceSession` to the shell as `voiceSession` to offer calls; leave it
+  out for text-only chat and the call is never compiled.
+
+## Speech
+
+Dictation (`useSpeechToText`) and the voice call (`useVoiceRoom`) recognize
+speech **on the device**: the Web Speech API in browsers that have it (Chromium
+and Safari — not Firefox, where `useSpeechToText().isSupported` is `false`), and
+[`expo-speech-recognition`](https://github.com/jamsch/expo-speech-recognition)
+on iOS and Android. No audio is sent to Alia; whether the platform's recognizer
+uses a network service of its own is the platform's (Chrome's does).
+
+On native, add `expo-speech-recognition` (a peer dependency, like `expo-audio`:
+the root entry's mic button reaches it) and its config plugin to your app, then
+make a new native build:
+
+```json
+["expo-speech-recognition", {
+  "microphonePermission": "Allow $(PRODUCT_NAME) to hear what you dictate and say in voice calls.",
+  "speechRecognitionPermission": "Allow $(PRODUCT_NAME) to turn your speech into text."
+}]
+```
+
+A voice call is a turn loop, not a realtime session: it listens until the
+person pauses, sends what they said through the ordinary chat path
+(`POST /v1/chat/completions` with `responseMode: "voice"`, or your own
+`sendTurn`), and speaks the answer sentence by sentence through
+`POST /v1/audio/speech` in the product voice (`male` / `female`). Talking over
+the answer interrupts it. Pass `lang` to both hooks to follow your app's
+language.
+
+## Use
+
+```tsx
+import { AliaChatScreen } from '@alia.onl/sdk';
+
+export function Assistant() {
+  return <AliaChatScreen />;
+}
+```
+
+`AliaChatScreen` is a full-screen route: it pads itself by the top and bottom
+safe-area insets, so render it where no tab bar or other bottom chrome is drawn.
+On iOS and Android its composer rises with the keyboard through
+`react-native-keyboard-controller`, which needs the app wrapped in its
+`KeyboardProvider` (re-exported here).
+
+Or the hook on its own, with your own UI:
+
+```tsx
+import { useAliaChat } from '@alia.onl/sdk';
+
+const { messages, send, isStreaming, stop, error } = useAliaChat({
+  clientContext: 'The user is looking at their order history.',
+});
+```
+
+`useAliaChat` streams a turn as Server-Sent Events and switches on Alia's
+product events — `alia.reasoning`, `alia.tool_result`, `alia.research_progress`,
+`alia.plan_preview`, delegated-agent answers — into `ChatMessage` fields your
+components render. Those events are the product runtime's, not part of the Oxy
+generic inference contract, and this package is written against them on
+purpose: it is a **product** client.
+
+## Which endpoint the SDK calls, and why
+
+The hook sends its turns to `POST {apiUrl}/v1/chat/completions`, with `apiUrl`
+defaulting to `EXPO_PUBLIC_ALIA_API_URL` or `https://api.alia.onl`. It also
+reads `GET {apiUrl}/catalogue` once per base URL when a `model` is passed, to
+check that `publisher/model` against the real models the server offers. With no
+`model`, the request carries none and the server's default model answers — the
+SDK ships no model identifier of its own.
+
+That is the compatibility surface, not the product route. `POST /alia/chat` is
+the same handler with the same authentication, and it is where Alia's own
+clients go — but the two mounts answer browsers differently:
+
+| Preflight | `access-control-allow-origin` |
+| --- | --- |
+| `OPTIONS /alia/chat` from `https://alia.onl` or `https://console.alia.onl` | that origin, with credentials |
+| `OPTIONS /alia/chat` from an origin Alia does not enumerate | **absent** |
+| `OPTIONS /v1/chat/completions` from anywhere | `*` |
+
+`/alia/chat` takes Alia's exact-origin allowlist (`packages/api/src/lib/cors-origins.ts`);
+`/v1` is public CORS. Because this package compiles into *your* app on *your*
+origin, defaulting the hook to `/alia/chat` would fail every consumer's
+preflight on web. So it stays on `/v1/chat/completions`, which is Alia's
+**permanent product API** — it does not sunset
+([ADR 0010](https://github.com/OxyHQ/Alia/blob/main/docs/adr/0010-alia-keeps-a-product-api-credentials-come-from-oxy-console.md)).
+Generic model access is a different product, Kaana through Oxy; this package
+is written against Alia's, and the credential a consumer presents is an Oxy
+one — the signed-in user's session today. A change of default to `/alia/chat`
+would be a semver-major of this package, would reach only consumers who upgrade
+**and** rebuild, and is not needed to escape a sunset; it is taken only if the
+per-application origin policy below makes it worthwhile
+([#244](https://github.com/OxyHQ/Alia/issues/244), closed on that decision).
+
+Native apps are not subject to CORS at all — React Native sends no `Origin`
+header — so the table above is about web builds and the backend path below.
+
+## Using the SDK from your own product: the consumer-backend path
+
+The supported way for an application outside Alia's origins to use this SDK
+today is to put your own backend between the SDK and Alia. Your backend
+receives the SDK's request, calls Alia's product route server-to-server — a
+server sends no `Origin` header, so `/alia/chat` answers it on its credential
+alone — and streams the SSE body back unchanged. Then point the hook at that
+backend:
+
+```tsx
+useAliaChat({ apiUrl: 'https://your-backend.example' });
+```
+
+The hook keeps its paths, so your backend answers
+`POST /v1/chat/completions` and `GET /catalogue` under whatever base URL you
+give it. Nothing about the stream changes: the SDK's parser reads the bytes Alia
+wrote.
+
+**Which credential.** The SDK attaches the signed-in user's Oxy access token as
+`Authorization: Bearer …` on the request your backend receives. Forward that
+header as it is. `POST /alia/chat` authenticates with
+`authenticateTokenOrApiKey` (`packages/api/src/routes/chat.ts`,
+`packages/api/src/middleware/auth.ts`), which accepts an Oxy session token —
+verified with Oxy, the same way it would be if the browser had called Alia
+directly — and the turn is metered to that user's Alia entitlement, the same as
+a direct call. The other credentials the middleware recognises are
+Alia-internal. There is no consumer-application credential for this route yet — that is Oxy Applications' to issue (OxyHQ/oxy#972).
+
+A minimal relay, Node 18+ and Express:
+
+```ts
+import express from 'express';
+
+const ALIA = 'https://api.alia.onl';
+const app = express();
+app.use(express.json({ limit: '1mb' }));
+
+/** Relay one request to Alia and stream the answer back unchanged. */
+async function relay(
+  req: express.Request,
+  res: express.Response,
+  method: 'GET' | 'POST',
+  path: string,
+): Promise<void> {
+  const controller = new AbortController();
+  req.on('close', () => controller.abort());
+
+  const authorization = req.get('authorization');
+  const upstream = await fetch(`${ALIA}${path}`, {
+    method,
+    headers: {
+      ...(authorization ? { Authorization: authorization } : {}),
+      Accept: req.get('accept') ?? 'application/json',
+      ...(method === 'POST' ? { 'Content-Type': 'application/json' } : {}),
+    },
+    body: method === 'POST' ? JSON.stringify(req.body) : undefined,
+    signal: controller.signal,
+  });
+
+  res.status(upstream.status);
+  res.setHeader('Content-Type', upstream.headers.get('content-type') ?? 'application/json');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('X-Accel-Buffering', 'no'); // keep proxies from buffering the SSE stream
+  res.flushHeaders();
+
+  if (upstream.body === null) {
+    res.end();
+    return;
+  }
+  try {
+    for await (const chunk of upstream.body) res.write(chunk);
+  } catch (error) {
+    if (!controller.signal.aborted) throw error;
+  } finally {
+    res.end();
+  }
+}
+
+// The SDK's turn: answered by Alia's PRODUCT route, server-to-server.
+app.post('/v1/chat/completions', (req, res) => relay(req, res, 'POST', '/alia/chat'));
+
+// The SDK's model check. Without this the hook still works — an unreadable
+// catalogue leaves the requested identifier alone — but it never learns what
+// the server offers.
+app.get('/catalogue', (req, res) => relay(req, res, 'GET', '/catalogue'));
+
+app.listen(3000);
+```
+
+The request body the SDK sends is `{ model?, messages, stream: true }` and the
+response Alia writes is `text/event-stream`; the relay forwards both without
+reading them. CORS between your web app and your backend is yours to configure,
+as it would be for any of your own routes.
+
+**The trade-off.** This is one more hop, and one more process in the path of a
+stream. Some consumers will not want it, which is why it is documented as the
+path that works today rather than chosen as the only one. The other two shapes
+— a CORS policy on `/alia/chat` for registered consumer origins, and the SDK
+default moving to `/alia/chat` in a major — are recorded in #244: the first is
+blocked on Oxy Applications carrying an origin registry (OxyHQ/oxy#972), and
+the second is an adoption window rather than a switch, for the raw-source
+reason above.
+
+## Scripts
+
+```sh
+bun run typecheck       # tsc --noEmit
+bun run test            # vitest
+bun run check:entries   # the root entry must not reach the voice call
+```
+
+## Licence
+
+Apache-2.0. See `LICENSE` and `NOTICE`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alia.onl/sdk",
-  "version": "7.2.9",
+  "version": "10.0.0",
   "description": "Alia AI chat SDK — reusable chat UI, voice, and streaming components for Oxy apps",
   "main": "src/index.ts",
   "react-native": "src/index.ts",
@@ -31,9 +31,6 @@
   "dependencies": {
     "@radix-ui/react-dropdown-menu": "^2.1.20",
     "@radix-ui/react-icons": "^1.3.2",
-    "@tanstack/query-async-storage-persister": "^5.101.2",
-    "@tanstack/react-query": "^5.102.8",
-    "@tanstack/react-query-persist-client": "^5.102.8",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react-native": "^1.24.0",
@@ -45,25 +42,23 @@
   "peerDependencies": {
     "react": "^19.2.3",
     "react-native": "^0.86.0",
-    "@oxy.so/core": "^1.0.1",
-    "@oxy.so/services": "^1.0.1",
+    "@oxy.so/core": "^3.0.0",
+    "@oxy.so/services": "^8.0.0",
     "@react-native-async-storage/async-storage": "^2.2.0",
-    "socket.io-client": "^4.8.3",
-    "expo-font": "^57.0.0",
     "expo-blur": "^57.0.0",
     "react-native-reanimated": "^4.5.0",
     "react-native-gesture-handler": "^2.32.0",
     "react-native-safe-area-context": "^5.8.0",
     "react-native-keyboard-controller": "^1.21.9",
-    "react-native-svg": "^15.15.4",
-    "livekit-client": "^2.20.1",
+    "react-native-svg": "^15.15.5",
     "expo-audio": "^57.0.0",
     "expo-image": "^57.0.0",
     "expo-image-picker": "^57.0.2",
     "expo-document-picker": "^57.0.0",
     "expo-haptics": "^57.0.0",
     "nativewind": "^5.0.0-preview.3",
-    "expo-clipboard": "^57.0.0"
+    "expo-clipboard": "^57.0.0",
+    "expo-speech-recognition": "^57.1.0"
   },
   "peerDependenciesMeta": {
     "nativewind": {
@@ -77,6 +72,7 @@
     "@types/react-test-renderer": "^19.1.0",
     "react-test-renderer": "19.2.3",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "expo-speech-recognition": "~57.1.0"
   }
 }

package/src/components/AliaChatContent.tsx

@@ -286,7 +286,6 @@ export function AliaChatContent({
             onStop={stop}
             emptyAction={voiceActivateButton}
             placeholder="Ask Alia..."
-            apiUrl={apiUrl}
             autocomplete={!!useSuggestions}
             useSuggestions={useSuggestions}
             onSuggestionUsed={onSuggestionUsed}

package/src/components/AliaChatMessageList.tsx

@@ -337,10 +337,6 @@ const AssistantMessage = React.memo(function AssistantMessage({
       {/* Message Content */}
       {(hasContent || message.isStreaming) && (
         <View className="flex-col items-start gap-0.5">
-          {/* Voice cohost label */}
-          {message.source === 'voice' && message.speaker === 'cohost' && (
-            <Text className="text-xs text-indigo-400 mb-0.5">Cohost</Text>
-          )}
           {/* Agent identity */}
           {message.agentInfo && (
             <View className="flex-row items-center gap-2 mb-0.5">

package/src/components/IdentityMark.tsx

@@ -203,6 +203,9 @@ export function IdentityMark({
       // button would promise an action it does not have.
       accessibilityRole={onPress === undefined ? 'image' : 'button'}
       accessibilityLabel={accessibilityLabel}
+      // Nor a Tab stop: on web a Pressable is focusable by default, so the
+      // flourish was an unlabelled stop in the keyboard order that did nothing.
+      focusable={onPress !== undefined}
       className={className}
       style={box}
     >

package/src/components/Markdown.tsx

@@ -1,6 +1,6 @@
 import React, { useMemo, type ReactNode } from 'react';
 import { View, Text, Platform, Linking, useColorScheme } from 'react-native';
-import Markdown, { type ASTNode } from 'react-native-markdown-display';
+import Markdown, { MarkdownIt, type ASTNode } from 'react-native-markdown-display';
 import type { AliaColors } from '../theme';
 
 // Hardcoded fallback colors for standalone SDK usage (when no color override is passed).
@@ -24,10 +24,32 @@ const BODY_TEXT = { fontSize: 16, lineHeight: 28 } as const;
 const HEADING_TEXT = { fontSize: 16, lineHeight: 22 } as const;
 const MONO_FONT = Platform.select({ ios: 'Courier', android: 'monospace', default: 'monospace' })!;
 
-function createRules(colors: AliaColors) {
+function createRules(colors: AliaColors, renderCodeBlock?: RenderCodeBlock) {
   const { text: textColor, muted, border, primary, mutedForeground } = colors;
 
+  /**
+   * Fenced and indented code, drawn by the host when it brings a code card of
+   * its own (the app passes Bloom's `CodeBlock`). This package has no Bloom
+   * dependency, so it cannot name one itself; without the prop the library's
+   * default `fence` / `code_block` rendering, styled below, stays.
+   */
+  const codeRules = renderCodeBlock === undefined
+    ? {}
+    : {
+        fence: (node: ASTNode) => (
+          <View key={node.key} style={{ marginVertical: 8 }}>
+            {renderCodeBlock(node.content.replace(/\n$/, ''), codeLanguage(node))}
+          </View>
+        ),
+        code_block: (node: ASTNode) => (
+          <View key={node.key} style={{ marginVertical: 8 }}>
+            {renderCodeBlock(node.content.replace(/\n$/, ''), undefined)}
+          </View>
+        ),
+      };
+
   return {
+    ...codeRules,
     heading1: (node: ASTNode, children: ReactNode[]) => (
       <Text
         key={node.key}
@@ -249,6 +271,16 @@ function createStyles(colors: AliaColors, fontFamily: string | undefined) {
   };
 }
 
+/** Draws one block of code: its source, and the fence's language when it named one. */
+export type RenderCodeBlock = (code: string, language: string | undefined) => ReactNode;
+
+/** The fence's info string up to the first space (```ts title=x → `ts`). */
+function codeLanguage(node: ASTNode): string | undefined {
+  const info = (node as ASTNode & { sourceInfo?: string }).sourceInfo?.trim() ?? '';
+  const language = info.split(/\s+/)[0];
+  return language === '' ? undefined : language;
+}
+
 export interface AliaMarkdownProps {
   /**
    * The sans family for body text, as a SINGLE family name — RN's `fontFamily`
@@ -263,6 +295,12 @@ export interface AliaMarkdownProps {
   fontFamily?: string;
   content: string;
   colors?: Partial<AliaColors>;
+  /**
+   * Draw fenced code with the host's own code card. Keep the function's
+   * identity stable (a module-level function or a `useCallback`): it is part of
+   * the rules' memo, and a new one per render re-parses every block.
+   */
+  renderCodeBlock?: RenderCodeBlock;
 }
 
 const FENCE_RE = /^\s*(?:```|~~~)/;
@@ -327,21 +365,64 @@ type MarkdownBlockProps = {
   styles: ReturnType<typeof createStyles>;
 };
 
-const MarkdownBlock = React.memo(function MarkdownBlock({ content, rules, styles }: MarkdownBlockProps) {
-  return <Markdown rules={rules} style={styles}>{content}</Markdown>;
-});
+/**
+ * `react-native-markdown-display` gives three of its props DEFAULT VALUES that
+ * are new objects on every render: `markdownit = MarkdownIt({ typographer:
+ * true })`, `allowedImageHandlers = [...]` and `topLevelMaxExceededItem =
+ * <Text>`. A default parameter is evaluated per call, so each render of each
+ * `<Markdown>` built a parser (compiling linkify-it's regexes), and the two
+ * others sit in the deps of its renderer's `useMemo`, so the renderer — and
+ * the `StyleSheet.create` of every style inside it — was rebuilt every render
+ * too. A streamed answer re-renders its last block per token, and opening a
+ * thread renders every block once: both paid for it. Passing the defaults'
+ * own values, created once, makes both memos hold. The parser is shared:
+ * `parse` keeps no state between calls.
+ *
+ * The typings omit the last two props, which the component does take.
+ */
+const PARSER = MarkdownIt({ typographer: true });
+const IMAGE_HANDLERS = [
+  'data:image/png;base64',
+  'data:image/gif;base64',
+  'data:image/jpeg;base64',
+  'https://',
+  'http://',
+];
+const TOP_LEVEL_EXCEEDED = <Text key="dotdotdot">...</Text>;
+const StableMarkdown = Markdown as React.ComponentType<
+  React.ComponentProps<typeof Markdown> & {
+    allowedImageHandlers?: string[];
+    topLevelMaxExceededItem?: ReactNode;
+  }
+>;
+
+function ParsedMarkdown({ content, rules, styles }: MarkdownBlockProps) {
+  return (
+    <StableMarkdown
+      rules={rules}
+      style={styles}
+      markdownit={PARSER}
+      allowedImageHandlers={IMAGE_HANDLERS}
+      topLevelMaxExceededItem={TOP_LEVEL_EXCEEDED}
+    >
+      {content}
+    </StableMarkdown>
+  );
+}
+
+const MarkdownBlock = React.memo(ParsedMarkdown);
 
-export function AliaMarkdown({ content, colors: colorOverrides, fontFamily }: AliaMarkdownProps) {
+export function AliaMarkdown({ content, colors: colorOverrides, fontFamily, renderCodeBlock }: AliaMarkdownProps) {
   const scheme = useColorScheme();
   const fallback = scheme === 'dark' ? FALLBACK_DARK : FALLBACK_LIGHT;
   const colors = { ...fallback, ...colorOverrides } as AliaColors;
 
-  const customRules = useMemo(() => createRules(colors), [colors.text, colors.muted, colors.border, colors.primary, colors.mutedForeground]);
+  const customRules = useMemo(() => createRules(colors, renderCodeBlock), [colors.text, colors.muted, colors.border, colors.primary, colors.mutedForeground, renderCodeBlock]);
   const markdownStyles = useMemo(() => createStyles(colors, fontFamily), [colors.text, colors.muted, colors.border, colors.primary, colors.mutedForeground, fontFamily]);
   const blocks = useMemo(() => splitMarkdownBlocks(content), [content]);
 
   if (blocks.length === 1) {
-    return <Markdown rules={customRules} style={markdownStyles}>{blocks[0]}</Markdown>;
+    return <ParsedMarkdown content={blocks[0]} rules={customRules} styles={markdownStyles} />;
   }
 
   // Each block's `body` rule cancels its own trailing paragraph margin

package/src/components/ResearchProgressCard.tsx

@@ -23,6 +23,9 @@ const PHASE_LABELS: Record<string, string> = {
   follow_up: 'Follow-up research',
   finalizing: 'Polishing report',
   complete: 'Research complete',
+  // The engine finished searching but could not write the final answer; the
+  // message carries what was found, and this label keeps the card honest.
+  failed: 'Research incomplete',
 };
 
 const PHASE_ORDER = ['decomposing', 'searching', 'synthesizing', 'follow_up', 'finalizing', 'complete'];

package/src/components/ui/prompt-input/mic-button.tsx

@@ -8,12 +8,11 @@ import { usePromptInput } from "./context";
 
 export type PromptInputMicButtonProps = {
   className?: string;
-  apiUrl?: string;
 };
 
-export function PromptInputMicButton({ className, apiUrl }: PromptInputMicButtonProps) {
+export function PromptInputMicButton({ className }: PromptInputMicButtonProps) {
   const { value, setValue, onError } = usePromptInput();
-  const stt = useSpeechToText({ apiUrl });
+  const stt = useSpeechToText();
 
   useEffect(() => {
     if (stt.error) {