@belonguniverseai/react-sdk 0.6.33 → 0.6.35

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

@@ -1,8 +1,8 @@
+import { PinnedChatRow, SessionSummary } from './EmbedSessions';
 import { ReactNode } from 'react';
 import { VoiceActionFlash } from '../../embed/closed-surface-voice-bus.ts';
 import { VoiceStatus } from '../../embed/voice-bus.ts';
 import { SpawnAgent } from '../../embed/voice/agent-spawn.ts';
-import { SessionSummary } from './EmbedSessions';
 import { PlanProgress } from '../../stream/plan-progress.ts';
 import { BelongTheme, BelongThemePalette, PresetName } from '../../types/public.ts';
 /** The rail's nav entries. TWIN of `DockView` in `embed/dock-state.ts` — the
@@ -16,7 +16,13 @@ export type EmbedView = "chat" | "goal" | "files" | "scheduled" | "prompts" | "c
  * Focus hides labels only; every destination remains available as an icon.
  * Active fill and brand colors come from the tenant palette.
  */
-export declare function EmbedRail({ view, collapsed, user, theme, palette, sessions, activeId, planProgress, speakEnabled, ttsSupported, voiceSupported, voiceStatus, pendingVoiceDraft, voiceActionFlash, accent, cssVars, presets, activePreset, onSelectView, onToggleMode, onToggleSide, onAccentChange, onAccentReset, onCssVarsChange, onApplyPreset, onLogout, onNewSession, onSelectSession, onSelectAgentLine, spawnAgent, pendingAgentLine, onCloseAgentLine, onDeleteSession, onRenameSession, onSessionsOpen, onViewStats, onToggleSpeak, fullscreen, navigationLabelsVisible, onToggleNavigationLabels, layoutControl, connectorsUnavailable, skillsUnavailable, artifactsUnavailable, goalPresent, goalNeedsYou, }: {
+export declare function EmbedRail({ onAgentNameClick, pinnedActive, pinned, view, collapsed, user, theme, palette, sessions, activeId, planProgress, speakEnabled, ttsSupported, voiceSupported, voiceStatus, pendingVoiceDraft, voiceActionFlash, accent, cssVars, presets, activePreset, onSelectView, onToggleMode, onToggleSide, onAccentChange, onAccentReset, onCssVarsChange, onApplyPreset, onLogout, onNewSession, onSelectSession, onSelectAgentLine, spawnAgent, pendingAgentLine, onCloseAgentLine, onDeleteSession, onRenameSession, onSessionsOpen, onViewStats, onToggleSpeak, fullscreen, navigationLabelsVisible, onToggleNavigationLabels, layoutControl, connectorsUnavailable, skillsUnavailable, artifactsUnavailable, goalPresent, goalNeedsYou, }: {
+    /** Beside the logo in the labeled sidebar: the name goes where the logo goes (BEL-348). */
+    onAgentNameClick?: (() => void) | undefined;
+    /** The pinned chat is on screen: no chat entry is the current page. */
+    pinnedActive?: boolean;
+    /** Its row at the top of Chat history. */
+    pinned?: PinnedChatRow | undefined;
     view: EmbedView;
     collapsed: boolean;
     user: string | null;

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

@@ -1,11 +1,31 @@
 import { BelongTheme } from '../../types/public.ts';
+import { AgentCharacterId, AgentCharacterState } from '../pinned/character/agent-character-art.ts';
 export interface SessionSummary {
     readonly sessionId: string;
     readonly title: string | null;
     readonly updatedAt: string;
 }
+/** The pinned chat's row, always first (BEL-348). */
+export interface PinnedChatRow {
+    readonly name: string;
+    readonly brand: {
+        readonly logo?: string;
+        readonly initials: string;
+    };
+    /** The personal agent's face, where the brand has one (Sima, Bel). */
+    readonly face?: {
+        readonly character: AgentCharacterId;
+        readonly state: AgentCharacterState;
+    } | undefined;
+    readonly unreadCount: number;
+    readonly lastMessage: string | null;
+    readonly refresh?: () => void;
+    readonly active: boolean;
+    readonly onOpen: () => void;
+}
 type SessionsBodyProps = {
     sessions: readonly SessionSummary[];
+    pinned?: PinnedChatRow | undefined;
     activeId: string | null;
     onNew: () => void;
     onSelect: (id: string) => void;
@@ -27,7 +47,7 @@ type SessionsBodyProps = {
 /** Shared history behavior for the compact menu and fullscreen settings.
  * Panel rows use native buttons with sibling edit actions, so history does
  * not depend on a Radix menu context or nest interactive controls. */
-export declare function EmbedSessionsBody({ sessions, activeId, onNew, onSelect, onDelete, onRename, sessionAgentLine, onViewStats, presentation, }: SessionsBodyProps & {
+export declare function EmbedSessionsBody({ sessions, pinned, activeId, onNew, onSelect, onDelete, onRename, sessionAgentLine, onViewStats, presentation, }: SessionsBodyProps & {
     presentation?: "menu" | "panel";
 }): import("react").JSX.Element;
 /**
@@ -35,7 +55,7 @@ export declare function EmbedSessionsBody({ sessions, activeId, onNew, onSelect,
  * an inline text edit, or delete one via an inline trash → confirm flow. Rename +
  * delete are per-row inline affordances that keep the menu open (BEL-120).
  */
-export declare function EmbedSessions({ sessions, activeId, theme, side, triggerClassName, triggerLabel, presentation, onNew, onSelect, onDelete, onRename, onOpen, sessionAgentLine, onViewStats, }: SessionsBodyProps & {
+export declare function EmbedSessions({ sessions, pinned, activeId, theme, side, triggerClassName, triggerLabel, presentation, onNew, onSelect, onDelete, onRename, onOpen, sessionAgentLine, onViewStats, }: SessionsBodyProps & {
     theme: BelongTheme;
     /** Which way the menu opens — toward the panel from the rail edge, or
      *  upward when the trigger lives in the mobile bottom nav bar. */

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

@@ -1,12 +1,14 @@
 import { ComponentProps } from 'react';
 import { EmbedAvatar } from './EmbedAvatar';
-import { SessionSummary } from './EmbedSessions';
+import { PinnedChatRow, SessionSummary } from './EmbedSessions';
 import { EmbedView } from './EmbedRail';
 import { BelongTheme, BelongThemePalette, PresetName } from '../../types/public.ts';
 /** Four mobile destinations. Secondary tools and account controls live in
  * Tools; session switching lives above the conversation. Primary cells retain
  * 44px targets (56px with labels) and surface-scaled glyphs without horizontal scrolling. */
-export declare function MobileNavBar({ view, user, theme, palette, sessions, activeId, voiceSupported, readReplies, accent, cssVars, presets, activePreset, onSelectView, onClose, onToggleMode, onToggleSide, onAccentChange, onAccentReset, onCssVarsChange, onApplyPreset, onLogout, onNewSession, onSelectSession, onDeleteSession, onRenameSession, onSessionsOpen, onViewStats, navigationLabelsVisible, onToggleNavigationLabels, connectorsUnavailable, skillsUnavailable, artifactsUnavailable, goalPresent, }: {
+export declare function MobileNavBar({ pinned, view, user, theme, palette, sessions, activeId, voiceSupported, readReplies, accent, cssVars, presets, activePreset, onSelectView, onClose, onToggleMode, onToggleSide, onAccentChange, onAccentReset, onCssVarsChange, onApplyPreset, onLogout, onNewSession, onSelectSession, onDeleteSession, onRenameSession, onSessionsOpen, onViewStats, navigationLabelsVisible, onToggleNavigationLabels, connectorsUnavailable, skillsUnavailable, artifactsUnavailable, goalPresent, }: {
+    /** The pinned chat's row at the top of Chat history (BEL-348). */
+    pinned?: PinnedChatRow | undefined;
     /** Focus changes navigation labels only; the icons always remain available. */
     navigationLabelsVisible?: boolean;
     onToggleNavigationLabels?: () => void;

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

@@ -0,0 +1,8 @@
+/**
+ * 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, 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/embed/use-settings-owner-key.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The signed-in user a settings section's cached data belongs to: the API
+ * base URL plus the token's issuer, tenant and user. Null until the host has
+ * handed the dock a token.
+ */
+export declare const readSettingsOwnerKey: (baseUrl: string) => string | null;
+/**
+ * Track the owner key so a section re-keys (and drops another user's cached
+ * data) the moment the host switches users. `authError` turns true when no
+ * token arrives at all, so the section can say so instead of loading forever.
+ */
+export declare const useSettingsOwnerKey: () => {
+    readonly ownerKey: string | null;
+    readonly authError: boolean;
+};

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

@@ -0,0 +1,15 @@
+import { ReactElement, ReactNode } from 'react';
+import { Proactive } from '../../api/proactive.ts';
+import { PersonalAgent } from './personal-agent.ts';
+export declare const PinnedChatHeader: ({ proactive, name, agent, covered, onOpenProfile, onOpenComputer, layoutControl, }: {
+    readonly proactive: Proactive;
+    readonly name: string;
+    /** 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/pinned/use-agent-name.d.ts

@@ -0,0 +1,2 @@
+/** What the dock calls the agent: "Belong agent", or the tenant's own brand as is. */
+export declare const useAgentName: () => string;

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/goal-cap-notice.d.ts

@@ -1,4 +1,3 @@
-import { PostMessageError } from '../stream/belong-chat-transport.ts';
 export type GoalRefusal = {
     readonly kind: "exists";
 } | {
@@ -26,11 +25,3 @@ export type GoalRefusal = {
  * chat's own generic error surface instead of being misread as a refusal.
  */
 export declare const goalRefusalFromError: (error: unknown) => GoalRefusal | null;
-/**
- * A refused POST, whatever the reason. `PostMessageError.message` embeds the
- * server's status AND its raw body (a wire enum, untranslated English prose,
- * or a Zod issue list) — never show that to a user: the dock renders its own
- * i18n'd fallback instead. The memory note "server prose isn't localized" is
- * exactly this failure, and §42's "reads as breakage" is the cost.
- */
-export declare const isPostMessageRefusal: (error: unknown) => error is PostMessageError;

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

@@ -0,0 +1,52 @@
+/**
+ * Which Session is the user's pinned chat (BEL-348).
+ *
+ * A tiny external store because places that don't share props need it: BelongDock
+ * (header, presentation) and ChatRoute (it must never be adopted as "Agent 1",
+ * which it isn't, and its quiet check replies aren't rendered).
+ *
+ * Remembered across reloads: ChatRoute binds what's on screen to line 1 in the
+ * dock's first commit, before the dock has read anything, and binding the pinned
+ * chat would take that line from the user's regular chat. An id left by another
+ * account on this browser is harmless: it never matches a Session of theirs.
+ */
+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 {
+        readonly type: string;
+        readonly text?: unknown;
+    }[];
+};
+/**
+ * A quiet check reply. A reply to the user's own message never is, whatever it
+ * 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). 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;
+    readonly streaming: boolean;
+}) => boolean;
+export {};

package/dist/embed/voice/line-run-reader.d.ts

@@ -55,4 +55,4 @@ export type WatchLineRunInput = {
      */
     readonly onTick?: () => void;
 };
-export declare const watchLineRun: (input: WatchLineRunInput, fetchFn?: typeof fetch) => (() => void);
+export declare const watchLineRun: (input: WatchLineRunInput, fetchFn?: typeof fetch, sleepMs?: (ms: number, signal: AbortSignal) => Promise<void>) => (() => void);

package/dist/embed/voice-call.d.ts

@@ -195,6 +195,12 @@ export declare const notifyCallProgress: (hint: string) => void;
 /** ChatRoute mirrors the run's current tool phase — the orb wears it as a
  * small work badge while the agent is busy. */
 export declare const setCallWorkPhase: (phase: CallState["workPhase"]) => void;
+/**
+ * Clear a chat's visible history and refresh it if it's the one on screen. For
+ * what isn't ChatRoute and can't call `runClearCommand`: a call, the pinned chat's
+ * header. False when the server refused; nothing changed then.
+ */
+export declare const clearChatOnScreen: (sessionId: string) => Promise<boolean>;
 /**
  * The lines strip chip on CallScreen calls this directly (no tool-call round
  * trip, no ack — there is no voice tool for it any more, which is why nothing