@belonguniverseai/react-sdk 0.4.1 → 0.4.3

package/dist/stream/stream-state-store.d.ts

@@ -92,6 +92,62 @@ export declare const clearStreamState: (workspaceId?: string | null) => void;
  * message overwrites the cursor via {@link writeStreamState}.
  */
 export declare const readResumableStreamState: (workspaceId?: string | null) => PersistedStreamState | null;
+/**
+ * Was a run still in flight for `sessionId` when this page last looked — the
+ * ONE query behind "a reload must not lie about a backgrounded agent"
+ * (BEL-90 / §41). The parked-cursor map already carries exactly this truth
+ * for every session this tab drove: it lives in `sessionStorage`, so it
+ * survives a genuine reload and is correctly absent in a brand-new tab, which
+ * owns no reader for the run.
+ *
+ * Gated on the same {@link RESUME_MAX_AGE_MS} window {@link setActiveSessionId}
+ * and {@link readResumableStreamState} use, so a run abandoned by a worker
+ * restart ages out into `null` instead of pinning a badge at "working"
+ * forever. Non-throwing and null-returning like its neighbours.
+ *
+ * That gate is only honest while SOMETHING re-stamps the cursor for a live but
+ * silent run — see {@link touchParkedRun}. The transport does it from its
+ * `: keepalive` handler; a reader that adopts a run WITHOUT a transport (the
+ * boot re-attach in `line-dispatch.ts`) must do it too, or a genuinely
+ * streaming run reads "idle" on the next reload.
+ *
+ * NOTE the boundary this does NOT cover: a line's DURABLE slot runId
+ * (`line-slots.ts`) is written by voice dispatch and is not consulted here,
+ * so a slot runId left behind by a reader torn down mid-flight
+ * (`abortAllLineReaders`) bypasses this freshness gate entirely — that path is
+ * `resetForCallStart`'s to clean up, not this one's.
+ */
+export declare const peekLiveParkedRun: (sessionId: string) => string | null;
+/**
+ * Prove `runId` is still alive: re-stamp `sessionId`'s parked cursor's
+ * `updatedAt` so the {@link RESUME_MAX_AGE_MS} gate in
+ * {@link peekLiveParkedRun} keeps returning it (BEL-90 / §41).
+ *
+ * This is the SAME job the transport's `onKeepalive` → `#persist()` does, made
+ * callable by the one reader that has no transport behind it: after a reload
+ * `line-dispatch.ts`'s progress reader is the only listener on a backgrounded
+ * typed run's stream, so without this a run doing 2 minutes of silent tool work
+ * ages out of the cursor map and the next reload paints its chip "idle" while
+ * it is still streaming.
+ *
+ * Deliberately touches ONLY the parked map, never the selected pointer: the
+ * caller attaches exclusively to sessions that are NOT on screen, and moving
+ * the selection would hijack the user's chat. No-op unless the cursor still
+ * names `runId` — a cursor that moved on belongs to a newer run, and the
+ * caller has no claim on it.
+ */
+export declare const touchParkedRun: (sessionId: string, runId: string) => void;
+/**
+ * `runId` reached a terminal state — drop `sessionId`'s parked cursor so
+ * nothing rehydrates the line as "working" for a run that is already done
+ * (BEL-90 / §41, the mirror of {@link touchParkedRun}).
+ *
+ * The transport gets this for free from `onStreamTerminal` → `#persist()` with
+ * a null `#runId`; the progress reader has no transport, so it calls this. Same
+ * ownership guard: a cursor naming a DIFFERENT run is someone else's live run
+ * and is left alone.
+ */
+export declare const releaseParkedRun: (sessionId: string, runId: string) => void;
 /**
  * Select one Session (sessions menu switch / new). A Session with a live cursor
  * parked by this tab restores that cursor so the next ChatRoute mount resumes

package/dist/stream/tool-error-copy.d.ts

@@ -0,0 +1,4 @@
+import { TFunction } from 'i18next';
+import { ToolCallData } from './belong-data-parts.ts';
+/** Localised copy for a tool error, or the server's message when unmapped. */
+export declare const toolErrorText: (t: TFunction, error: ToolCallData["error"]) => string | undefined;

package/dist/test/fetch-stubs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared fetch-stub bodies for the preview surfaces.
+ *
+ * `usePreviewBytes` reads a text preview as BYTES (`res.arrayBuffer()`) rather
+ * than `res.text()`, so it can fall back to windows-1252 when a file isn't
+ * valid UTF-8 — a stub that only implements `text()` therefore no longer models
+ * a Response the hook can consume. `textResponseStub` implements both, so a
+ * test can stay agnostic about which one the code under test reaches for.
+ */
+export type TextResponseStub = {
+    readonly ok: true;
+    readonly status: 200;
+    readonly text: () => Promise<string>;
+    readonly arrayBuffer: () => Promise<ArrayBuffer>;
+};
+export declare const textResponseStub: (text: string) => TextResponseStub;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@belonguniverseai/react-sdk",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Belong — embeddable React AI assistant dock. Mount <BelongWidget> in your app tree with getToken dependency-injection auth.",
   "license": "UNLICENSED",
   "type": "module",