@belonguniverseai/react-sdk 0.6.31 → 0.6.33

package/dist/routes/chat/use-next-step-suggestion.d.ts

@@ -0,0 +1,38 @@
+import { UseChatHelpers } from '@ai-sdk/react';
+import { NextStepSuggestion } from '../../api/suggestions.ts';
+import { GoalStatus } from '../../api/goals.ts';
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+type ChatStatus = UseChatHelpers<BelongUIMessage>["status"];
+export type UseNextStepSuggestionInput = {
+    readonly apiBaseUrl: string;
+    readonly sessionId: string | null;
+    readonly locale: string;
+    readonly status: ChatStatus;
+    readonly lastMessage: {
+        readonly role: string;
+    } | null;
+    readonly draftEmpty: boolean;
+    /** False when this tab cannot act on the session (follower tab, read-only run). */
+    readonly enabled: boolean;
+};
+export type UseNextStepSuggestion = {
+    readonly suggestion: NextStepSuggestion | null;
+    readonly dismiss: () => void;
+    /** Call before Stop: the turn about to end was cut short, so nothing is suggested for it. */
+    readonly suppressNextFinish: () => void;
+};
+export declare const useNextStepSuggestion: (input: UseNextStepSuggestionInput) => UseNextStepSuggestion;
+/**
+ * The suggestion as the screen shows it: the card and the composer ghost read
+ * this one value, so they always agree. It yields to the two rows that already
+ * sit above the composer — an open question card is the agent's own ask, and a
+ * live goal's row is where the hand already is. A finished or cleared goal has
+ * no row, so it hides nothing.
+ */
+export declare const nextStepOnScreen: (suggestion: NextStepSuggestion | null, context: {
+    readonly questionOpen: boolean;
+    readonly goalStatus: GoalStatus | null;
+}) => NextStepSuggestion | null;
+/** The composer's ghost: the welcome question on a new chat, else the recommended reply. */
+export declare const composerGhost: (welcome: string | null, nextStep: NextStepSuggestion | null) => string | null;
+export {};

package/dist/routes/chat/use-quota-notice.d.ts

@@ -0,0 +1,29 @@
+import { TFunction } from 'i18next';
+import { QuotaRefusal } from '../../api/quota-refusal.ts';
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+/**
+ * Re-key the refused message's optimistic bubble to the server's id and
+ * append the notice. Pure and idempotent: a second application (a duplicate
+ * `onError`, a replayed refusal) changes nothing further.
+ */
+export declare const applyQuotaRefusal: (messages: readonly BelongUIMessage[], refusal: QuotaRefusal) => BelongUIMessage[];
+/**
+ * What a finished assistant message says out loud (the live call and the
+ * speaker's batch TTS). A quota notice says the card's words: live it has no
+ * text part, and its history row's fallback text is never shown, so both
+ * renders speak the same sentence under the same id — spoken once, on time.
+ */
+export declare const assistantSpokenText: (message: BelongUIMessage, t: TFunction, locale: string) => string;
+/**
+ * `handleQuotaError(error)` answers a quota refusal and reports `true`, or
+ * reports `false` and leaves the error to the caller's other paths. The
+ * chat's error state is cleared on a microtask: `useChat` calls `onError`
+ * BEFORE it parks `status: "error"`, and `clearError` is a no-op until then
+ * (the same deferral the goal refusal uses).
+ */
+export declare const useQuotaNotice: ({ setMessages, clearError, }: {
+    readonly setMessages: (update: (messages: BelongUIMessage[]) => BelongUIMessage[]) => void;
+    readonly clearError: () => void;
+}) => {
+    readonly handleQuotaError: (error: unknown) => boolean;
+};

package/dist/routes/chat/use-quota-stop-refresh.d.ts

@@ -0,0 +1,27 @@
+import { BelongUIMessage } from '../../stream/belong-data-parts.ts';
+import { HistoryPageResult } from './history-cache.ts';
+export declare const signalQuotaStop: (sessionId: string) => void;
+/**
+ * The newest quota-stop signal of the turn on screen, as a stable key, or
+ * `null`. Restored history is never a signal (it already carries its card),
+ * and the scan stops at the turn's user message.
+ */
+export declare const quotaStopSignalKey: (messages: readonly BelongUIMessage[]) => string | null;
+export declare const useQuotaStopRefresh: ({ messages, idle, isBusy, resolveSessionId, refreshNewestHistory, applyHistoryPage, sleepMs, }: {
+    readonly messages: readonly BelongUIMessage[];
+    /** No turn is streaming into the chat right now (reactive; re-runs the hook). */
+    readonly idle: boolean;
+    /** Read at apply time: a turn is in flight or the transport holds a live stream. */
+    readonly isBusy: () => boolean;
+    /** The chat's session, read when a refresh starts and between attempts. */
+    readonly resolveSessionId: () => string | null;
+    readonly refreshNewestHistory: (sessionId: string) => Promise<HistoryPageResult>;
+    /** Merge the page into the conversation (the `/compact` merge). */
+    readonly applyHistoryPage: (page: Extract<HistoryPageResult, {
+        ok: true;
+    }>) => void;
+    /** Injectable delay (§25). */
+    readonly sleepMs?: (ms: number) => Promise<void>;
+}) => {
+    readonly refreshForQuotaStop: () => void;
+};

