@belonguniverseai/react-sdk 0.1.3 → 0.1.4-beta

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

@@ -1,6 +1,34 @@
 import { z } from 'zod';
 import { ChatTransport, UIMessageChunk } from 'ai';
 import { BelongUIMessage, WireStreamPart } from './belong-data-parts.ts';
+declare const cancelRunResponseSchema: z.ZodObject<{
+    recalledMessages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        messageId: z.ZodString;
+        clientMessageId: z.ZodNullable<z.ZodString>;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        clientMessageId: string | null;
+        text: string;
+        messageId: string;
+    }, {
+        clientMessageId: string | null;
+        text: string;
+        messageId: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    recalledMessages: {
+        clientMessageId: string | null;
+        text: string;
+        messageId: string;
+    }[];
+}, {
+    recalledMessages?: {
+        clientMessageId: string | null;
+        text: string;
+        messageId: string;
+    }[] | undefined;
+}>;
+export type RecalledQueuedMessage = z.infer<typeof cancelRunResponseSchema>["recalledMessages"][number];
 /**
  * The wire/stored part union. Exported so the history loader (chat.tsx) can
  * validate persisted assistant parts against the SAME shapes the live stream
@@ -652,6 +680,14 @@ export type BelongChatTransportOptions = {
      * production uses `STALL_TIMEOUT_MS`.
      */
     readonly stallTimeoutMs?: number;
+    /**
+     * Workspace isolation: the host workspace this transport's session belongs
+     * to. Defaults to the CURRENT scope at construction — captured once, so a
+     * workspace-A transport still streaming after the host switched to B keeps
+     * persisting its cursor under A's key and stamping A on its requests.
+     * Tests may pin it explicitly.
+     */
+    readonly workspaceExternalId?: string | null;
 };
 export type StreamContext = {
     /** Stable id we emit on every `text-delta`. Null when no text run is open. */
@@ -682,15 +718,32 @@ export type StreamContext = {
 export declare class BelongChatTransport implements ChatTransport<BelongUIMessage> {
     #private;
     constructor(options: BelongChatTransportOptions);
+    /**
+     * The server session this transport is pinned to (adopted at construction
+     * or created on first send), or null before any exists. The queued-send
+     * path reads THIS — never the live workspace-keyed pointer — so a steering
+     * message posts to the conversation on screen even inside the scope
+     * store's poll window after a host workspace switch.
+     */
+    get sessionId(): string | null;
+    /** The construction-captured workspace (see #workspaceExternalId). */
+    get workspaceExternalId(): string | null;
     /** Drop the cached session so the next `sendMessages` creates a new one. */
     reset(): void;
     /**
      * Best-effort server-side cancel of an in-flight run. `useChat`'s `stop()`
      * only aborts the local stream (stops listening); this tells belong-cloud to
      * actually halt the agent (POST /v1/runs/:runId/cancel → run-cancel pub/sub).
+     *
+     * BEL-144 — the backend also recalls the session's queued-but-unclaimed
+     * messages so they never execute; their text is returned here for the caller
+     * to restore into the composer. Any failure (network, non-2xx, old backend
+     * without the field) collapses to an empty list — the cancel stays
+     * best-effort.
      */
-    cancelRun: (runId: string) => Promise<void>;
+    cancelRun: (runId: string) => Promise<readonly RecalledQueuedMessage[]>;
     sendMessages: ChatTransport<BelongUIMessage>["sendMessages"];
     reconnectToStream: ChatTransport<BelongUIMessage>["reconnectToStream"];
 }
 export declare const wireToUiChunks: (part: WireStreamPart, ctx: StreamContext) => readonly UIMessageChunk[];
+export {};

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

@@ -1,4 +1,5 @@
 import { UIMessage } from 'ai';
+import { BelongMessageMetadata } from './message-metadata.ts';
 /**
  * F2 — per-step execution status. Optional: absent means `pending`
  * (back-compat with plans proposed before F2 and the initial propose). The
@@ -183,11 +184,12 @@ export type BelongDataParts = {
 };
 /**
  * The concrete `UIMessage` shape the chat surface and transport speak.
- * Metadata is typed `unknown` and read defensively at use sites (e.g. the
- * user-bubble skill chip reads `metadata.skill` via a narrowing guard) — keep
- * it `unknown` so new metadata fields need no type-plumbing changes.
+ * Metadata was `unknown` until the `fromHistory` gate needed to propagate
+ * reliably — now it's the `belongMessageMetadataSchema`-inferred type, parsed
+ * once at the wire perimeter (§4) so use sites read typed fields instead of
+ * re-narrowing.
  */
-export type BelongUIMessage = UIMessage<unknown, BelongDataParts>;
+export type BelongUIMessage = UIMessage<BelongMessageMetadata, BelongDataParts>;
 /**
  * Wire shape emitted by belong-cloud's SSE adapter. This stays as a
  * separate union because the server side has not migrated to AI-SDK

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

@@ -0,0 +1,45 @@
+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"]>;
+        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). */
+    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;
+}>;
+export type BelongMessageMetadata = z.infer<typeof belongMessageMetadataSchema>;

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

@@ -30,9 +30,9 @@ declare const streamStateSchema: z.ZodObject<{
     lastEventId: string | null;
 }>;
 export type PersistedStreamState = z.infer<typeof streamStateSchema>;
-export declare const readStreamState: () => PersistedStreamState | null;
-export declare const writeStreamState: (state: Omit<PersistedStreamState, "updatedAt">) => void;
-export declare const clearStreamState: () => void;
+export declare const readStreamState: (workspaceId?: string | null) => PersistedStreamState | null;
+export declare const writeStreamState: (state: Omit<PersistedStreamState, "updatedAt">, workspaceId?: string | null) => void;
+export declare const clearStreamState: (workspaceId?: string | null) => void;
 /**
  * Like {@link readStreamState}, but only returns state fresh enough that its
  * run is worth reconnecting to. Returns null for stale state WITHOUT clearing
@@ -40,7 +40,7 @@ export declare const clearStreamState: () => void;
  * and history restore on reload — only the *run* is too old to resume. A new
  * message overwrites the cursor via {@link writeStreamState}.
  */
-export declare const readResumableStreamState: () => PersistedStreamState | null;
+export declare const readResumableStreamState: (workspaceId?: string | null) => PersistedStreamState | null;
 /**
  * Persist the chosen session as the active stream session (sessions menu
  * switch / new). Passing a session id points the next ChatRoute mount at that

package/dist/types/public.d.ts

@@ -177,6 +177,17 @@ export type BelongGlobal = {
     readonly setToken: (jwt: string) => void;
     /** Switch the dock UI language at runtime (persisted; relabels live). */
     readonly setLocale: (locale: BelongLocale) => void;
+    /**
+     * Switch the dock's workspace at runtime (workspace isolation). Re-scopes
+     * the whole dock synchronously — session list, Files tab, chat, and the
+     * agent's Simetrik CLI credential all follow the given workspace id (the
+     * same value `agentGrant.scopeExternalId` / the `scopeUrlParam` URL param
+     * carry). Wins over URL tracking until cleared with `null` (which falls
+     * back to the URL/static resolution). Invalid ids are ignored with a
+     * console warning. Hosts can use this standalone (no `scopeUrlParam`) or
+     * alongside URL tracking for instant switches.
+     */
+    readonly setWorkspace: (id: string | null) => void;
     readonly setTheme: (theme: PartialBelongTheme) => void;
     readonly applyPreset: (name: PresetName) => void;
     readonly open: () => void;

package/package.json

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