@belonguniverseai/react-sdk 0.6.34 → 0.6.35

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

@@ -2,6 +2,7 @@
  * Settings → General: on/off for proactive checks (BEL-348). Renders nothing
  * when the feature is not on for this user. It names the connected apps a check
  * reads, so that's never a surprise. What a check finds shows up in the pinned
- * chat and on Slack, not here.
+ * chat and on Slack, not here, and by email for those who turn that on, which is
+ * offered only where email can reach them.
  */
 export declare const ProactiveChecksSetting: () => import("react").JSX.Element | null;

package/dist/components/pinned/AgentComputerSheet.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+export declare const AgentComputerSheet: ({ name, onClose, }: {
+    readonly name: string;
+    readonly onClose: () => void;
+}) => ReactElement;

package/dist/components/pinned/AgentMessageNote.d.ts

@@ -0,0 +1,12 @@
+import { ProactiveTurnNote, ProactiveTurnSource } from '../../stream/message-metadata.ts';
+type Caption = {
+    /** Null when there's no logo of ours for it. */
+    readonly iconKey: string | null;
+    readonly name: string;
+    readonly place: string | null;
+};
+export declare const captionOf: (origin: ProactiveTurnSource["origin"], scheduledTask: string) => Caption;
+export declare function AgentMessageNote({ note }: {
+    readonly note: ProactiveTurnNote;
+}): import("react").JSX.Element;
+export {};

package/dist/components/pinned/PinnedChatHeader.d.ts

@@ -1,9 +1,15 @@
 import { ReactElement, ReactNode } from 'react';
 import { Proactive } from '../../api/proactive.ts';