package/dist/routes/chat/use-session-goal.d.ts

@@ -227,6 +227,12 @@ export type SessionGoalInput = {
      *  objective back to the composer through the SAME door
      *  `useGoalReceipt`'s follow-ups already use. */
     readonly setDraft: (value: string) => void;
+    /**
+     * Console P1 — a resume or edit answered `budget_limited`: the monthly
+     * token quota may have stopped it, and the cell persisted an orange notice
+     * the chat reads from history (`use-quota-stop-refresh.ts`).
+     */
+    readonly onGoalQuotaStop?: (() => void) | undefined;
 };
 export declare const useSessionGoal: (input: SessionGoalInput) => SessionGoalApi;
 export {};

package/dist/routes/chat.d.ts

@@ -1,21 +1,15 @@
-import { QueryClient } from '@tanstack/react-query';
-import { HistoryScope } from './chat/history-cache.ts';
-export type QueuedMessage = {
-    readonly clientId: string;
-    readonly text: string;
-    readonly submittedAt: number;
-    readonly state: "queued" | "failed";
-};
-/**
- * Read a chat's newest page ahead of opening it (the Chats list's
- * `SessionIntentContext`), so it opens painted from the cache. A chat kept
- * live needs no read; a page read in the last 30 s is not read again.
- */
-export declare const prefetchChatHistory: (queryClient: QueryClient, apiBaseUrl: string, scope: HistoryScope) => void;
-export declare const ChatRoute: ({ sessionId, draftId, reconcileBackgroundRun, onOpenGoalView, onOpenFilesView, projectRunReadOnly, }?: {
+export declare const ChatRoute: ({ sessionId, draftId, reconcileBackgroundRun, sessionPending, justCreated, onOpenGoalView, onOpenFilesView, projectRunReadOnly, }?: {
     readonly sessionId?: string;
     readonly draftId?: string;
     readonly reconcileBackgroundRun?: boolean;
+    /**
+     * The rail's "+" shows this new chat while its session is still being created
+     * (BelongDock remounts onto that session when it exists). Nothing may be
+     * written here until then: it would land outside the new agent.
+     */
+    readonly sessionPending?: boolean;
+    /** This tab created the session a moment ago: it opens with nothing to catch up on. */
+    readonly justCreated?: boolean;
     /** Put the Goal view on screen (the dock owns navigation — same path the
      *  header pill takes). Omitted in tests and stories, where the row's
      *  Details simply does nothing. */

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

@@ -239,6 +239,7 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         outcome: z.ZodOptional<z.ZodString>;
         terminationReason: z.ZodOptional<z.ZodString>;
         retryable: z.ZodOptional<z.ZodBoolean>;
+        code: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"data-usage">;
@@ -309,12 +310,12 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             waiting_for_approval: "waiting_for_approval";
             active: "active";
             paused: "paused";
+            blocked: "blocked";
             clarifying: "clarifying";
             completion_claimed: "completion_claimed";
             deferred: "deferred";
             waiting_for_user: "waiting_for_user";
             waiting_for_ui_action: "waiting_for_ui_action";
-            blocked: "blocked";
             budget_limited: "budget_limited";
             complete: "complete";
             cleared: "cleared";
@@ -354,12 +355,12 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
                 waiting_for_approval: "waiting_for_approval";
                 active: "active";
                 paused: "paused";
+                blocked: "blocked";
                 clarifying: "clarifying";
                 completion_claimed: "completion_claimed";
                 deferred: "deferred";
                 waiting_for_user: "waiting_for_user";
                 waiting_for_ui_action: "waiting_for_ui_action";
-                blocked: "blocked";
                 budget_limited: "budget_limited";
                 complete: "complete";
                 cleared: "cleared";
@@ -386,6 +387,20 @@ export declare const wireStreamPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             normal: "normal";
         }>>;
     }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-quota-notice">;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        kind: z.ZodLiteral<"quota_exceeded">;
+        reason: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+            exhausted: "exhausted";
+            blocked: "blocked";
+        }>>>;
+        productName: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        resetsAt: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        limitWeightedTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        usedWeightedTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$loose>;
 }, z.core.$strip>], "type">;
 /** A request was 401'd twice (once with a freshly re-read token), or no usable
  * token could be had at all (`BelongAuthUnavailableError`): the host session is

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

@@ -268,6 +268,12 @@ export type StatusData = {
      * up" pill instead of a scary failure badge.
      */
     readonly retryable?: boolean | undefined;
