@opengeni/react 4.2.1-canary.39642758903001 → 4.3.1

package/src/hooks/use-session-events.ts

@@ -1,5 +1,6 @@
 import {
   isPresentedSessionToolName,
+  isRetryableStreamError,
   isSessionModelResponsePhase,
   SESSION_EVENT_COMPAT_EXCLUDED_STEP_TYPES,
   SESSION_EVENT_CONTENT_STEP_TYPES,
@@ -22,6 +23,7 @@ import type { EmbeddedSessionClientLike } from "../client";
 import { normalizeError } from "../lib/error-message";
 import { joinSessionDetailRead, sessionDetailReadMark } from "../lib/session-detail-read";
 import { usePageLiveActivity } from "./internal";
+import { subscribePageWake } from "./page-wake";
 import { deniesRetainedView, useRetainedSessionView } from "./session-view-cache";
 import { markTurnlessOutputGap } from "./turnless-output-gaps";
 import type { LatestQuestionOptions } from "./latest-question";
@@ -130,12 +132,22 @@ const BOUNDARY_PAGE_CAP = 1;
 // The first window keeps the plain caps, so opening a chat stays one read.
 const FILTERED_PAGE_CAP = 32;
 // Rejoining the live tip (first open of a working turn, a return to a hidden
-// tab, catching up from history) replays a tiny raw gap over SSE. A larger gap
-// catches up the conversation only and reads the working turn's latest steps,
-// instead of replaying every step since the last conversation event. Only a
-// gap of more than this many pages of conversation reloads the latest window.
+// tab or from a sleep, any stream reconnect, catching up from history)
+// replays a tiny raw gap over SSE. A larger gap catches up the conversation
+// only and reads the working turn's latest steps, instead of replaying every
+// step since the last conversation event. Only a gap of more than this many
+// pages of conversation reloads the latest window.
 const DIRECT_REPLAY_MAX_SEQUENCES = 16;
 const CATCHUP_MAX_PAGES = 2;
+// Rejoining the tip after a reconnect or a wake is bounded: an attempt that
+// completes no read for REJOIN_STALL_TIMEOUT_MS is abandoned (a slow but
+// progressing catch-up is never cut short), a transient failure retries (with
+// backoff) only this many times in a row, and after that the stream replays
+// exactly from where the view stands rather than staying stuck "reconnecting".
+const STRICT_REJOIN_ATTEMPTS = 5;
+export const REJOIN_STALL_TIMEOUT_MS = 30_000;
+const FOREGROUND_REJOIN_RETRY_MS = 500;
+const FOREGROUND_REJOIN_RETRY_MAX_MS = 8_000;
 const EMPTY_EVENTS: SessionEvent[] = [];
 const encoder = new TextEncoder();
 // Durable history remains on the server and is available through bounded
@@ -827,52 +839,68 @@ export function useSessionEvents(
      * append (the caller then loads the latest window).
      */
     // The durable head: the conversation's fresh detail read when one started
-    // since this stream began loading (the session view's own), else a new one.
-    const readSessionHead = async () => {
-      const joined = joinSessionDetailRead(client, workspaceId, sessionId, detailReadMark);
+    // since `mark` (the session view's own), else a new one.
+    const effectScope: RejoinScope = { signal: controller.signal, isCurrent };
+    const readSessionHead = async (mark: number, scope: RejoinScope) => {
+      const joined = joinSessionDetailRead(client, workspaceId, sessionId, mark);
       if (joined) {
         try {
           return await joined;
         } catch (cause) {
-          if (controller.signal.aborted) throw cause;
+          if (scope.signal.aborted) throw cause;
         }
       }
       return await client.getSession(workspaceId, sessionId, {
         fresh: true,
-        signal: controller.signal,
+        signal: scope.signal,
       });
     };
-    const rejoinLive = async (force: boolean): Promise<"joined" | "reload"> => {
+    // `strict` (a stream reconnect) fails on a transient read failure, so the
+    // stream backs off and retries the whole check instead of replaying a
+    // backlog it could not size; any other failed read replays the gap.
+    const rejoinLive = async (
+      force: boolean,
+      {
+        strict = false,
+        mark = detailReadMark,
+        scope = effectScope,
+      }: { strict?: boolean; mark?: number; scope?: RejoinScope } = {},
+    ): Promise<RejoinOutcome> => {
       const activeTurn = activeConversationTurn(eventWindowRef.current.events);
       if (!force && !activeTurn) return "joined";
       const cursor = streamResumeSequenceRef.current;
       let head: number;
       let sessionActiveTurn: string | null = null;
       try {
-        const session = await readSessionHead();
+        const session = await readSessionHead(mark, scope);
+        scope.progress?.();
         head = session.lastSequence;
         sessionActiveTurn = session.activeTurnId;
       } catch (cause) {
-        if (controller.signal.aborted) throw cause;
+        if (!scope.isCurrent() || (strict && isRetryableStreamError(cause))) throw cause;
         // An optimization read: replay from the exact cursor instead.
         return "joined";
       }
-      if (!isCurrent()) throw abortError();
+      if (!scope.isCurrent()) throw abortError();
       // A head the client does not report is unknown: replay from the cursor.
       if (!Number.isSafeInteger(head) || head - cursor <= DIRECT_REPLAY_MAX_SEQUENCES) {
         return "joined";
       }
       let catchup: SessionEvent[] | null;
       try {
-        catchup = await loadConversationCatchup(client, workspaceId, sessionId, cursor, head, {
-          signal: controller.signal,
-          isCurrent,
-        });
+        catchup = await loadConversationCatchup(
+          client,
+          workspaceId,
+          sessionId,
+          cursor,
+          head,
+          scope,
+        );
       } catch (cause) {
-        if (!isCurrent()) throw cause;
+        if (!scope.isCurrent() || (strict && isRetryableStreamError(cause))) throw cause;
         return "joined";
       }
-      if (!isCurrent()) throw abortError();
+      if (!scope.isCurrent()) throw abortError();
       if (catchup === null) return "reload";
       // Continuity broke: steps of turns still working before the catch-up
       // may be missing, so those stores go (the working one is re-read).
@@ -889,13 +917,216 @@ export function useSessionEvents(
       return "joined";
     };
 
+    // Replace the browser window with the newest conversation window. The
+    // previous window stays on screen until the replacement is installed.
+    const loadLatestWindow = async (scope: RejoinScope = effectScope): Promise<boolean> => {
+      // First paint is ONE compact fetch of the conversation — the newest
+      // window, revealed at the bottom in a few hundred ms. Deeper history
+      // loads only when the reader scrolls up (the sentinel drives
+      // loadOlder); a turn's steps load when the reader opens it.
+      const window = await loadEventWindow(t, client, workspaceId, sessionId, {
+        before: Number.MAX_SAFE_INTEGER,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
+        targetGroups: Number.POSITIVE_INFINITY,
+        maxFetches: INITIAL_FETCH_CAP,
+        boundaryPageCap: BOUNDARY_PAGE_CAP,
+        signal: scope.signal,
+        ...(scope.progress ? { progress: scope.progress } : {}),
+        filter: CONVERSATION_FILTER,
+      });
+      if (!scope.isCurrent()) {
+        return false;
+      }
+      const status = observeSessionStatus(window.events, sessionStatusRef);
+      const retained = boundBrowserSessionEventWindow(window.events);
+      // A replacement tail retires requests against the discarded window.
+      // Ordinary SSE reconnects preserve navigation, but splicing an old
+      // page into this new tail could leave an inaccessible history gap.
+      navigationGenerationRef.current += 1;
+      loadingOlderRef.current = false;
+      loadingNewerRef.current = false;
+      loadingOldestRef.current = false;
+      setLoadingOlder(false);
+      setLoadingNewer(false);
+      setLoadingOldest(false);
+      const previous = eventWindowRef.current.events;
+      eventWindowRef.current = retained;
+      pruneStepStores(retained.events, previous);
+      oldestSequenceRef.current =
+        retained.events[0]?.sequence ?? window.oldestSequence ?? window.scanCursor;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? window.newestSequence;
+      hasOlderRef.current = window.hasOlder || retained.truncated;
+      hasNewerRef.current = false;
+      lastSequenceRef.current = Math.max(lastSequenceRef.current, window.newestSequence);
+      streamResumeSequenceRef.current = window.newestSequence;
+      skippedStepsThroughRef.current =
+        retained.events.length === 0 && window.newestSequence > 0 ? window.newestSequence : null;
+      initialWindowLoadedRef.current = true;
+      setInitialHistoryReady(true);
+      setError(null);
+      if (status !== undefined) {
+        setSessionStatusProjection(status);
+      }
+      setEventWindow(retained);
+      setHasOlder(window.hasOlder || retained.truncated);
+      setHasNewer(false);
+      setInitialLoading(false);
+      return true;
+    };
+
+    // The stream starts past what it last delivered: a window load,
+    // catch-up, page or jump moved the cursor with conversation reads, which
+    // carry no terminal output, so the sandbox terminal reads it again.
+    const noteStreamResume = () => {
+      if (!fullReplay && streamResumeSequenceRef.current > liveThroughRef.current) {
+        markTurnlessOutputGap(workspaceId, sessionId);
+      }
+      liveThroughRef.current = Math.max(liveThroughRef.current, streamResumeSequenceRef.current);
+    };
+
+    // One bounded rejoin attempt: it is abandoned once no read completes for
+    // REJOIN_STALL_TIMEOUT_MS, and a late result is fenced out of the view
+    // (reads without a signal can only be outwaited). A `strict` attempt
+    // that failed transiently or stalled resolves the cause so the caller
+    // retries; a lenient one that stalled resolves "joined", which replays
+    // exactly from where the view stands. Read failures are translated where
+    // they happen, so anything else is a bug applying the result: it throws
+    // rather than passing for a rejoin.
+    const boundedRejoin = async (
+      strict: boolean,
+      join: (scope: RejoinScope) => Promise<RejoinOutcome>,
+    ): Promise<RejoinOutcome | { retry: unknown }> => {
+      if (!isCurrent()) throw abortError();
+      const attempt = new AbortController();
+      let timedOut = false;
+      const abortAttempt = () => attempt.abort();
+      controller.signal.addEventListener("abort", abortAttempt, { once: true });
+      const stalled = () => {
+        timedOut = true;
+        attempt.abort();
+      };
+      let timer = setTimeout(stalled, REJOIN_STALL_TIMEOUT_MS);
+      let stopWaiting: (() => void) | undefined;
+      const stopped = new Promise<never>((_resolve, reject) => {
+        stopWaiting = () => reject(abortError());
+        attempt.signal.addEventListener("abort", stopWaiting, { once: true });
+      });
+      const scope: RejoinScope = {
+        signal: attempt.signal,
+        isCurrent: () => isCurrent() && !attempt.signal.aborted,
+        progress: () => {
+          if (attempt.signal.aborted) return;
+          clearTimeout(timer);
+          timer = setTimeout(stalled, REJOIN_STALL_TIMEOUT_MS);
+        },
+      };
+      try {
+        return await Promise.race([join(scope), stopped]);
+      } catch (cause) {
+        if (!isCurrent()) throw cause;
+        if (timedOut) {
+          return strict
+            ? {
+                retry: new TypeError(
+                  `rejoining the live session stalled for ${REJOIN_STALL_TIMEOUT_MS}ms`,
+                ),
+              }
+            : "joined";
+        }
+        if (strict && isRetryableStreamError(cause)) return { retry: cause };
+        throw cause;
+      } finally {
+        clearTimeout(timer);
+        controller.signal.removeEventListener("abort", abortAttempt);
+        if (stopWaiting) attempt.signal.removeEventListener("abort", stopWaiting);
+      }
+    };
+    // A bounded rejoin whose failure replays exactly (the first open after
+    // a window load, or a return from history: their gaps are short).
+    const leniently = async (
+      join: (scope: RejoinScope) => Promise<RejoinOutcome>,
+    ): Promise<RejoinOutcome> => {
+      const result = await boundedRejoin(false, join);
+      return typeof result === "string" ? result : "joined";
+    };
+
+    // Every reconnect after the stream first opened (a dropped connection, a
+    // heartbeat timeout, a sleep) joins the tip like a hidden-tab return: a
+    // short gap replays over SSE, a long one is caught up or reloaded instead
+    // of being poured through the live stream. A transient failure makes the
+    // SDK back off and call this again, at most STRICT_REJOIN_ATTEMPTS times
+    // in a row (until a connection opens); after that the reconnect replays
+    // exactly rather than staying stuck.
+    let strictFailures = 0;
+    const beforeReconnect = async (cursor: number): Promise<number> => {
+      // Deliver what the broken connection already yielded first.
+      flush();
+      if (!isCurrent()) throw abortError();
+      const strict = strictFailures < STRICT_REJOIN_ATTEMPTS;
+      const mark = sessionDetailReadMark();
+      let result: RejoinOutcome | { retry: unknown };
+      try {
+        result = await boundedRejoin(strict, async (scope) => {
+          if ((await rejoinLive(true, { strict, mark, scope })) === "joined") return "joined";
+          let loaded: boolean;
+          try {
+            loaded = await loadLatestWindow(scope);
+          } catch (cause) {
+            if (!scope.isCurrent() || (strict && isRetryableStreamError(cause))) throw cause;
+            // A window that cannot be read: replay exactly instead.
+            return "joined";
+          }
+          if (!loaded) throw abortError();
+          // The fresh window's own gap is short: join its head the same way.
+          if ((await rejoinLive(true, { strict, mark, scope })) === "reload" && strict) {
+            throw new TypeError("the session outran a fresh window while rejoining it");
+          }
+          return "joined";
+        });
+      } catch (cause) {
+        if (!isCurrent()) throw abortError();
+        // Not a read failure: end the stream visibly instead of letting the
+        // SDK retry it forever.
+        if (!isRetryableStreamError(cause)) throw cause;
+        throw new Error(
+          `rejoining the live session failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          { cause },
+        );
+      }
+      if (!isCurrent()) throw abortError();
+      if (typeof result === "object") {
+        strictFailures += 1;
+        throw result.retry;
+      }
+      noteStreamResume();
+      return Math.max(cursor, streamResumeSequenceRef.current);
+    };
+
     void (async () => {
       try {
         if (reconcileForegroundResume) {
           setConnectionState("connecting");
           // A short gap replays over SSE into the loaded steps; a longer one
           // drops the steps of turns that were working and re-reads the tail.
-          if ((await rejoinLive(true)) === "reload") {
+          // A transient failure (the network often returns just after a wake)
+          // retries with backoff instead of replaying the backlog it could
+          // not size; only after that does the stream replay exactly.
+          let outcome: RejoinOutcome;
+          for (let attempt = 0; ; attempt += 1) {
+            const strict = attempt < STRICT_REJOIN_ATTEMPTS;
+            const result = await boundedRejoin(strict, (scope) =>
+              rejoinLive(true, { strict, scope }),
+            );
+            if (typeof result === "string") {
+              outcome = result;
+              break;
+            }
+            await abortableDelay(
+              Math.min(FOREGROUND_REJOIN_RETRY_MS * 2 ** attempt, FOREGROUND_REJOIN_RETRY_MAX_MS),
+              controller.signal,
+            );
+          }
+          if (outcome === "reload") {
             // Keep the last known window visible until the bounded latest
             // replacement is ready, then install that replacement below.
             initialWindowLoadedRef.current = false;
@@ -903,7 +1134,7 @@ export function useSessionEvents(
           }
         } else if (!fullReplay && initialWindowLoadedRef.current && rejoinPendingRef.current) {
           rejoinPendingRef.current = false;
-          if ((await rejoinLive(false)) === "reload") {
+          if ((await leniently((scope) => rejoinLive(false, { scope }))) === "reload") {
             initialWindowLoadedRef.current = false;
           }
         }
@@ -917,80 +1148,29 @@ export function useSessionEvents(
           attempt += 1
         ) {
           setConnectionState("connecting");
-          // First paint is ONE compact fetch of the conversation — the newest
-          // window, revealed at the bottom in a few hundred ms. Deeper history
-          // loads only when the reader scrolls up (the sentinel drives
-          // loadOlder); a turn's steps load when the reader opens it.
-          const window = await loadEventWindow(t, client, workspaceId, sessionId, {
-            before: Number.MAX_SAFE_INTEGER,
-            pageSize: SESSION_HISTORY_PAGE_SIZE,
-            targetGroups: Number.POSITIVE_INFINITY,
-            maxFetches: INITIAL_FETCH_CAP,
-            boundaryPageCap: BOUNDARY_PAGE_CAP,
-            signal: controller.signal,
-            filter: CONVERSATION_FILTER,
-          });
-          if (!isCurrent()) {
+          if (!(await loadLatestWindow())) {
             return;
           }
-          const status = observeSessionStatus(window.events, sessionStatusRef);
-          const retained = boundBrowserSessionEventWindow(window.events);
-          // A replacement tail retires requests against the discarded window.
-          // Ordinary SSE reconnects preserve navigation, but splicing an old
-          // page into this new tail could leave an inaccessible history gap.
-          navigationGenerationRef.current += 1;
-          loadingOlderRef.current = false;
-          loadingNewerRef.current = false;
-          loadingOldestRef.current = false;
-          setLoadingOlder(false);
-          setLoadingNewer(false);
-          setLoadingOldest(false);
-          const previous = eventWindowRef.current.events;
-          eventWindowRef.current = retained;
-          pruneStepStores(retained.events, previous);
-          oldestSequenceRef.current =
-            retained.events[0]?.sequence ?? window.oldestSequence ?? window.scanCursor;
-          newestSequenceRef.current =
-            maxResumeSequenceOrNull(retained.events) ?? window.newestSequence;
-          hasOlderRef.current = window.hasOlder || retained.truncated;
-          hasNewerRef.current = false;
-          lastSequenceRef.current = Math.max(lastSequenceRef.current, window.newestSequence);
-          streamResumeSequenceRef.current = window.newestSequence;
-          skippedStepsThroughRef.current =
-            retained.events.length === 0 && window.newestSequence > 0
-              ? window.newestSequence
-              : null;
-          initialWindowLoadedRef.current = true;
-          setInitialHistoryReady(true);
-          setError(null);
-          if (status !== undefined) {
-            setSessionStatusProjection(status);
-          }
-          setEventWindow(retained);
-          setHasOlder(window.hasOlder || retained.truncated);
-          setHasNewer(false);
-          setInitialLoading(false);
           // Join at the durable head rather than replaying every row since the
           // window's last conversation event: a working turn's steps (its
           // latest are read), or terminal output written after the last turn,
           // which only the sandbox dock reads.
-          if ((await rejoinLive(true)) === "reload" && attempt === 0) {
+          if (
+            (await leniently((scope) => rejoinLive(true, { scope }))) === "reload" &&
+            attempt === 0
+          ) {
             initialWindowLoadedRef.current = false;
           }
         }
         if (fullReplay) {
           setInitialLoading(false);
         }
-        // The stream starts past what it last delivered: a window load,
-        // catch-up, page or jump moved the cursor with conversation reads, which
-        // carry no terminal output, so the sandbox terminal reads it again.
-        if (!fullReplay && streamResumeSequenceRef.current > liveThroughRef.current) {
-          markTurnlessOutputGap(workspaceId, sessionId);
-        }
-        liveThroughRef.current = Math.max(liveThroughRef.current, streamResumeSequenceRef.current);
+        noteStreamResume();
         const stream = client.streamEvents(workspaceId, sessionId, {
           after: streamResumeSequenceRef.current,
           signal: controller.signal,
+          // Full replay keeps the SDK's exactly-once reconnects.
+          ...(fullReplay ? {} : { beforeReconnect }),
           onOpen: () => {
             // The first open after this mount's initial tail: every read hook
             // read its projection alongside that tail, and the shared feed
@@ -998,6 +1178,7 @@ export function useSessionEvents(
             // foreground resumes) repair every projection.
             const initialOpen = openedStreamKeyRef.current !== streamKey;
             openedStreamKeyRef.current = streamKey;
+            strictFailures = 0;
             // Reconciliation repairs projections, but it must not block reading
             // the already-open SSE body. Otherwise live events accumulate in the
             // browser and appear as one delayed burst after every reconciler ends.
@@ -1088,6 +1269,22 @@ export function useSessionEvents(
     startupTurns,
   ]);
 
+  // A sleep, frozen tab or lost network usually killed the stream without the
+  // page ever going hidden. Rejoin at once, like a hidden-tab return, instead
+  // of waiting for the heartbeat timeout and then replaying the backlog.
+  useEffect(() => {
+    if (!sessionId || !streamEnabled) return;
+    return subscribePageWake(() => {
+      const stream = streamAbortRef.current;
+      // History views and paused streams have no live connection to restore.
+      if (!stream || stream.signal.aborted || viewModeRef.current !== "live") return;
+      if (!fullReplay && initialWindowLoadedRef.current) {
+        reconcileAfterPageResumeRef.current = true;
+      }
+      setStreamEpoch((epoch) => epoch + 1);
+    });
+  }, [sessionId, streamEnabled, fullReplay]);
+
   const navigationBusy = (): boolean =>
     loadingTargetRef.current ||
     loadingOlderRef.current ||
@@ -1988,7 +2185,7 @@ async function loadConversationCatchup(
   sessionId: string,
   cursor: number,
   head: number,
-  options: { signal?: AbortSignal; isCurrent: () => boolean },
+  options: { signal?: AbortSignal; isCurrent: () => boolean; progress?: () => void },
 ): Promise<SessionEvent[] | null> {
   const events: SessionEvent[] = [];
   let after = cursor;
@@ -2003,6 +2200,7 @@ async function loadConversationCatchup(
       payloadMode: "full",
     });
     if (!options.isCurrent()) throw abortError();
+    options.progress?.();
     const fresh = page.filter((event) => eventResumeSequence(event) > after);
     assertAscending(fresh);
     events.push(...fresh);
@@ -2047,6 +2245,8 @@ async function loadEventWindow(
     filteredPageCap?: number;
     signal?: AbortSignal;
     isCurrent?: () => boolean;
+    /** Called after each completed page read. */
+    progress?: () => void;
     filter?: HistoryFilter | undefined;
   },
 ): Promise<LoadedEventWindow> {
@@ -2073,6 +2273,7 @@ async function loadEventWindow(
       ...(options.signal ? { signal: options.signal } : {}),
     });
     if (options.isCurrent?.() === false) throw abortError();
+    options.progress?.();
     if (page.raw.oldest === null) {
       reachedStart = true;
       break;
@@ -2106,6 +2307,7 @@ async function loadEventWindow(
       ...(options.signal ? { signal: options.signal } : {}),
     });
     if (options.isCurrent?.() === false) throw abortError();
+    options.progress?.();
     if (page.raw.oldest === null) {
       reachedStart = true;
       break;
@@ -2441,6 +2643,32 @@ function abortError(): Error {
   return error;
 }
 
+function abortableDelay(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(abortError());
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+/**
+ * One rejoin attempt's cancellation: its signal, whether it still owns state,
+ * and `progress`, reported after each completed read (it keeps a slow but
+ * progressing attempt from being abandoned as stalled).
+ */
+type RejoinScope = { signal: AbortSignal; isCurrent: () => boolean; progress?: () => void };
+type RejoinOutcome = "joined" | "reload";
+
 /* ----------------------------------------------------------------------------
    Conversation-first history
 

package/src/lib/format.ts

@@ -114,8 +114,9 @@ export function tryParseJson(text: string): unknown {
 
 /**
  * The canonical credit-death sentence. Credit exhaustion is the one failure a
- * user can fix themselves — the copy must say what happened (no usable credit for this model),
- * what to do (add credits), and what is safe (nothing was lost). Crucially it
+ * user can fix themselves — the copy must say what happened (the remaining
+ * credit does not cover this model, though it may cover others), what to do
+ * (choose a covered model or add credits), and what is safe (nothing was lost). Crucially it
  * must NOT say "send a message to revive": a revive turn burns credits the
  * workspace no longer has.
  */

package/src/messages/en.ts

@@ -1303,7 +1303,7 @@ export const englishMessages = {
     "This chat's model is no longer available. Choose another model to continue. Your message is saved.",
   "lib.format.now": "now",
   "lib.format.outOfCreditsThisWorkspace":
-    "Out of credits for this model. Add credits to continue; the conversation is preserved.",
+    "Your remaining credits don't cover this model. Choose a model they cover or add credits. The conversation is preserved.",
   "lib.format.providerBlockedRequest": "The model provider blocked this request.",
   "lib.format.providerBlockedRequestDetail": "The model provider blocked this request. {detail}",
   "lib.format.reconcileBeforeRetry":
@@ -1331,7 +1331,7 @@ export const englishMessages = {
   "lib.format.workspaceUsageLimitReachedAn":
     "Workspace usage limit reached. An organization admin can raise the workspace budget. Your draft is preserved.",
   "lib.format.yourOrganizationDoesnTHave":
-    "Your organization doesn't have enough credits to send this message. Add credits or choose a model with another payment source. Your message and attachments are saved.",
+    "Your remaining credits don't cover this model. Choose a model they cover or add credits. Your message and attachments are saved.",
   "lib.providerRecovery.anImageFromEarlierIn":
     "An image from earlier in this conversation can't be read from storage",
   "lib.providerRecovery.opengeniToolServiceUnavailable":
@@ -1795,6 +1795,9 @@ export const englishMessages = {
     "Billed to the organization Anthropic API account",
   "modelPolicy.billedToTheOrganizationOpenrouter": "Billed to the organization OpenRouter account",
   "modelPolicy.billedToTheOrganizationOpper": "Billed to the organization Opper account",
+  "modelPolicy.billedToTheOrganizationOpenai": "Billed to the organization OpenAI API account",
+  "modelPolicy.billedToTheOrganizationAzureOpenai":
+    "Billed to the organization Azure OpenAI account",
   "modelPolicy.billedToTheOrganizationProvider": "Billed to the organization provider account",
   "modelPolicy.billedToTheOrganizationVercel": "Billed to the organization Vercel account",
   "modelPolicy.billedToTheWorkspaceAnthropic": "Billed to the workspace Anthropic API account",
@@ -1822,7 +1825,7 @@ export const englishMessages = {
   "modelPolicy.freeCredits": "Free credits",
   "modelPolicy.freeInThisDeployment": "Free in this deployment",
   "modelPolicy.models": "Models",
-  "modelPolicy.needsCredits": "Needs credits",
+  "modelPolicy.needsCredits": "Not covered by your credits",
   "modelPolicy.notEntitled": "Not entitled",
   "modelPolicy.opengeniCredits": "{product} credits",
   "modelPolicy.opengeniCreditsAutomaticManagedRoute": "{product} credits · automatic managed route",
@@ -2002,6 +2005,13 @@ export const englishMessages = {
     "results folded into model context — no list available.",
   "native.timeline.activity.thinking": "Thinking",
   "native.timeline.activity.thought": "Thought",
+  "native.timeline.annotations.done": "Done",
+  "native.timeline.annotations.removeAllTitle_one": "Remove this annotation?",
+  "native.timeline.annotations.removeAllTitle_other": "Remove {count} annotations?",
+  "native.timeline.annotations.removeAllMessage_one": "Your note will be lost.",
+  "native.timeline.annotations.removeAllMessage_other": "Your notes will be lost.",
+  "native.timeline.annotations.removeAllConfirm": "Remove",
+  "native.timeline.annotations.cancel": "Cancel",
   "native.timeline.composer.errorDismiss": "{error} Dismiss",
   "native.timeline.composer.fast": "Fast",
   "native.timeline.composer.ultrafast": "Ultrafast",

package/src/model-picker-model.ts

@@ -130,6 +130,9 @@ export function billingClassForMissingSelection(modelId: string): PickerBillingC
   if (modelId.startsWith("workspace-anthropic/")) return "byok";
   if (modelId.startsWith("organization-claude-subscription/")) return "claude_subscription";
   if (modelId.startsWith("organization-anthropic/")) return "organization_byok";
+  // Every organization OpenAI or Azure OpenAI id is an organization-paid model.
+  if (modelId.startsWith("organization-openai/")) return "organization_byok";
+  if (modelId.startsWith("organization-azure-openai/")) return "organization_byok";
   if (modelId.startsWith("workspace-gateway/")) return "byok";
   if (modelId.startsWith("workspace-openrouter/")) return "byok";
   if (modelId.startsWith("workspace-opper/")) return "byok";

package/src/model-policy.ts

@@ -60,7 +60,9 @@ export function billingClassForModel(model: ClientModel): PickerBillingClass {
   if (
     model.provider === "organization-gateway" ||
     model.provider === "organization-openrouter" ||
-    model.provider === "organization-opper"
+    model.provider === "organization-opper" ||
+    model.provider === "organization-openai" ||
+    model.provider === "organization-azure-openai"
   ) {
     return "organization_byok";
   }
@@ -297,6 +299,12 @@ function organizationProviderPayerSummary(t: OpenGeniText, model: ClientModel):
   if (model.provider === "organization-opper") {
     return t("modelPolicy.billedToTheOrganizationOpper");
   }
+  if (model.provider === "organization-openai") {
+    return t("modelPolicy.billedToTheOrganizationOpenai");
+  }
+  if (model.provider === "organization-azure-openai") {
+    return t("modelPolicy.billedToTheOrganizationAzureOpenai");
+  }
   if (model.provider === "organization-gateway") {
     return t("modelPolicy.billedToTheOrganizationVercel");
   }

package/src/session.ts

@@ -150,6 +150,7 @@ export type {
   TurnEndItem,
   TurnStepsItem,
   TurnStepsState,
+  TimelineAnnotationSourceDescriptor,
   UserMessageItem,
   WorkerCompletionItem,
   WorkerItem,