@alia.onl/sdk 21.5.0 → 21.5.2

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @alia.onl/sdk
 
+## 21.5.2
+
+### Fixed
+
+- Welcome and conversation sheets grow and shrink with their content up to Bloom’s
+  available-height limit, instead of filling the entire frame. Bloom owns the Screen
+  sizing, scrolling, keyboard clearance and safe areas.
+- The empty thread no longer adds composer clearance a second time. Growing and
+  shrinking a draft now changes the sheet height by the composer’s actual change.
+
+### Changed
+
+- The Bloom peer is `>=15.10.1 <16.0.0`, which provides intrinsic Screen sizing
+  inside content-sized sheets and clips decorative chat backgrounds.
+
+## 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

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 use Bloom's default content sizing: they grow and
+shrink with the chat up to the shared viewport limit. Bloom coordinates the Screen
+content, safe areas and keyboard clearance. 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.5.0",
+  "version": "21.5.2",
   "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,7 +54,7 @@
     "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.1 <16.0.0",
     "@oxy.so/core": ">=3.0.0",
     "@oxy.so/services": ">=12.1.0",
     "@tanstack/react-query": "^5.101",

package/src/components/thread/AliaThread.tsx

@@ -1,9 +1,5 @@
 import { AgentThinking } from '@oxy.so/bloom/agent-thinking';
-import {
-  AiChatThread,
-  type AiChatThreadHandle,
-  useAiChatChromeInsets,
-} from '@oxy.so/bloom/ai-chat';
+import { AiChatThread, type AiChatThreadHandle } from '@oxy.so/bloom/ai-chat';
 import { ChatDateHeader } from '@oxy.so/bloom/chat-screen';
 import { Divider } from '@oxy.so/bloom/divider';
 import { Loading } from '@oxy.so/bloom/loading';
@@ -263,16 +259,12 @@ export const AliaThread = memo(function AliaThread({
     onScroll,
   });
 
-  const chromeInsets = useAiChatChromeInsets();
   const nothingToShow =
     rows.length === 0 && !conversationLoading && !isLoading && !loadingHistory && !voiceThinking;
   if (nothingToShow) {
     return (
-      // Above the floating composer: the container measures it for us.
-      <View
-        className="flex-1 justify-center px-4"
-        style={{ paddingBottom: chromeInsets?.bottom ?? 0 }}
-      >
+      // Screen reserves the composer; the empty state only owns its alignment.
+      <View className="flex-1 justify-center px-4">
         <View className="w-full max-w-[768px] self-center">{empty}</View>
       </View>
     );

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`. */