+    /**
+     * #974 — a failed run's cause: the server's `run_error` code (e.g.
+     * `provider_content_filter`). The dock picks its copy by this, never by the
+     * English `message`. Absent from an older cloud and from other statuses.
+     */
+    readonly code?: string | undefined;
 };
 /**
  * One slice of the context-window breakdown. `key` is an open string on the
@@ -334,6 +340,28 @@ export type GoalProposalData = {
     readonly criteria?: readonly string[] | undefined;
     readonly runway?: GoalRunwayPreset | undefined;
 };
+/**
+ * Console P1 (TS-DOCK-02, DE-QTA-09) — a persisted monthly-quota refusal.
+ * The cell writes it as the assistant row answering a refused message; the
+ * history route returns it beside a fallback `text` part, which a dock that
+ * renders this card suppresses (SAD §9). The live 429 builds the same part
+ * from the response body (`routes/chat/use-quota-notice.ts`), so a reload
+ * renders what the user saw (§41).
+ *
+ * Every field but `kind` is optional on the wire (SAD §9): a newer dock must
+ * render a notice an older or partial writer left fields out of. The two
+ * figures are carried, never shown (the card has no number in it).
+ */
+export type QuotaRefusalReason = "exhausted" | "blocked";
+export type QuotaNoticeData = {
+    readonly kind: "quota_exceeded";
+    readonly reason?: QuotaRefusalReason | undefined;
+    readonly productName?: string | undefined;
+    /** ISO instant the month's tokens reset; `null` when there is none (blocked). */
+    readonly resetsAt?: string | null | undefined;
+    readonly limitWeightedTokens?: number | undefined;
+    readonly usedWeightedTokens?: number | undefined;
+};
 /**
  * Single source of truth for Belong's custom data parts. The record
  * keys (`reasoning`, `plan`, …) become the part-type suffix:
@@ -361,6 +389,8 @@ export type BelongDataParts = {
     goal: GoalView;
     /** Goal Mode M6 — a goal the agent offered via `propose_goal`. */
     "goal-proposal": GoalProposalData;
+    /** Console P1 — a persisted monthly-quota refusal (TS-DOCK-02). */
+    "quota-notice": QuotaNoticeData;
 };
 /**
  * The concrete `UIMessage` shape the chat surface and transport speak.
@@ -390,5 +420,5 @@ export type WireDataPart<NAME extends keyof BelongDataParts> = {
     readonly id: string;
     readonly data: BelongDataParts[NAME];
 };
-export type WireStreamPart = WireTextPart | WireDataPart<"model-activity"> | 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"> | WireDataPart<"goal"> | WireDataPart<"goal-proposal">;
+export type WireStreamPart = WireTextPart | WireDataPart<"model-activity"> | 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"> | WireDataPart<"goal"> | WireDataPart<"goal-proposal"> | WireDataPart<"quota-notice">;
 export type WireStreamPartType = WireStreamPart["type"];

package/dist/stream/provider-blocked.d.ts

@@ -0,0 +1,16 @@
+import { BelongUIMessage, StatusData } from './belong-data-parts.ts';
+/**
+ * A run the provider refused to finish. It ends on one localized notice in
+ * the turn (`stream.answerBlocked`), not on a stream error: nothing was lost
+ * in transit. Keyed on the run's cause code, never on the server's English
+ * prose.
+ */
+export declare const isProviderBlockedStatus: (data: StatusData) => boolean;
+/**
+ * Whether an assistant turn ended on a provider refusal. Such a run settles
+ * `ready` like a finished one (no stream error), so whatever reports a run's
+ * outcome reads this to tell the two apart. Only the turn's LAST status
+ * counts: a resumed run streams into the same message, so an earlier run's
+ * refusal can sit in front of a later run's answer.
+ */
+export declare const endedProviderBlocked: (message: BelongUIMessage) => boolean;

package/package.json

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

package/dist/component/flowDiagram-UKHOOZJN-CjSeviPw.js

@@ -1,19 +0,0 @@
-globalThis.process = globalThis.process || { env: {} }, globalThis.global = globalThis.global || globalThis;
-import "./chunk-Y2CYZVJY-CiUSrfaV.js";
-import "./src-CKo8cHWB.js";
-import "./chunk-I66GZJ75-CGsmSAKB.js";
-import "./chunk-NSK5VX7P-dusZw8pp.js";
-import "./chunk-ZIRB5QZD-DmX0SXRC.js";
-import "./chunk-W5SLKNZC-CRG_NQXu.js";
-import "./chunk-UBXNYLIW-CJHU4Dfa.js";
-import "./chunk-4I5QYGJK-CDPqoPOq.js";
-import "./chunk-WRU74C26-D8hrtupL.js";
-import "./chunk-QR6OTTB3-Bb0pFQ-m.js";
-import "./chunk-7BUUIJ7U-DJJ8ycYS.js";
-import "./chunk-7Z6QIM7H-BgV4nQ80.js";
-import "./chunk-J7OUQ5F2-D0GPh9LA.js";
-import "./chunk-5VM5RSS4-BuOiQaWo.js";
-import "./chunk-2GRJ4B5K-CBAw5kla.js";
-import "./chunk-XXDRQBXY-BP7ld7ls.js";
-import "./chunk-KBJHAD2P-_EJQ1rNN.js";
-export { n as diagram } from "./chunk-JQJVKLGR-D4zeU7rQ.js";