-export declare const PinnedChatHeader: ({ proactive, name, onClear, layoutControl, }: {
+import { PersonalAgent } from './personal-agent.ts';
+export declare const PinnedChatHeader: ({ proactive, name, agent, covered, onOpenProfile, onOpenComputer, layoutControl, }: {
     readonly proactive: Proactive;
     readonly name: string;
-    readonly onClear: () => void;
+    /** Sima or Bel, where the brand has one: their face replaces the status dot. */
+    readonly agent: PersonalAgent | null;
+    /** A sheet covers this header: it's out of reach until the sheet closes. */
+    readonly covered: boolean;
+    readonly onOpenProfile: () => void;
+    readonly onOpenComputer: () => void;
     /** On a phone, where there's no rail: the logo, as every other header has it. */
     readonly layoutControl?: ReactNode;
 }) => ReactElement;

package/dist/components/pinned/SentByAgentTag.d.ts

@@ -0,0 +1 @@
+export declare function SentByAgentTag(): import("react").JSX.Element;

package/dist/components/pinned/agent-computer-open-state.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Which pinned chat's computer is open, for a reload of this tab to come back to it
+ * (CLAUDE.md §41). Per tab: another tab of the host shouldn't open onto a terminal.
+ * By chat, not just a yes: signing in as someone else in this tab mustn't open their
+ * computer, and wake it, without a click. Best-effort like dock-state.ts: no storage
+ * just means no restore.
+ */
+export declare const readAgentComputerOpen: () => string | null;
+export declare const writeAgentComputerOpen: (sessionId: string | null) => void;

package/dist/components/pinned/character/AgentCharacter.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement } from 'react';
+import { AgentCharacterId, AgentCharacterState } from './agent-character-art.ts';
+export declare const AgentCharacter: ({ character, state, size, className, }: {
+    readonly character: AgentCharacterId;
+    readonly state: AgentCharacterState;
+    readonly size: number;
+    readonly className?: string;
+}) => ReactElement;

package/dist/components/pinned/character/agent-character-art.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The personal agent's character art: Sima (Simetrik) and Bel (Belong), one
+ * self-contained SVG per state. Each is drawn as an <img>, like the brand marks
+ * in brand-marks.ts, so its CSS animation (and its prefers-reduced-motion
+ * fallback) lives inside the image and never touches the host page's styles.
+ *
+ * Generated from the illustrators' and animators' files; edit those, not this.
+ */
+export type AgentCharacterId = "sima" | "bel";
+export type AgentCharacterState = "idle" | "working" | "needs" | "paused";
+/** The state as an image source, with its animation inside it. */
+export declare const agentCharacterSrc: (who: AgentCharacterId, state: AgentCharacterState) => string;

package/dist/components/pinned/personal-agent.d.ts

@@ -0,0 +1,43 @@
+import { Proactive } from '../../api/proactive.ts';
+import { AgentCharacterId, AgentCharacterState } from './character/agent-character-art.ts';
+export type PersonalAgent = {
+    readonly character: AgentCharacterId;
+    readonly name: string;
+};
+/**
+ * Set by the chat route while the pinned chat is on screen, so the agent's
+ * messages there are signed by Sima or Bel; null everywhere else, where the
+ * regular chat keeps the brand's agent name.
+ */
+export declare const PinnedAgentAuthorContext: import('react').Context<PersonalAgent | null>;
+type TurnLike = {
+    readonly role: string;
+    readonly metadata?: {
+        readonly taskId?: string | undefined;
+        readonly proactive?: unknown;
+    } | undefined;
+};
+/**
+ * Whether the pinned chat's last turn is one the agent started, and its task once
+ * the cloud has said so. A check's own message is internal, so a turn that doesn't
+ * follow one of the user's isn't an answer to them, even before history is re-read.
+ */
+export declare const agentStartedLastTurn: (messages: readonly TurnLike[]) => {
+    readonly wroteLast: boolean;
+    readonly turnId: string | null;
+};
+export declare const personalAgentFor: (brandName: string) => PersonalAgent | null;
+export declare const isPinnedWorking: (proactive: Proactive) => boolean;
+export declare const personalAgentState: (proactive: Proactive) => AgentCharacterState;
+/**
+ * For where it's already in front of them, in its header and its profile. The "needs
+ * you" mark is for the rail, to bring them here; here the chat says what it needs.
+ */
+export declare const calmAgentState: (proactive: Proactive) => AgentCharacterState;
+/** A line saying what it's doing, for the header and the profile. */
+export declare const usePinnedStatus: (proactive: Proactive) => string;
+/** The personal agent for the brand on screen, or null for a tenant's own brand. */
+export declare const usePersonalAgent: () => PersonalAgent | null;
+/** What the pinned chat calls the agent: its own name, else the brand's agent name. */
+export declare const usePinnedAgentName: () => string;
+export {};

package/dist/components/pinned/profile/AgentProfileSheet.d.ts

@@ -0,0 +1,14 @@
+import { ReactElement } from 'react';
+import { Proactive } from '../../../api/proactive.ts';
+import { PersonalAgent } from '../personal-agent.ts';
+export declare const AgentProfileSheet: ({ proactive, name, brandName, agent, onClose, onClear, onOpenSession, onOpenScheduled, onConnect, }: {
+    readonly proactive: Proactive;
+    readonly name: string;
+    readonly brandName: string;
+    readonly agent: PersonalAgent | null;
+    readonly onClose: () => void;
+    readonly onClear: () => void;
+    readonly onOpenSession: (sessionId: string) => void;
+    readonly onOpenScheduled: () => void;
+    readonly onConnect: (() => void) | null;
+}) => ReactElement;

package/dist/components/pinned/profile/ProfileAboutTab.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+export declare const ProfileAboutTab: ({ name }: {
+    readonly name: string;
+}) => ReactElement;

package/dist/components/pinned/profile/ProfileActivityTab.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+import { Proactive } from '../../../api/proactive.ts';
+export declare const ProfileActivityTab: ({ proactive, name, onBackToChat, onOpenSession, onOpenScheduled, }: {
+    readonly proactive: Proactive;
+    readonly name: string;
+    readonly onBackToChat: () => void;
+    readonly onOpenSession: (sessionId: string) => void;
+    readonly onOpenScheduled: () => void;
+}) => ReactElement;

package/dist/components/pinned/profile/ProfileSourcesTab.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement } from 'react';
+import { Proactive } from '../../../api/proactive.ts';
+export declare const ProfileSourcesTab: ({ proactive, name, onConnect, }: {
+    readonly proactive: Proactive;
+    readonly name: string;
+    /** Null where this dock has no Connectors view to send them to. */
+    readonly onConnect: (() => void) | null;
+}) => ReactElement;

