@belonguniverseai/react-sdk 0.6.0 → 0.6.2

package/dist/stream/message-metadata.d.ts

@@ -1,45 +1,15 @@
 import { z } from 'zod';
 export declare const belongMessageMetadataSchema: z.ZodObject<{
-    /** Producing task of an assistant turn — the reload-stable feedback key. */
     taskId: z.ZodOptional<z.ZodString>;
-    /** The user's current 👍/👎 on that turn; `.nullish()` because the live
-     *  `start` chunk stamps no vote yet while history returns `null` for
-     *  "no vote" (requiring it would hide the thumbs on a fresh turn). */
     feedback: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        sentiment: z.ZodEnum<["up", "down"]>;
+        sentiment: z.ZodEnum<{
+            up: "up";
+            down: "down";
+        }>;
         reason: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        reason: string | null;
-        sentiment: "up" | "down";
-    }, {
-        reason: string | null;
-        sentiment: "up" | "down";
-    }>>>;
-    /** Server row creation time (ISO) — per-bubble clock, history only (§41). */
+    }, z.core.$strip>>>;
     createdAt: z.ZodOptional<z.ZodString>;
-    /** Skill picked for this user message — renders the bubble's skill chip. */
     skill: z.ZodOptional<z.ZodString>;
-    /** Set by `loadSessionHistory` on every restored message. Gates the
-     *  dispatch renderers' auto-fire: absent (live/replayed turn) → fire once;
-     *  true (restored history) → render settled, never re-dispatch. */
     fromHistory: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    createdAt?: string | undefined;
-    taskId?: string | undefined;
-    skill?: string | undefined;
-    feedback?: {
-        reason: string | null;
-        sentiment: "up" | "down";
-    } | null | undefined;
-    fromHistory?: boolean | undefined;
-}, {
-    createdAt?: string | undefined;
-    taskId?: string | undefined;
-    skill?: string | undefined;
-    feedback?: {
-        reason: string | null;
-        sentiment: "up" | "down";
-    } | null | undefined;
-    fromHistory?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type BelongMessageMetadata = z.infer<typeof belongMessageMetadataSchema>;

package/dist/stream/run-line-progress.d.ts

@@ -6,11 +6,12 @@ import { RunStatusKind } from './belong-data-parts.ts';
  * turn that only writes text calls no tools, so `tool_started` never fires and
  * the chip would otherwise sit at "idle" through the whole answer.
  *
- * There is deliberately NO `text` variant. An accumulator feeding
- * `AgentLine.lastText` was specified and dropped: nothing in the dock renders
- * `lastText`, and because this seam no-ops while the session is on screen the
- * accumulator could only ever have collected the post-switch TAIL of an
- * answer. Re-add it when something renders it.
+ * There is deliberately NO `text` variant. An accumulator feeding a per-line
+ * "last result text" field was specified and dropped: nothing in the dock
+ * renders such a field (the registry no longer even carries one), and because
+ * this seam no-ops while the session is on screen the accumulator could only
+ * ever have collected the post-switch TAIL of an answer. Re-add both when
+ * something renders it.
  *
  * `terminal` carries the run's OWN id, and it is not decoration: the durable
  * slot runId this seam clears is shared with the voice dispatch, and a line can

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

@@ -1,34 +1,10 @@
 import { z } from 'zod';
 declare const streamStateSchema: z.ZodObject<{
     sessionId: z.ZodString;
-    /**
-     * Active run id, or null once the run reached a terminal state. The session
-     * pointer outlives the run: it survives on terminal so a reload can still
-     * restore this conversation's history — only the run cursor is dropped so we
-     * never reconnect to a finished run.
-     */
     runId: z.ZodNullable<z.ZodString>;
-    /** `<seq>-0` SSE cursor, or null when no event has been seen yet. */
     lastEventId: z.ZodNullable<z.ZodString>;
-    /**
-     * Epoch ms of the last cursor write. Resume is only attempted for
-     * recently-touched runs (see {@link readResumableStreamState}). State
-     * written by an older SDK build has no `updatedAt`, fails this schema, and
-     * is treated as absent — which is exactly the "start fresh" behavior we
-     * want for stale leftovers from a previous visit.
-     */
     updatedAt: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    updatedAt: number;
-    sessionId: string;
-    runId: string | null;
-    lastEventId: string | null;
-}, {
-    updatedAt: number;
-    sessionId: string;
-    runId: string | null;
-    lastEventId: string | null;
-}>;
+}, z.core.$strip>;
 export type PersistedStreamState = z.infer<typeof streamStateSchema>;
 /** Bump the foreground-mount generation. Call exactly once per ChatRoute
  * remount (BelongDock's `chatMount.key` writers), synchronously alongside

package/dist/stream/tool-action-label.d.ts

@@ -0,0 +1,16 @@
+import { TFunction } from 'i18next';
+export type ToolActionLabel = {
+    readonly key: string;
+};
+/**
+ * The neutral line for a tool this build has never heard of. Exported because
+ * `browserStepMeta` branches on it: an unrecognized `browser_*` suffix keeps
+ * the chat's own sentence-cased fallback instead of this.
+ */
+export declare const GENERIC_ACTION_KEY = "stream.actionGeneric";
+/**
+ * `t(...)` over a `ToolActionLabel` — the ONE way either surface renders one,
+ * so the two can't drift into two different names for the same action.
+ */
+export declare const translateAction: (t: TFunction, action: ToolActionLabel) => string;
+export declare const toolActionLabel: (toolName: string) => ToolActionLabel | null;

