@belonguniverseai/react-sdk 0.6.21 → 0.6.23

package/dist/stream/subagent-lanes.d.ts

@@ -0,0 +1,90 @@
+import { ReactNode } from 'react';
+import { TFunction } from 'i18next';
+import { ActivityItem, ToolActivityItem } from './activity-items.ts';
+import { SubagentData } from './belong-data-parts.ts';
+import { SubagentControlsState } from './subagent-controls-store.ts';
+import { SubagentLane, SubagentLaneStatus, SubagentMessageIndex, SubagentWaveCounts, SubagentWaveLabel } from './subagent-lanes-model.ts';
+type RenderToolItem = (item: ToolActivityItem) => ReactNode;
+/**
+ * §3.6 — the wave label, worded. An unlabelled wave says how many are running
+ * only while any lane still is: "3 running" beside counts of "3 done" would be
+ * a false state claim on the surface §42 exists to keep honest. Once none runs,
+ * it reads the progress the collapsed line already words. BY NAME: that key is
+ * "{{done}} of {{count}} done" — a swapped pass renders "3 of 2 done".
+ */
+export declare const waveLabelText: (t: TFunction, label: SubagentWaveLabel) => string;
+/** §3.6 — non-zero counts, in order: done, running, waiting, need a look, stopped. */
+export declare const waveCountsText: (t: TFunction, counts: SubagentWaveCounts) => string;
+/**
+ * The elapsed-time LEAF (§3.4). It owns the only interval, so a tick re-renders
+ * this span and nothing else, and it runs only while the group is live and the
+ * lane is running — the group's content is force-mounted while collapsed, so an
+ * unconditional interval would tick for every group in the transcript. This
+ * leaf is the wall-clock adapter; the model takes `nowMs` (§25).
+ */
+export declare const SubagentElapsed: ({ data, status, live, }: {
+    readonly data: SubagentData;
+    readonly status: SubagentLaneStatus;
+    readonly live: boolean;
+}) => import("react").JSX.Element | null;
+/** Stable role identity, with motion only while the lane is actually live. */
+export declare const SubagentGlyph: ({ status, live, name, }: {
+    readonly status: SubagentLaneStatus;
+    readonly live: boolean;
+    readonly name?: string;
+}) => import("react").JSX.Element;
+/**
+ * §3.3 subline: orange for the ended-badly outcomes, muted otherwise — including
+ * §4a's "Waiting for you" on a running lane whose approval is pending (waiting
+ * on a person is not a failure).
+ */
+export declare const SubagentOutcomeLine: ({ status, waiting, }: {
+    readonly status: SubagentLaneStatus;
+    readonly waiting: boolean;
+}) => import("react").JSX.Element | null;
+/** §3.5 — the subagent's own written report, as PLAIN text (never HTML). */
+export declare const SubagentReport: ({ summary }: {
+    readonly summary: string;
+}) => import("react").JSX.Element;
+/**
+ * §3.5 — the Stop handler for a lane, or null when Stop must not render: the
+ * lane is stoppable (own loop only) and still running or queued, its group is
+ * live, and the chat has an active run.
+ */
+export declare const stopHandlerFor: (controls: SubagentControlsState | null, live: boolean, lane: SubagentLane) => SubagentControlsState["stop"] | null;
+/**
+ * Stop ONE subagent. Disables after the click and shows nothing optimistic:
+ * the lane changes only when its `subagent_finished` part arrives (§3.5).
+ * `outline`, never `destructive` (§42) — a stop is an ordinary thing to ask
+ * for, and it is best-effort besides.
+ */
+export declare const SubagentStopButton: ({ subagentId, onStop, }: {
+    readonly subagentId: string;
+    readonly onStop: SubagentControlsState["stop"];
+}) => import("react").JSX.Element;
+/**
+ * Decision 9 — Stop all confirms INLINE, in two steps: the first click turns
+ * the button into "Stop N?" for 4 s; a second click inside that window stops.
+ * No modal. Once it stops, it stays disabled until the lanes finish and the
+ * button unmounts (nothing optimistic).
+ */
+export declare const SubagentStopAll: ({ count, onStopAll, }: {
+    readonly count: number;
+    readonly onStopAll: () => Promise<void>;
+}) => import("react").JSX.Element;
+/** A report worth a toggle: present and not blank. */
+export declare const reportOf: (data: SubagentData) => string | null;
+/**
+ * The expanded group's body: main-loop items in place, lanes with their nested
+ * steps, and waves. Keys are the model's (`item-<i>`, `lane-<id>`,
+ * `wave-<id>`), never a render index, so a re-sort never remounts a lane.
+ * `index` is the group's MESSAGE (§4a): a lane nests its calls, and a wave its
+ * lanes, from every group of it. Absent, the items are their own message.
+ */
+export declare const SubagentLanes: ({ items, live, renderToolItem, index, }: {
+    readonly items: readonly ActivityItem[];
+    readonly live: boolean;
+    readonly renderToolItem: RenderToolItem;
+    readonly index?: SubagentMessageIndex | undefined;
+}) => import("react").JSX.Element;
+export {};