package/dist/components/pinned/profile/profile-activity.d.ts

@@ -0,0 +1,52 @@
+import { Proactive } from '../../../api/proactive.ts';
+import { TaskScheduleListItem, TaskScheduleRun } from '../../../api/task-schedules.ts';
+export type ActivityItem = {
+    readonly kind: "chat_waiting";
+    readonly unreadCount: number;
+    readonly lastMessage: string | null;
+} | {
+    readonly kind: "run_waiting";
+    readonly taskScheduleId: string;
+    readonly title: string;
+    readonly sessionId: string | null;
+} | {
+    readonly kind: "check_running";
+} | {
+    readonly kind: "chat_running";
+} | {
+    readonly kind: "run_running";
+    readonly taskScheduleId: string;
+    readonly title: string;
+} | {
+    readonly kind: "next_check";
+    readonly at: string;
+} | {
+    readonly kind: "run_next";
+    readonly taskScheduleId: string;
+    readonly title: string;
+    readonly at: string;
+} | {
+    readonly kind: "check_done";
+    readonly at: string;
+} | {
+    readonly kind: "run_done";
+    readonly taskScheduleId: string;
+    readonly title: string;
+    readonly at: string;
+    readonly outcome: "completed" | "not_finished";
+};
+export type ProfileActivity = {
+    readonly waiting: readonly ActivityItem[];
+    readonly inProgress: readonly ActivityItem[];
+    readonly comingUp: readonly ActivityItem[];
+    readonly doneToday: readonly ActivityItem[];
+};
+/** The schedules whose newest run says "running": it may really be waiting on the user. */
+export declare const runningScheduleIds: (schedules: readonly TaskScheduleListItem[]) => readonly string[];
+export declare const profileActivity: (input: {
+    readonly proactive: Proactive;
+    readonly schedules: readonly TaskScheduleListItem[];
+    /** What `runningScheduleIds` came back with. */
+    readonly latestRuns: ReadonlyMap<string, TaskScheduleRun>;
+    readonly now: Date;
+}) => ProfileActivity;

package/dist/components/scheduled/ScheduleFolderDialogs.d.ts

@@ -36,6 +36,20 @@ export declare const DeleteFolderDialog: (props: {
     readonly busy: boolean;
     readonly onConfirm: () => void;
 }) => import("react").JSX.Element;