package/package.json

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

package/dist/components/embed/PoweredByBelong.d.ts

@@ -1,7 +0,0 @@
-/** Fixed footer height (px) so the terminal overlay can reserve exact space. */
-export declare const POWERED_BY_BELONG_HEIGHT_PX = 28;
-/**
- * Persistent attribution strip pinned to the bottom of the dock panel when a
- * tenant brand is active. Always the Belong mark (not the tenant BrandMark).
- */
-export declare function PoweredByBelong(): import("react").JSX.Element;

package/dist/embed/voice/agent-queue.d.ts

@@ -1,106 +0,0 @@
-/**
- * Per-line FIFO for work an operator asks an agent to do WHILE that agent is
- * already busy — the structure behind "queue two things on Agent 2, then
- * drop one" (Slice 3 of the voice-operator plan). File-scope-singleton
- * idiom, same as `line-slots.ts` / `voice-call-lines.ts` beside it: one
- * module-level `Map<number, QueuedRequest[]>`, no class, no React.
- *
- * WHAT THIS REPLACES: today, sending work to a busy agent POSTs it
- * immediately — the message lands in Postgres and the server's own drain
- * loop (SAD §5.1 / CLAUDE.md §37) gets to it whenever the agent frees up.
- * That queue is invisible (no way to ask "what's waiting for Agent 2?"),
- * unorderable (no way to promote the third ask over the second), and
- * undroppable (no way to take one back). This module is the queue moved
- * into the browser, so a caller can read it back, drop an entry, or reorder
- * it before anything is sent. (Wiring `dispatchToLine`'s busy-line path
- * through this queue, and adding the voice-facing `manage_queue` tool, are
- * later tasks — see NOT WIRED IN YET below.)
- *
- * WHY CALL-SCOPED AND NOT DURABLE — the trade-off, spelled out:
- *
- *   - A held `QueuedRequest` lives ONLY in this in-memory Map. Today's
- *     behavior is strictly more durable: a queued follow-up is already
- *     POSTed and sitting in Postgres the instant the operator says it, so it
- *     survives a tab crash, a network blip, anything short of the session
- *     itself being deleted. Moving the queue into the browser gives up that
- *     durability in exchange for the operator being able to see and steer
- *     it — that is the entire point, and the trade needs to be made with
- *     open eyes, not by accident.
- *   - `drainAllQueues()` is what keeps that loss narrow. It is the hang-up
- *     flush: called as part of ending a call normally, it empties every
- *     line's queue and hands back everything that was waiting so it can be
- *     POSTed to the server exactly as if this module had never sat in front
- *     of it. A normal end-of-call therefore loses nothing — the queue is
- *     just a staging area the operator got to look inside before the same
- *     dispatch that would have happened anyway.
- *   - The durability genuinely AT RISK is narrower still than it first
- *     sounds: a live voice call is not something a page reload survives
- *     regardless of this module — there is no reload-resume contract for
- *     the call itself (unlike the §41 guarantee for an already-dispatched
- *     agent turn, which is a Postgres/Redis-backed run, not the call). So
- *     "a reload loses the queue" is not a NEW failure this module
- *     introduces; the call was already gone. What is genuinely new is the
- *     sliver between "something got queued" and "the call ends" during
- *     which the tab could crash before `drainAllQueues()` ever runs — a
- *     real but narrow window, and the one honest cost of this design.
- *
- * NOT WIRED IN YET: this ships as a standalone module with its own tests
- * and no production caller. A later task connects `enqueueForLine` /
- * `dequeueForLine` to `dispatchToLine`'s busy-line path and `drainAllQueues`
- * to the hang-up handler; another adds the voice-facing `manage_queue` tool
- * on top of `peekQueue` / `dropQueuedAt` / `moveQueued`.
- */
-export type QueuedRequest = {
-    readonly id: string;
-    readonly request: string;
-};
-/** Append `request` to the back of `line`'s queue, minting a fresh id
- * (`nanoid()`, the same generator `line-dispatch.ts` uses for
- * `clientMessageId`). Always succeeds — there is no bound on queue depth. */
-export declare const enqueueForLine: (line: number, request: string) => QueuedRequest;
-/** Pop and return the FRONT of `line`'s queue, or `null` when it's empty. */
-export declare const dequeueForLine: (line: number) => QueuedRequest | null;
-/** A read-only snapshot of `line`'s queue, front to back. Never mutates. */
-export declare const peekQueue: (line: number) => readonly QueuedRequest[];
-/** How many requests are waiting on `line`. */
-export declare const queueDepth: (line: number) => number;
-/** Remove and return the item at `index` in `line`'s queue, or `null` when
- * `index` is out of range — an explicit `< 0 || >= length` bound (§10: never
- * truthiness on a length or index), so a bad index is an honest miss rather
- * than a silent no-op that could be mistaken for success. */
-export declare const dropQueuedAt: (line: number, index: number) => QueuedRequest | null;
-/** Move the item at `from` to position `to` in `line`'s queue (both bounds
- * explicit, same discipline as `dropQueuedAt`). Returns `false` — leaving
- * the queue completely untouched — when either index is out of range;
- * `true` on success, including the no-op case `from === to` (a valid index
- * moved to itself: nothing changes, but the request was satisfied, not
- * refused). `to` is a position in the queue AFTER `from` is removed — the
- * standard "move to position N" reading: moving the last item to `to: 0`
- * makes it the new front. */
-export declare const moveQueued: (line: number, from: number, to: number) => boolean;
-/** The hang-up flush: empty EVERY line's queue and return everything that
- * was waiting, in line-then-position order (line ascending, FIFO within a
- * line) — the order a normal end-of-call should hand work to the server in.
- * Exhaustive by construction: every line the map holds is visited and
- * cleared, so nothing can be left behind. See the module doc for why this
- * is what makes the queue's in-memory-only durability trade-off safe for a
- * normal call end. */
-export declare const drainAllQueues: () => readonly {
-    readonly line: number;
-    readonly request: string;
-}[];
-/** The call-teardown clear: drop every line's queue without returning
- * anything. Unlike `drainAllQueues`, this is for the paths that must not
- * re-POST stale work — e.g. resetting state at the START of a fresh call. */
-export declare const resetQueues: () => void;
-/** Drop `line`'s held queue and report how many items were discarded — the
- * ONE-line counterpart to `resetQueues()` (every line). For the paths that
- * must not re-POST or re-dispatch one line's stale work without touching any
- * other line's: `stop_agent` (voice-call.ts) clearing exactly the queue it
- * just told the user was dropped, and `closeAgentLine` (voice-call-lines.ts)
- * releasing a line whose held work must not resurrect onto the next
- * occupant of the same number. An explicit `=== 0` check rather than
- * truthiness (§10), same discipline as `dropQueuedAt`/`moveQueued`: a
- * nothing-to-drop line reports `0` honestly instead of writing an empty
- * array through `setQueue` for no reason. */
-export declare const clearQueueForLine: (line: number) => number;