package/dist/stream/use-publish-subagent-controls.d.ts

@@ -0,0 +1,11 @@
+import { BelongChatTransport } from './belong-chat-transport.ts';
+import { BelongUIMessage } from './belong-data-parts.ts';
+import { PublishedSubagentWave } from './subagent-controls-store.ts';
+/**
+ * Every wave in the conversation, in message order — each message grouped and
+ * indexed exactly as `MessageParts` draws it (§4a, deviation 16: the same
+ * `indexableMessageParts` filter, so the pane's lanes and the chat's lanes are
+ * the same lanes down to their step keys), `waiting` included.
+ */
+export declare const collectSubagentWaves: (messages: readonly BelongUIMessage[], runActive: boolean) => readonly PublishedSubagentWave[];
+export declare const usePublishSubagentControls: (transport: Pick<BelongChatTransport, "stopSubagent">, messages: readonly BelongUIMessage[]) => void;

package/dist/stream/workspace-focus-store.d.ts

@@ -1,6 +1,11 @@
 import { PreviewTarget } from './preview-panel-store.ts';
 export type WorkspaceFocusTarget = PreviewTarget | {
     readonly kind: "plan";
+}
+/** Spec 2026-09-16 §3.5 — one wave's full subagent list ("Show all" in fullscreen). */
+ | {
+    readonly kind: "subagents";
+    readonly waveId: string;
 };
 export type WorkspaceFocusState = {
     readonly target: WorkspaceFocusTarget | null;
@@ -9,7 +14,8 @@ export type WorkspaceFocusState = {
     /** The agent wants this shown, but the user holds the pane. */
     readonly pending: WorkspaceFocusTarget | null;
 };
-/** Same thing on screen? Artifacts by id, workspace files by pinned scope + path, plans by kind. */
+/** Same thing on screen? Artifacts by id, workspace files by pinned scope + path,
+ *  plans by kind, subagent views by wave. */
 export declare const isSameFocusTarget: (a: WorkspaceFocusTarget, b: WorkspaceFocusTarget) => boolean;
 export declare const peekWorkspaceFocus: () => WorkspaceFocusState;
 export declare const subscribeWorkspaceFocus: (listener: () => void) => (() => void);

package/dist/test/render.d.ts

@@ -16,8 +16,25 @@ export declare function setValue(el: HTMLInputElement | HTMLTextAreaElement, val
  * it holds or `timeoutMs` elapses. The repo's render harness serves React's
  * prod build (no `React.act`), so async state — react-query settling, a $post
  * resolving — is observed by polling rather than awaiting `act`.
+ *
+ * `predicate` keeps its ORIGINAL truthy contract — a falsy return (`false`,
+ * `null`, `0`, `""`, a `querySelector` miss, …) means "not yet, keep
+ * polling" — with exactly two additions, both needed for the
+ * `waitFor(() => expect(x).toBe(y))` idiom: `undefined` counts as
+ * "satisfied" (a PASSING `expect(...)` call returns nothing, so treating
+ * `undefined` as falsy would spin every such predicate to the timeout), and
+ * a THROW (a FAILING `expect(...)` call) means "not yet, keep polling"
+ * rather than an immediate hard stop. Without the second part, the very
+ * FIRST call to a throwing predicate always races an async continuation
+ * that hasn't had a microtask turn yet, so it would fail on that first race
+ * almost every time, no matter how the component under test is implemented
+ * — see IssueReportDialog.test.tsx's failed-send case for a concrete
+ * instance. Every existing boolean/element-returning predicate in this repo
+ * is unaffected: `true`/a found element still short-circuits immediately,
+ * `false`/`null` still retries. On timeout the LAST assertion error (if any)
+ * is re-thrown, which is more actionable than the generic message below.
  */
-export declare function waitFor(predicate: () => boolean, { timeoutMs, stepMs }?: {
+export declare function waitFor(predicate: () => unknown, { timeoutMs, stepMs }?: {
     timeoutMs?: number;
     stepMs?: number;
 }): Promise<void>;

package/dist/test/subagent-fixtures.d.ts

@@ -0,0 +1,24 @@
+import { ActivityItem, ToolActivityItem } from '../stream/activity-items.ts';
+import { SubagentLane } from '../stream/subagent-lanes-model.ts';
+import { ApprovalState, BelongUIMessage, SubagentData, ToolCallData } from '../stream/belong-data-parts.ts';
+/** A subagent activity item; `data` overrides the running defaults. */
+export declare const subagentItem: (subagentId: string, data?: Partial<SubagentData>) => ActivityItem;
+/**
+ * A tool activity item, completed unless `state` says otherwise; `subagentId`
+ * nests it under that lane.
+ */
+export declare const toolItem: (toolName: string, subagentId?: string, state?: ToolCallData["state"]) => ToolActivityItem;
+/** An approval card part; `subagentId` undefined = the main agent raised it. */
+export declare const approvalPart: (subagentId: string | undefined, state?: ApprovalState) => BelongUIMessage["parts"][number];
+/**
+ * A `data-subagent` message part; `data` overrides the running defaults. Lives
+ * here (not in one suite) because the whole-message suite and the controls
+ * suite must build the SAME part — they assert the two index it identically.
+ */
+export declare const subagentPart: (id: string, data?: Partial<SubagentData>) => BelongUIMessage["parts"][number];
+/**
+ * A resolved lane with no steps and no pending approval — what the pure model
+ * and the fullscreen pane both start from. `status` is derived, never passed,
+ * so a fixture can never claim a state its data does not imply.
+ */
+export declare const subagentLane: (subagentId: string, data?: Partial<SubagentData>) => SubagentLane;

package/dist/types/public.d.ts

@@ -218,6 +218,53 @@ export type BelongInitInput = {
          */
         readonly scopeUrlParam?: string;
     };
+    /**
+     * Host-bridged MCP (opt-in). Same-origin paths of MCP endpoints the host app
+     * lets the agent call THROUGH THIS PAGE, with the signed-in viewer's own
+     * session (cookies), e.g. `{ allowedPaths: ["/mcp"] }`. The agent reaches
+     * them only via tools its tenant published with `transport: "host"`; a path
+     * not listed here is refused in the page, whatever the tenant publishes.
+     * Omitted = no host MCP at all.
+     */
+    readonly hostMcp?: BelongHostMcpConfig;
+    /**
+     * Which browser-control ops the agent may run on THIS page (opt-in
+     * restriction). Omitted = every op (reading, clicking, typing, navigating,
+     * running JS, host MCP), exactly as before. A host that only bridges MCP
+     * should pass `{ allowedOps: ["mcp_call"] }`, so the agent cannot drive or
+     * script the page with the viewer's session. `allowedOps: []` = none. A
+     * value that is present but invalid allows NOTHING (with a console warning).
+     * Restated on every `init`: omitting it on a re-init lifts the restriction.
+     */
+    readonly browserControl?: BelongBrowserControlConfig;
+};
+export type BelongHostMcpConfig = {
+    /**
+     * Root-relative paths (`/mcp`, `/api/mcp?x=1`) on this page's origin, each at
+     * most 512 URL path/query characters (no whitespace, `\`, `#` or `..`
+     * segment). At most 8.
+     */
+    readonly allowedPaths: readonly string[];
+};
+/** A browser-control op the dock can run on the host page. */
+export type BelongBrowserOpName = "snapshot" | "read" | "click" | "type" | "select" | "press" | "navigate" | "eval" | "mcp_call";
+export type BelongBrowserControlConfig = {
+    /** The ops this page runs; every other op is refused in the page. */
+    readonly allowedOps: readonly BelongBrowserOpName[];
+};
+/** `window.belong.open(options)` — what the host asks the dock to show. */
+export type BelongOpenOptions = {
+    /**
+     * The size to open at. `fullscreen` covers the viewport on desktop (mobile
+     * resolves it to the open sheet, as the rail toggle does). The user can
+     * still leave it. Omitted = the dock's current size, expanded if collapsed.
+     */
+    readonly size?: "expanded" | "fullscreen";
+    /**
+     * Prefill (never send) the composer — only when it is empty — and focus it.
+     * At most 4,000 characters.
+     */
+    readonly draft?: string;
 };
 export type RouteHandlerResult = {
     readonly ok: true;
@@ -272,7 +319,13 @@ export type BelongGlobal = {
     readonly setPageContext: (label: string | null) => void;
     readonly setTheme: (theme: PartialBelongTheme) => void;
     readonly applyPreset: (name: PresetName) => void;
-    readonly open: () => void;
+    /**
+     * Show the dock: switch to the chat view at the requested size (and
+     * optionally prefill the composer). Safe to call BEFORE `init` resolves — a
+     * request made before the dock mounts is applied at mount, with no flash of
+     * the docked size.
+     */
+    readonly open: (options?: BelongOpenOptions) => void;
     readonly close: () => void;
     readonly registerRouteHandler: (routeName: string, handler: RouteHandler) => void;
     readonly registerUiAction: <I, O>(name: string, handler: UiActionHandler<I, O>) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@belonguniverseai/react-sdk",
-  "version": "0.6.21",
+  "version": "0.6.23",
   "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/ai-elements/reasoning.d.ts

@@ -1,26 +0,0 @@
-import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
-import { ComponentProps, ReactNode } from 'react';
-interface ReasoningContextValue {
-    isStreaming: boolean;
-    isOpen: boolean;
-    setIsOpen: (open: boolean) => void;
-    duration: number | undefined;
-}
-export declare const useReasoning: () => ReasoningContextValue;
-export type ReasoningProps = ComponentProps<typeof Collapsible> & {
-    isStreaming?: boolean;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    duration?: number;
-};
-export declare const Reasoning: import('react').MemoExoticComponent<({ className, isStreaming, open, defaultOpen, onOpenChange, duration: durationProp, children, ...props }: ReasoningProps) => import("react").JSX.Element>;
-export type ReasoningTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
-    getThinkingMessage?: (isStreaming: boolean, duration?: number) => ReactNode;
-};
-export declare const ReasoningTrigger: import('react').MemoExoticComponent<({ className, children, getThinkingMessage, ...props }: ReasoningTriggerProps) => import("react").JSX.Element>;
-export type ReasoningContentProps = ComponentProps<typeof CollapsibleContent> & {
-    children: string;
-};
-export declare const ReasoningContent: import('react').MemoExoticComponent<({ className, children, ...props }: ReasoningContentProps) => import("react").JSX.Element>;
-export {};