@belonguniverseai/react-sdk 0.5.0 → 0.6.1

package/dist/stream/belong-chat-transport.d.ts

@@ -145,16 +145,19 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
         reason: z.ZodString;
         state: z.ZodEnum<["pending", "approved", "rejected", "amend_requested", "expired"]>;
         toolName: z.ZodOptional<z.ZodString>;
+        subagentId: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         reason: string;
         approvalId: string;
         state: "pending" | "approved" | "rejected" | "amend_requested" | "expired";
         toolName?: string | undefined;
+        subagentId?: string | undefined;
     }, {
         reason: string;
         approvalId: string;
         state: "pending" | "approved" | "rejected" | "amend_requested" | "expired";
         toolName?: string | undefined;
+        subagentId?: string | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     id: string;
@@ -163,6 +166,7 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
         approvalId: string;
         state: "pending" | "approved" | "rejected" | "amend_requested" | "expired";
         toolName?: string | undefined;
+        subagentId?: string | undefined;
     };
     type: "data-approval-request";
 }, {
@@ -172,6 +176,7 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
         approvalId: string;
         state: "pending" | "approved" | "rejected" | "amend_requested" | "expired";
         toolName?: string | undefined;
+        subagentId?: string | undefined;
     };
     type: "data-approval-request";
 }>, z.ZodObject<{
@@ -195,6 +200,7 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
             code: string;
             severity?: "error" | "stop" | undefined;
         }>>;
+        subagentId: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         toolName: string;
         state: "completed" | "failed" | "started";
@@ -205,6 +211,7 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
         } | undefined;
         input?: Record<string, unknown> | undefined;
         output?: Record<string, unknown> | null | undefined;
+        subagentId?: string | undefined;
     }, {
         toolName: string;
         state: "completed" | "failed" | "started";
@@ -215,6 +222,7 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
         } | undefined;
         input?: Record<string, unknown> | undefined;
         output?: Record<string, unknown> | null | undefined;
+        subagentId?: string | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     id: string;
@@ -228,6 +236,7 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
         } | undefined;
         input?: Record<string, unknown> | undefined;
         output?: Record<string, unknown> | null | undefined;
+        subagentId?: string | undefined;
     };
     type: "data-tool-call";
 }, {
@@ -242,8 +251,56 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
         } | undefined;
         input?: Record<string, unknown> | undefined;
         output?: Record<string, unknown> | null | undefined;
+        subagentId?: string | undefined;
     };
     type: "data-tool-call";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"data-subagent">;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        state: z.ZodEnum<["running", "finished", "failed"]>;