+/**
+ * #851 — confirm pausing every task in a folder and its subfolders. `count`
+ * is every task there, paused or finished ones included, so the copy says
+ * "tasks in this folder" and never promises how many will change. It stays
+ * open while the pause runs; `busy` disables confirming again.
+ */
+export declare const PauseFolderDialog: (props: {
+    readonly open: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+    readonly folderName: string;
+    readonly count: number;
+    readonly busy: boolean;
+    readonly onConfirm: () => void;
+}) => import("react").JSX.Element;
 type MoveDialogProps = {
     readonly open: boolean;
     readonly onOpenChange: (open: boolean) => void;

package/dist/components/scheduled/ScheduleFolderTree.d.ts

@@ -5,7 +5,8 @@ type TreeRowProps = {
     readonly expanded: ReadonlySet<string>;
     readonly onToggle: (id: string) => void;
     readonly renderTask: (item: TaskScheduleListItem) => ReactNode;
-    readonly onNotice: (notice: string) => void;
+    /** `undoIds`: tasks an Undo beside the notice resumes (a folder pause's). */
+    readonly onNotice: (notice: string, undoIds?: readonly string[]) => void;
 };
 export declare const ProjectRow: (props: TreeRowProps & {
     readonly node: ProjectTreeNode;

package/dist/components/scheduled/ScheduledListSurface.d.ts

@@ -8,4 +8,11 @@
  * Delete in place. Internal UUIDs never appear in copy (they live only in the
  * memory-router path).
  */
+/**
+ * #851 — how long a folder pause's Undo stays offered. The dock has no other
+ * Undo to match, so this is a short, fixed window: later, another editor may
+ * have paused one of those tasks again on purpose, and the server would
+ * resume it regardless. The notice's text stays; only the Undo goes.
+ */
+export declare const UNDO_WINDOW_MS = 30000;
 export declare const ScheduledListSurface: () => import("react").JSX.Element;

package/dist/embed/pinned-chat.d.ts

@@ -13,6 +13,23 @@
 export declare const peekPinnedChatSessionId: () => string | null;
 export declare const setPinnedChatSessionId: (sessionId: string | null) => void;
 export declare const usePinnedChatSessionId: () => string | null;
+/**
+ * An email from the personal agent links back with `?belongView=pinned` (the
+ * cloud's `pinnedChatDeepLinkUrl`). Stripped once acted on, so a reload doesn't pull
+ * the user back to it, and any other query is the host's and stays untouched.
+ */
+export declare const consumePinnedChatLink: (location: {
+    readonly search: string;
+    readonly replaceSearch: (next: string) => void;
+}) => boolean;
+/** Whether this page was opened from that link, without acting on it. */
+export declare const hasPinnedChatLink: (search: string) => boolean;
+/**
+ * How long that link waits for the host to name the Workspace. The link has none
+ * in it, and its arrival resets the dock to a new chat, but a host may never name
+ * one: the link only stays worth clicking if the chat opens anyway.
+ */
+export declare const PINNED_LINK_WORKSPACE_WAIT_MS = 10000;
 type MessageLike = {
     readonly role: string;
     readonly parts: readonly {
@@ -25,7 +42,8 @@ type MessageLike = {
  * says: "NO" can be the answer they asked for. The check's own message is internal,
  * so a check's reply never follows one of theirs. A prefix ("NO", "NO_UP"…) counts
  * only while it streams in; the cloud stores the real thing internal, so this keeps
- * the live render the same as the reload (§41).
+ * the live render the same as the reload (§41). It's the last thing it wrote that
+ * counts, since an agent narrates between tool calls.
  */
 export declare const isQuietPinnedMessage: (message: MessageLike, context: {
     readonly previousRole: string | undefined;

package/dist/i18n/messages/en.d.ts

@@ -460,6 +460,9 @@ export declare const en: {
         proactiveCheckNow: string;
         proactiveChecking: string;
         proactiveNothingNew: string;
+        proactiveEmailTitle: string;
+        proactiveEmailBody: string;
+        proactiveEmailSaveError: string;
         profile: string;
         languageDescription: string;
         dockPosition: string;
@@ -490,6 +493,7 @@ export declare const en: {
         readonly noMatchingChats: "No matching chats";
         readonly newChat: "New chat";
         readonly noChatsYet: "No chats yet";
+        readonly noOtherChatsYet: "No other chats yet";
         readonly untitledChat: "Untitled chat";
         readonly confirmDelete: "Confirm delete";
         readonly cancelDelete: "Cancel delete";
@@ -758,6 +762,25 @@ export declare const en: {
         readonly folderMovedTo: "Moved to “{{name}}”.";
         readonly folderMovedOut: "Moved out of projects.";
         readonly folderDeleted: "Folder deleted. Its contents moved up one level.";
+        readonly pauseAll: "Pause all";
+        readonly pauseAllTitle: "Pause all tasks in “{{name}}”?";
+        readonly pauseAllBody_one: "{{count}} task in this folder and its subfolders. Scheduled runs won't start until you resume it. A run already in progress, or one started with Run now, still goes ahead.";
+        readonly pauseAllBody_other: "{{count}} tasks in this folder and its subfolders. Scheduled runs won't start until you resume them. A run already in progress, or one started with Run now, still goes ahead.";
+        readonly pausedAll_one: "Paused {{count}} task";
+        readonly pausedAll_other: "Paused {{count}} tasks";
+        readonly pausedAllAlready_one: "{{count}} already paused";
+        readonly pausedAllAlready_other: "{{count}} already paused";
+        readonly pauseAllNothing: "Nothing to pause: these tasks are already paused or finished.";
+        readonly undo: "Undo";
+        readonly undoPauseLabel_one: "Undo pause of {{count}} task";
+        readonly undoPauseLabel_other: "Undo pause of {{count}} tasks";
+        readonly resumedAll_one: "Resumed {{count}} task";
+        readonly resumedAll_other: "Resumed {{count}} tasks";
+        readonly resumedAllAttention_one: "{{count}} needs attention and stays paused";
+        readonly resumedAllAttention_other: "{{count}} need attention and stay paused";
+        readonly undoIncomplete_one: "Resumed {{count}} of {{total}} tasks; the rest may still be paused";
+        readonly undoIncomplete_other: "Resumed {{count}} of {{total}} tasks; the rest may still be paused";
+        readonly undoFailed: "Couldn't confirm they resumed; they may still be paused.";
         readonly projectRoleOwner: "Owner";
         readonly projectRoleEdit: "Can edit";
         readonly projectRoleView: "Can view";
@@ -880,15 +903,78 @@ export declare const en: {
         readonly rowStatus: "Always on";
         readonly rowStatusUnread: "Always on, {{count}} new";
         readonly statusWorking: "Working on something";
+        readonly statusWaiting: "Waiting for your approval";
         readonly statusWatching: "Watching {{apps}}";
         readonly statusOn: "Always on";
         readonly statusPaused: "Paused";
-        readonly openDetails: "What {{name}} is watching";
         readonly composerPlaceholder: "Message {{name}}";
         readonly emptyTitle: "This is your chat with {{name}}";
         readonly emptyBody: "It keeps working while you're away and writes here when something needs you. Tell it what to watch, or ask for anything.";
         readonly clear: "Clear chat";
         readonly clearHint: "Starts this chat over. What it remembers about you stays.";
+        readonly sentByAgent: "Sent by {{name}}";
+        readonly openProfile: "Open {{name}}'s profile";
+        readonly profileLabel: "{{name}}'s profile";
+        readonly profileBack: "Chat";
+        readonly profileSettings: "Checks and chat settings";
+        readonly openComputer: "Open {{name}}'s computer";
+        readonly computerButton: "Computer";
+        readonly profileSettingsShort: "Settings";
+        readonly starterTasks: "What did my scheduled tasks find lately?";
+        readonly starterWatch: "What can you keep an eye on for me?";
+        readonly starterOnItsOwn: "What do you do on your own?";
+        readonly computerTitle: "{{name}}'s computer";
+        readonly computerHint: "What you change here, {{name}} finds on its next step.";
+        readonly computerStarting: "Starting {{name}}'s computer…";
+        readonly computerRetrying: "Can't reach {{name}}'s computer right now. Trying again…";
+        readonly profileRole: "Your personal agent in {{brand}}";
+        readonly profilePause: "Pause";
+        readonly profileResume: "Resume";
+        readonly profilePausedHint: "{{name}} won't check anything or start work on its own until you resume. Your scheduled tasks keep running.";
+        readonly profileTabActivity: "Activity";
+        readonly profileTabSources: "Sources";
+        readonly profileTabAbout: "Permissions";
+        readonly profileOpen: "Open";
+        readonly activityWaiting: "Waiting on you";
+        readonly activityInProgress: "In progress";
+        readonly activityComingUp: "Coming up";
+        readonly activityDoneToday: "Done today";
+        readonly activityChatWaiting: "{{name}} needs you in the chat";
+        readonly activityInYourChat: "{{count}} new in your chat";
+        readonly activityRunWaiting: "Scheduled task, waiting for your answer";
+        readonly activityChecking: "Checking what's new";
+        readonly activityCheckingDetail: "It writes in your chat if something needs you";
+        readonly activityInChat: "In your chat";
+        readonly activityScheduledTask: "Scheduled task";
+        readonly activityNextCheck: "Next check";
+        readonly activityLastCheck: "Checked what's new";
+        readonly activityRunNotFinished: "{{time}} · didn't finish";
+        readonly activityEmpty: "Nothing going on right now.";
+        readonly activityUnavailable: "Can't read the scheduled tasks right now. Trying again…";
+        readonly activitySeeScheduled: "See all scheduled tasks";
+        readonly sourcesIntro: "Where {{name}} looks for things worth your time. It reads on its own, and only sends or posts after you say so.";
+        readonly sourceAlwaysOn: "Always on";
+        readonly sourceListening: "Listening";
+        readonly sourceConnect: "Connect";
+        readonly sourceNotConnected: "Not connected";
+        readonly sourceGmail: "Unread email sent to you, leaving out marketing and mailing lists";
+        readonly sourceSlack: "Direct messages, mentions and channel messages you haven't answered";
+        readonly sourceCalendar: "Invitations for the next 24 hours you haven't answered";
+        readonly sourceSimetrik: "Data that didn't arrive, failed runs and unusual patterns";
+        readonly sourceScheduledTasks: "Scheduled tasks";
+        readonly sourceScheduledTasksWhat: "Runs that failed or are waiting on you";
+        readonly aboutOnItsOwnTitle: "Does on its own";
+        readonly aboutOnItsOwn: "Reads your sources, posts what it finds here and works inside your workspace, then tells you how to undo it.";
+        readonly aboutAsksFirstTitle: "Asks you first";
+        readonly aboutAsksFirst: "Anything that reaches other people: a message, an email, an invitation, a shared link.\nChanging a scheduled task, adding a connector or using your browser.\nAnything that can't be undone: it proposes it and waits.";
+        readonly aboutAlwaysYoursTitle: "Payments and transfers";
+        readonly aboutAlwaysYours: "Moving money. {{name}} never pays or transfers anything on its own.";
+        readonly aboutWhenYouAsk: "These rules cover what {{name}} starts by itself. What you ask for in the chat follows the chat's mode.";
+        readonly tagNeedsYou: "Needs you";
+        readonly tagHeadsUp: "Heads-up";
+        readonly tagDoneOnMyOwn: "Done on my own";
+        readonly sourceScheduledTask: "Scheduled task";
+        readonly sourceMore: "+{{count}} more";
     };
     readonly navigation: {
         minimizeAgent: string;
@@ -1114,6 +1200,7 @@ export declare const en: {
         readonly devOverrideActive: "Dev override active — click to change";
         readonly callLightModelActive: "Calls are stepped down to the light voice model — click for the best voice";
         readonly agentWorking: "{{name}} is working…";
+        readonly agentWaiting: "Waiting for your answer";
         readonly waitingForReportAction: "Waiting for a report action to finish…";
     };
     readonly connectors: {

package/dist/i18n/messages/surfaces/embedMisc.d.ts

@@ -63,6 +63,7 @@ export declare const embedMiscEn: {
         readonly devOverrideActive: "Dev override active — click to change";
         readonly callLightModelActive: "Calls are stepped down to the light voice model — click for the best voice";
         readonly agentWorking: "{{name}} is working…";
+        readonly agentWaiting: "Waiting for your answer";
         readonly waitingForReportAction: "Waiting for a report action to finish…";
     };
 };
@@ -129,6 +130,7 @@ export declare const embedMiscEs: {
         devOverrideActive: string;
         callLightModelActive: string;
         agentWorking: string;
+        agentWaiting: string;
         waitingForReportAction: string;
     };
 };
@@ -195,6 +197,7 @@ export declare const embedMiscPt: {
         devOverrideActive: string;
         callLightModelActive: string;
         agentWorking: string;
+        agentWaiting: string;
         waitingForReportAction: string;
     };
 };
@@ -261,6 +264,7 @@ export declare const embedMiscIt: {
         devOverrideActive: string;
         callLightModelActive: string;
         agentWorking: string;
+        agentWaiting: string;
         waitingForReportAction: string;
     };
 };