package/dist/embed/voice/call-roster-store.d.ts

@@ -1,110 +0,0 @@
-/**
- * The voice call's agent ROSTER — the browser-side twin of the tenant
- * roster minted server-side (`buildCallRoster` in
- * apps/belong-cloud/src/features/voice/call-roster.ts) and threaded through
- * `POST /v1/voice/call-token`'s `agents` field (`callAgentSpecSchema`,
- * voice.schemas.ts). This is what lets the dock's rail, the call screen's
- * agent board, and every spoken announcement address an agent by ROLE
- * ("cli", "consulting") instead of a bare line number — and do so from the
- * moment the dock boots, before any call has ever been started: the rail
- * renders dock-wide with no call active, so it needs the LAST-KNOWN roster,
- * not only one handed to it live off a fresh mint.
- *
- * Persisted per workspace, exactly like `line-slots.ts` beside it
- * (`belong:voice-call-roster`, suffixed `:ws:<id>` when a workspace is in
- * effect via `peekWorkspaceId()`) — a host workspace switch must not hand
- * tenant A's roster (its titles, its CLI agent) to a rail rendering for
- * tenant B.
- *
- * localStorage is a perimeter: the persisted roster is zod-validated on read
- * and any junk (corrupted JSON, wrong shape, storage disabled) degrades to
- * an EMPTY roster — same as "no call minted yet". The schema below is a
- * deliberately independent, by-hand copy of the server's
- * `callAgentSpecSchema`: the two packages ship separately and share no type
- * module, so this is what keeps them honest (mirrors the existing
- * `CallAgentSpec`/`callAgentSpecSchema` split already living server-side in
- * `call-roster.ts` / `voice.schemas.ts`).
- *
- * Two fallback rules, and they are NOT the same rule:
- *
- *   - `lineForRole` / `roleForLine` on an EMPTY roster (nothing ever minted,
- *     or a mint whose body failed to parse) fall back to the POSITIONAL
- *     default that's been true since roles didn't exist: main=1, cli=2,
- *     consulting=3. This is what stops a parse failure from bricking role
- *     addressing mid-call — the switchboard still answers to
- *     main/cli/consulting by position.
- *   - On a NON-empty roster that simply doesn't have that role/line (a
- *     tenant with no CLI), the same lookups return `null` instead — the
- *     honest signal that THIS workspace has no such agent, which is what
- *     later produces an `unknown_role` tool response rather than silently
- *     addressing the wrong agent.
- *
- * `titleForRole` / `titleForLine` never return `null` — a title is always
- * needed for display/announcement, so THEIR fallback is a string, applied
- * uniformly regardless of whether the roster is empty or merely missing
- * that entry. The two fallbacks are deliberately DIFFERENT shapes, not the
- * same rule twice:
- *
- *   - `titleForRole` falls back to a ROLE-derived phrase ("the main agent" /
- *     "the CLI agent" / "the analyst") — never a switchboard
- *     number. Every voice tool call carries a role (it is the operator's
- *     entire addressing vocabulary — see `voice-call.ts`'s
- *     `resolveRoleLine`), so this fallback is always reachable from a role
- *     the model already said out loud, and it feeds prose the model
- *     SPEAKS: an empty roster (nothing minted yet, or a pre-roster backend
- *     mid rolling deploy — `callTokenResponseSchema`'s `agents` field
- *     legitimately defaults to `[]`) must not leak a bare "Agent 2" into
- *     that prose.
- *   - `titleForLine` falls back to `"the main agent"` for line 1 and
- *     `` `Agent ${line}` `` otherwise — the "Agent N" convention the
- *     switchboard used before roles existed. This one serves the UI's
- *     numbered rail, which genuinely displays a switchboard slot number, so
- *     a line-derived fallback is correct there and stays as-is.
- */
-export type CallAgentRole = "main" | "cli" | "consulting";
-export type CallAgentSpec = {
-    readonly role: CallAgentRole;
-    /** The durable switchboard line underneath (`line-slots.ts`). */
-    readonly line: number;
-    /** What the voice calls this agent out loud. */
-    readonly title: string;
-    /** One sentence describing what this agent is for. */
-    readonly purpose: string;
-};
-/** Persist the roster minted for the current call. A whole-roster replace —
- * never a per-entry patch — of whatever this workspace held before. */
-export declare const setCallRoster: (roster: readonly CallAgentSpec[]) => void;
-/** The current workspace's roster, or an empty array when nothing has been
- * minted yet (or storage held junk). */
-export declare const peekCallRoster: () => readonly CallAgentSpec[];
-/** Persist the tenant's product name minted alongside the roster (U2) — a
- * whole-value replace, same discipline as `setCallRoster`. */
-export declare const setProductName: (productName: string | null) => void;
-/** The current workspace's product name, or `null` when nothing has been
- * minted yet, the tenant has none, or storage held junk. Used ONLY to
- * localize the SDK's own UI copy (CallScreen's agent board, U2) — never fed
- * into any string the model speaks or receives. */
-export declare const peekProductName: () => string | null;
-/** Resolve a role to its switchboard line. See the module doc: `null` only
- * ever means "this NON-empty roster doesn't have that role" — an EMPTY
- * roster falls back to the positional default instead. */
-export declare const lineForRole: (role: CallAgentRole) => number | null;
-/** Resolve a switchboard line to its role — the inverse of `lineForRole`,
- * with the same two-rule fallback (EMPTY roster → positional; non-empty and
- * missing → `null`). */
-export declare const roleForLine: (line: number) => CallAgentRole | null;
-/** What the voice calls this role out loud. Always a string — falls back to
- * a ROLE-derived title (never a switchboard number, never `null`) when the
- * roster has no entry for this role, whether the roster is empty or just
- * missing it. */
-export declare const titleForRole: (role: CallAgentRole) => string;
-/** What the voice calls this line out loud. Always a string — falls back to
- * `"the main agent"` (line 1) or `` `Agent ${line}` `` otherwise when the
- * roster has no entry for this line, whether the roster is empty or just
- * missing it. */
-export declare const titleForLine: (line: number) => string;
-/** Test-only: drop the persisted roster AND product name for the current
- * workspace scope — they are minted together (the same call-token mint), so
- * a test resetting one without the other would leak a stale product name
- * (or roster) into the next case. */
-export declare const __clearCallRosterForTest: () => void;