@alia.onl/sdk 21.4.0 → 21.5.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @alia.onl/sdk
 
+## 21.5.1
+
+### Fixed
+
+- Embedded welcome and conversation sheets now request Bloom's bounded `sizing="fill"`
+  presentation. After the chat moved to Screen composition, a content-sized sheet could
+  mount at zero height even though the conversation and composer had loaded. Bloom owns
+  the available height, keyboard clearance and safe areas; hosts need no viewport workaround.
+
+### Changed
+
+- The Bloom peer is `>=15.10.0 <16.0.0`, the first release with the bounded sheet contract.
+  The independent thought sheet keeps its existing content sizing.
+
+## 21.5.0
+
+### Fixed
+
+- **The SDK no longer ships every Oxy account screen to the app.** The host's app assertion
+  (`useAppAssertion`) was read from `@oxy.so/services/ui`, the only entry that exported it, and
+  that entry registers every account screen at import (with Bloom's phone flags and the rest), so
+  every app using the SDK carried them in its first-paint JS: +0.58 MiB in CrowdSource's reviewer.
+  It now comes from the lean `@oxy.so/services/ui/client`, like `useOxy` and `useAuth`.
+  `check:entries` refuses `@oxy.so/services/ui` from every entry, as it already refused the root.
+
+### Changed
+
+- The `@oxy.so/services` peer is `>=12.1.0`, the first release whose `ui/client` exports
+  `useAppAssertion`.
+
 ## 21.4.0
 
 ### Added

package/README.md

@@ -27,6 +27,10 @@ the default in Expo SDK 53+), because every icon import is a subpath.
 
 The chat is built from Bloom (`@oxy.so/bloom`, a peer dependency): mount Bloom's
 `BloomProvider` above it, with the one `KeyboardProvider` your app already has.
+The main and conversation sheets request Bloom's `sizing="fill"` presentation: the
+shared sheet owns the bounded height, safe areas and keyboard clearance that the
+chat's Screen needs. Hosts should not add window-height calculations or a second
+scroll container to make an embedded chat visible.
 
 Alia's avatar is Bloom's 3D character (`AgentAvatar`). It draws through a runtime of
 static files (about 214 MB), which the chat loads from Alia's own origin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alia.onl/sdk",
-  "version": "21.4.0",
+  "version": "21.5.1",
   "description": "Alia AI chat SDK — the conversation runtime, chat UI, voice calls and dictation for Oxy apps",
   "main": "src/index.ts",
   "react-native": "src/index.ts",
@@ -54,9 +54,9 @@
     "react": "^19.2.3",
     "react-native": "^0.86.0 || ^0.88.0",
     "@expo/vector-icons": "^15.1.1",
-    "@oxy.so/bloom": ">=10.21.0",
+    "@oxy.so/bloom": ">=15.10.0 <16.0.0",
     "@oxy.so/core": ">=3.0.0",
-    "@oxy.so/services": ">=11.12.0",
+    "@oxy.so/services": ">=12.1.0",
     "@tanstack/react-query": "^5.101",
     "@react-native-async-storage/async-storage": "^2.2.0",
     "expo-blur": "^57.0.0 || ^58.0.0",

package/src/components/AliaChatSheet.tsx