+        stepsUsed: z.ZodOptional<z.ZodNumber>;
+        summary: z.ZodOptional<z.ZodString>;
+        timedOut: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        state: "failed" | "running" | "finished";
+        description: string;
+        stepsUsed?: number | undefined;
+        summary?: string | undefined;
+        timedOut?: boolean | undefined;
+    }, {
+        name: string;
+        state: "failed" | "running" | "finished";
+        description: string;
+        stepsUsed?: number | undefined;
+        summary?: string | undefined;
+        timedOut?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    data: {
+        name: string;
+        state: "failed" | "running" | "finished";
+        description: string;
+        stepsUsed?: number | undefined;
+        summary?: string | undefined;
+        timedOut?: boolean | undefined;
+    };
+    type: "data-subagent";
+}, {
+    id: string;
+    data: {
+        name: string;
+        state: "failed" | "running" | "finished";
+        description: string;
+        stepsUsed?: number | undefined;
+        summary?: string | undefined;
+        timedOut?: boolean | undefined;
+    };
+    type: "data-subagent";
 }>, z.ZodObject<{
     type: z.ZodLiteral<"data-sandbox-command">;
     id: z.ZodString;

package/dist/stream/belong-data-parts.d.ts

@@ -40,6 +40,12 @@ export type ApprovalRequestData = {
      * messages; render the generic label when undefined.
      */
     readonly toolName?: string | undefined;
+    /**
+     * BEL-199 attribution — the `data-subagent` part id whose gated call raised this
+     * card. The resolution event (`approval_state_changed`) carries no subagentId, so
+     * last-write-wins by part id drops it on resolve: pending-card-only by design.
+     */
+    readonly subagentId?: string | undefined;
 };
 /**
  * BEL-93 — a friendly question widget the agent emits instead of dumping a wall
@@ -105,6 +111,41 @@ export type ToolCallData = {
         readonly message: string;
         readonly severity?: ToolErrorSeverity | undefined;
     } | undefined;
+    /**
+     * BEL-199 — the `data-subagent` part id this call ran INSIDE. Absent on every
+     * main-loop call (and on every part emitted before BEL-199). The expanded
+     * activity group chips a matching item with a muted "via <name>" —
+     * attribution, not nesting.
+     */
+    readonly subagentId?: string | undefined;
+};
+/**
+ * BEL-199 — one delegated subagent. `running → finished | failed`, one part per
+ * subagent, reconciled by id like every other lifecycle part.
+ *
+ * It renders as an ACTIVITY ITEM: one thin line INSIDE the §42 collapsed
+ * activity line, never a card beside it. A failed subagent carries no
+ * `ToolErrorSeverity` — deliberately, so it can never reach the collapsed line:
+ * the parent agent reads the failure in its tool result and recovers, and
+ * surfacing it would read as breakage. Nothing about it is ever red.
+ */
+export type SubagentState = "running" | "finished" | "failed";
+export type SubagentData = {
+    /** Registry name, e.g. "general-purpose" — the "via <name>" chip's text. */
+    readonly name: string;
+    /** The model's own task label; this is what the line shows. */
+    readonly description: string;
+    readonly state: SubagentState;
+    readonly stepsUsed?: number | undefined;
+    readonly summary?: string | undefined;
+    /**
+     * The failure was the wall-clock budget, not an error — an optional EXTRA
+     * field rather than a fourth `state` (an unknown enum value would make an
+     * older dock drop the whole part; an unknown field it ignores). Lets the line
+     * say "ran out of time" in the reader's language instead of relaying English
+     * server prose.
+     */
+    readonly timedOut?: boolean | undefined;
 };
 export type SandboxCommandData = {
     readonly state: SandboxCommandState;
@@ -181,6 +222,8 @@ export type BelongDataParts = {
     "approval-request": ApprovalRequestData;
     "choice-request": ChoiceRequestData;
     "tool-call": ToolCallData;
+    /** BEL-199 — a delegated subagent, folded into the §42 activity line. */
+    subagent: SubagentData;
     "sandbox-command": SandboxCommandData;
     "ui-action": UiActionData;
     "cli-reconnect": CliReconnectData;
@@ -213,5 +256,5 @@ export type WireDataPart<NAME extends keyof BelongDataParts> = {
     readonly id: string;
     readonly data: BelongDataParts[NAME];
 };
-export type WireStreamPart = WireTextPart | WireDataPart<"reasoning"> | WireDataPart<"plan"> | WireDataPart<"approval-request"> | WireDataPart<"choice-request"> | WireDataPart<"tool-call"> | WireDataPart<"sandbox-command"> | WireDataPart<"ui-action"> | WireDataPart<"cli-reconnect"> | WireDataPart<"navigation"> | WireDataPart<"artifact"> | WireDataPart<"status"> | WireDataPart<"usage">;
+export type WireStreamPart = WireTextPart | WireDataPart<"reasoning"> | WireDataPart<"plan"> | WireDataPart<"approval-request"> | WireDataPart<"choice-request"> | WireDataPart<"tool-call"> | WireDataPart<"subagent"> | WireDataPart<"sandbox-command"> | WireDataPart<"ui-action"> | WireDataPart<"cli-reconnect"> | WireDataPart<"navigation"> | WireDataPart<"artifact"> | WireDataPart<"status"> | WireDataPart<"usage">;
 export type WireStreamPartType = WireStreamPart["type"];

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/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.5.0",
+  "version": "0.6.1",
   "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 data 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;