@@ -301,6 +301,7 @@ const AliaChatSheetBody = forwardRef<AliaChatSheetRef, AliaChatSheetProps>(
       <AgentAvatarProvider runtimeUrl={characterRuntimeUrl}>
         <BottomSheet
           ref={mainRef}
+          sizing="fill"
           detached={detached}
           scrollable={false}
           manualActivation
@@ -333,6 +334,7 @@ const AliaChatSheetBody = forwardRef<AliaChatSheetRef, AliaChatSheetProps>(
           <BottomSheet
             key={conversation.key}
             ref={conversationRef}
+            sizing="fill"
             detached={detached}
             scrollable={false}
             manualActivation

package/src/runtime/app-assertion.ts

@@ -1,6 +1,4 @@
-// `@oxy.so/services/ui`, not the root barrel (which ships the sign-in panels, `check:entries`):
-// `ui/client` does not export `useAppAssertion`.
-import { useAppAssertion } from '@oxy.so/services/ui';
+import { useAppAssertion } from '@oxy.so/services/ui/client';
 import { useMemo } from 'react';
 
 /**

package/src/runtime/error-utils.ts

@@ -102,3 +102,43 @@ export function errorName(err: unknown): string | undefined {
 export function errorResponseData(err: unknown): ErrorResponseData | undefined {
   return asObject(err).response?.data;
 }
+
+/** A refusal body is a small JSON envelope; more than this is not one. */
+const MAX_ERROR_BODY_BYTES = 64 * 1024;
+
+/**
+ * The whole body of a non-OK streaming response, parsed as JSON, or `null`.
+ *
+ * A streaming fetch is body-oriented (`.json()` is not reliable on it), so the
+ * body is read through its reader. ONE `read()` is not the body: a network that
+ * splits the envelope across chunks handed `JSON.parse` half of it, which threw,
+ * and the typed `code` and `reference` were lost for a generic "Server error".
+ * It reads to the end, bounded, and always releases the reader.
+ */
+export async function readErrorResponseBody(response: {
+  body?: ReadableStream<Uint8Array> | null;
+}): Promise<unknown> {
+  const reader = response.body?.getReader();
+  if (!reader) return null;
+  const decoder = new TextDecoder();
+  let text = '';
+  let bytes = 0;
+  try {
+    while (bytes < MAX_ERROR_BODY_BYTES) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+    return JSON.parse(text);
+  } catch {
+    return null;
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+      // Already closed: nothing left to release.
+    }
+  }
+}

package/src/runtime/use-conversation-stream.ts

@@ -5,7 +5,13 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 import { useLabels } from '../lib/labels';
 import { useAppAssertionHeaders } from './app-assertion';
 import { type AliaArtifact, useAliaRuntime } from './config';
-import { errorCode, errorMessage as getErrorMessage, errorName, errorStatus } from './error-utils';
+import {
+  errorCode,
+  errorMessage as getErrorMessage,
+  errorName,
+  errorStatus,
+  readErrorResponseBody,
+} from './error-utils';
 import { agentMessageId, buildOutboundMessages, isAgentMessageOf } from './message-history';
 import { aliaQueryKeys } from './query-keys';
 import { createRandomUuid } from './random-uuid';
@@ -314,8 +320,16 @@ export function useConversationStream({
     // which is the same conversation; any other change is a different one.
     const was = conversationRef.current;
     conversationRef.current = conversationId;
-    if (was !== undefined && was !== conversationId) hostOutcomesRef.current.clear();
-  }, [conversationId]);
+    if (was !== undefined && was !== conversationId) {
+      hostOutcomesRef.current.clear();
+      // The reply still streaming belongs to the thread that was left: cut it, drop what it had
+      // batched (it would land on this thread's last message) and let the screen be idle.
+      abortControllerRef.current?.abort();
+      abortControllerRef.current = null;
+      dropPendingUpdates();
+      setIsLoading(false);
+    }
+  }, [conversationId, dropPendingUpdates]);
 
   /**
    * A different account is a different person: the thread on screen is not
@@ -601,15 +615,22 @@ export function useConversationStream({
       /** The request's own controller: `finally` asks it whether the person stopped the turn. */
       let controller: AbortController | null = null;
       let linked: ReturnType<typeof oxyServices.createLinkedClient> | null = null;
+      /** Cut THIS turn's stream. Never the ref's: by now it may hold a later turn's controller. */
+      const abortThisTurn = (): void => {
+        controller?.abort();
+        if (abortControllerRef.current === controller) abortControllerRef.current = null;
+      };
 
       try {
-        // Collect device info (will be available to AI via tool if needed)
-        const deviceInfo = host.deviceInfo ? await host.deviceInfo() : undefined;
-
-        // Create abort controller for this request
+        // Create the abort controller before the first await, so `stop()` and an account or
+        // conversation change reach a turn that is still collecting device info.
         controller = new AbortController();
         abortControllerRef.current = controller;
 
+        // Collect device info (will be available to AI via tool if needed)
+        const deviceInfo = host.deviceInfo ? await host.deviceInfo() : undefined;
+        if (controller.signal.aborted) return 'aborted';
+
         /**
          * Read at send time rather than closed over: the capability switches
          * live in a menu that stays open across a send, and a value captured
@@ -660,21 +681,7 @@ export function useConversationStream({
         });
 
         if (!response.ok) {
-          let errorData: StreamErrorResponse | null = null;
-          try {
-            // A streaming fetch is body-oriented; .json() may not work for error responses.
-            // Read the body manually via the ReadableStream reader.
-            if (response.body) {
-              const errReader = response.body.getReader();
-              const { value } = await errReader.read();
-              if (value) {
-                errorData = JSON.parse(new TextDecoder().decode(value));
-              }
-            }
-          } catch {
-            // Best-effort: if the error body isn't readable/JSON, fall through to
-            // the generic status-based error message below.
-          }
+          const errorData = (await readErrorResponseBody(response)) as StreamErrorResponse | null;
 
           // An agent's feature gate refused the turn: the host shows its own upsell, and the
           // person's words go back to the composer for after.
@@ -734,14 +741,18 @@ export function useConversationStream({
           // own line, with code and reference — never the server's English.
           const failed =
             errorData?.error && typeof errorData.error === 'object' ? errorData.error : null;
-          if (failed && typeof failed.reference === 'string') {
+          if (
+            failed &&
+            (typeof failed.reference === 'string' ||
+              (response.status >= 500 && typeof failed.code === 'string'))
+          ) {
             setError(new Error(getErrorMessage(failed) || `Server error (${response.status})`));
             setIsLoading(false);
             return keepFailedTurn(
               failed.retryable !== false,
               failureDetail({
                 code: typeof failed.code === 'string' ? failed.code : undefined,
-                reference: failed.reference,
+                reference: typeof failed.reference === 'string' ? failed.reference : undefined,
               }),
             );
           }
@@ -790,6 +801,8 @@ export function useConversationStream({
          */
         const sse = createSseFrameReader();
         let lastOutputAt = 0;
+        /** The server closed the turn: `[DONE]`, or a chunk that carries a finish reason. */
+        let sawTerminal = false;
 
         while (true) {
           const { done, value } = await reader.read();
@@ -808,6 +821,13 @@ export function useConversationStream({
               setError(new Error('No response received from AI'));
               return keepFailedTurn(true);
             }
+            // The connection closed before the server said the turn was over:
+            // what is on screen is a cut-off answer, not a finished one. Kept
+            // as an interrupted tail with Retry, never settled as complete.
+            if (!sawTerminal) {
+              setError(new Error('The response ended before it was complete'));
+              return keepFailedTurn(true);
+            }
             break;
           }
 
@@ -821,6 +841,7 @@ export function useConversationStream({
 
             // Skip [DONE] marker
             if (data === '[DONE]') {
+              sawTerminal = true;
               continue;
             }
 
@@ -1021,9 +1042,8 @@ export function useConversationStream({
                 const lockedFeature = lockedFeatureOf(err);
                 if (lockedFeature !== null) {
                   setIsLoading(false);
-                  abortControllerRef.current?.abort();
-                  abortControllerRef.current = null;
-                  reader.cancel();
+                  abortThisTurn();
+                  reader.cancel().catch(() => {});
                   host.onFeatureLocked?.(lockedFeature);
                   return settleError();
                 }
@@ -1068,11 +1088,8 @@ export function useConversationStream({
                 const msg = getErrorMessage(err) || 'Something went wrong. Please try again.';
                 setError(new Error(msg));
                 setIsLoading(false);
-                if (abortControllerRef.current) {
-                  abortControllerRef.current.abort();
-                  abortControllerRef.current = null;
-                }
-                reader.cancel();
+                abortThisTurn();
+                reader.cancel().catch(() => {});
                 // A turn that failed after it started carries a run reference:
                 // its card says code and reference, never the server's English
                 // prose. A refusal without one (a gate, a bad request) keeps its
@@ -1102,6 +1119,7 @@ export function useConversationStream({
               // Handle OpenAI-compatible format
               const choice = parsed.choices?.[0];
               if (!choice) continue;
+              if (choice.finish_reason) sawTerminal = true;
 
               const delta = choice.delta;
               if (!delta) continue;
@@ -1239,13 +1257,10 @@ export function useConversationStream({
                 setIsLoading(false);
 
                 // Abort the stream
-                if (abortControllerRef.current) {
-                  abortControllerRef.current.abort();
-                  abortControllerRef.current = null;
-                }
+                abortThisTurn();
 
                 // Break out of the streaming loop
-                reader.cancel();
+                reader.cancel().catch(() => {});
                 return keepFailedTurn(true, errMsg);
               }
             } catch (frameError: unknown) {
@@ -1342,13 +1357,17 @@ export function useConversationStream({
           clearTimeout(flushTimerRef.current);
           flushTimerRef.current = null;
         }
-        abortControllerRef.current = null;
+        // Only the turn that still owns the ref clears it and the loading flag: after Stop and a new
+        // send, this `finally` belongs to the old turn and must not idle the new one.
+        const ownsTurn =
+          abortControllerRef.current === null || abortControllerRef.current === controller;
+        if (abortControllerRef.current === controller) abortControllerRef.current = null;
         linked?.dispose();
         // A turn that is still streaming here ended without an error path
         // settling it: on its own, or because `stop()` aborted the controller.
         // (The error paths abort it too, but they have settled it first.)
         settleAssistant(controller?.signal.aborted === true ? 'cancelled' : 'completed');
-        setIsLoading(false);
+        if (ownsTurn) setIsLoading(false);
         /*
          * The answer replaces your own line in the sidebar — once per turn rather
          * than once per token. Read from what this turn received, not from the

package/src/runtime/use-conversation-thread.ts

@@ -375,6 +375,9 @@ export function useConversationThread({
       const draft = useComposerDraftStore.getState().address(conversationId ?? null);
       const original = messages.find((msg) => msg.id === messageId);
       if (original === undefined) return false;
+      // Like a send: while a reply streams, truncating the thread under it would let the old
+      // stream keep writing into the new turn. The composer gets the words back.
+      if (isLoading) return false;
       // A string edit keeps the original turn's attachments; only a full parts
       // array replaces them. See `EditedContent`.
       let content = mergeEditedContent(original.content, newContent);
@@ -423,7 +426,7 @@ export function useConversationThread({
       releaseAttachments(attachments ?? []);
       return true;
     },
-    [setMessages, append, messages, conversationId, host, labels, upload],
+    [setMessages, append, messages, conversationId, host, labels, upload, isLoading],
   );
 
   /** The user turn a reply answers: the nearest one before it, or `undefined`. */