@fiodos/web-core 0.1.9 → 0.1.11

package/dist/cjs/api/backendClient.js

@@ -119,6 +119,21 @@ function createFiodosBackendClient(options) {
             if (request.sessionId?.trim()) {
                 body.session_id = request.sessionId.trim();
             }
+            // Autonomous-chain continuation metadata (backward compatible: absent on a
+            // normal turn; an old backend simply ignores these fields).
+            if (request.isContinuation) {
+                body.is_continuation = true;
+                if (typeof request.chainStep === 'number')
+                    body.chain_step = request.chainStep;
+                if (request.lastStep) {
+                    body.last_step = {
+                        type: request.lastStep.type,
+                        intent: request.lastStep.intent,
+                        ...(request.lastStep.label ? { label: request.lastStep.label } : {}),
+                        success: request.lastStep.success,
+                    };
+                }
+            }
             const res = await fetchWithTimeout(`${baseUrl}/assistant/chat`, { method: 'POST', headers: buildHeaders(), body: JSON.stringify(body) }, turnTimeoutMs, opts?.signal);
             if (!res.ok)
                 throw await errorFromResponse(res);
@@ -129,11 +144,16 @@ function createFiodosBackendClient(options) {
             catch {
                 throw new errors_1.AgentApiError('invalid_response');
             }
+            // Chain-continuation signal. Default to 'complete' so an old backend that
+            // never sends it keeps the one-action-per-turn behaviour (no chaining).
+            const rawStatus = typeof data.task_status === 'string' ? data.task_status : '';
+            const taskStatus = rawStatus === 'in_progress' || rawStatus === 'blocked' ? rawStatus : 'complete';
             return {
                 reply: (data.reply ?? '').trim(),
                 audioBase64: data.audio_base64 ?? null,
                 action: (0, core_1.parseAgentAction)(data.action),
                 wasTruncated: data.was_truncated === true,
+                taskStatus,
             };
         },
         async previewTts(voice, text) {

package/dist/cjs/config/types.d.ts

@@ -17,6 +17,22 @@ export interface AgentTimings {
     minTranscriptChars: number;
 }
 export declare const DEFAULT_AGENT_TIMINGS: AgentTimings;
+/**
+ * Autonomous multi-step chaining. OFF by default: with `enabled: false` the orb
+ * behaves exactly as before (one action per turn). When ON, after a successful
+ * navigate/execute whose backend `task_status` is "in_progress", the orb takes
+ * the next step on its own — capped at `maxSteps` and guarded by no-progress
+ * detection and sensitive-confirmation pauses (which always require the human).
+ */
+export interface AgentChaining {
+    /** Master switch. Default false (retrocompatible, one action per turn). */
+    enabled: boolean;
+    /** Hard cap on steps per user request (safety). Default 6. */
+    maxSteps: number;
+    /** Pause between chained steps so the user can see each screen (ms). */
+    dwellMs: number;
+}
+export declare const DEFAULT_AGENT_CHAINING: AgentChaining;
 export type TurnGateVerdict = {
     ok: true;
 } | {
@@ -59,5 +75,7 @@ export interface FiodosWebAgentConfig {
     ttsVoice?: string | (() => string | undefined);
     consentVersion?: number;
     timings?: Partial<AgentTimings>;
+    /** Autonomous multi-step chaining. OFF unless explicitly enabled. */
+    chaining?: Partial<AgentChaining>;
 }
 export type { WebUiMessages };

package/dist/cjs/config/types.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_TIMINGS = void 0;
+exports.DEFAULT_AGENT_CHAINING = exports.DEFAULT_AGENT_TIMINGS = void 0;
 exports.DEFAULT_AGENT_TIMINGS = {
     thinkingWatchdogMs: 25000,
     maxListeningSeconds: 60,
     confirmationVoiceWindowMs: 8000,
     minTranscriptChars: 2,
 };
+exports.DEFAULT_AGENT_CHAINING = {
+    enabled: false,
+    maxSteps: 6,
+    dwellMs: 450,
+};

package/dist/cjs/controller/AgentController.d.ts

@@ -23,6 +23,19 @@ export interface AgentExchange {
     userText: string;
     replyText: string;
 }
+/**
+ * REAL live activity for the chat panel — what the agent is actually doing
+ * right now, not a canned walk-through. Emitted at true lifecycle moments:
+ * request in flight ('thinking'), a navigate/execute action that really ran
+ * ('navigating'/'executing' with the manifest label), or a sensitive action
+ * waiting for the human ('waiting_confirmation'). Cleared when the final
+ * reply lands, so the panel narrative disappears exactly like before.
+ */
+export interface AgentActivity {
+    kind: 'thinking' | 'navigating' | 'executing' | 'waiting_confirmation';
+    /** Manifest label (route/action) for navigating/executing steps. */
+    label?: string;
+}
 /** The reactive snapshot every framework binding renders. */
 export interface AgentState {
     phase: AgentPhase;
@@ -33,6 +46,12 @@ export interface AgentState {
     isBusy: boolean;
     isListening: boolean;
     lastExchange: AgentExchange | null;
+    /** Paged window of recent user+reply pairs while session memory is active. */
+    recentExchanges: AgentExchange[];
+    /** Older messages exist beyond the mounted window (scroll up to load them). */
+    hasOlderExchanges: boolean;
+    /** An older page is being loaded (show the loading row at the top). */
+    loadingOlderExchanges: boolean;
     /** Confirmation question to show in the modal, or null. */
     confirmationMessage: string | null;
     /** Visible-only hint for strict actions (the exact phrase), or null. */
@@ -40,6 +59,10 @@ export interface AgentState {
     consentModalVisible: boolean;
     /** Mic denied/unusable: the orb should fall back to the keyboard channel. */
     voiceBlocked: boolean;
+    /** Current REAL agent activity for the panel's live row (null when idle). */
+    liveActivity: AgentActivity | null;
+    /** An autonomous chain is running steps (keeps the live row visible between turns). */
+    chainActive: boolean;
 }
 export declare class AgentController {
     readonly config: FiodosWebAgentConfig;
@@ -52,6 +75,7 @@ export declare class AgentController {
     private readonly consent;
     private readonly executor;
     private readonly timings;
+    private readonly chaining;
     private readonly ttsLocale;
     private readonly speech;
     private readonly notifyError;
@@ -77,10 +101,32 @@ export declare class AgentController {
     private speakTimer;
     private serverTtsUnavailable;
     private pendingConsentIntent;
+    /** Parked chain state (set when a chain pauses on a sensitive action). */
+    private chainState;
+    /** REAL live activity for the panel (replaces the old canned walk-through). */
+    private liveActivity;
+    private chainActive;
+    /** How many exchanges the bubble currently mounts (grows one page at a time). */
+    private bubbleWindowSize;
+    /** Idle retention from the dashboard (undefined = 30-minute default). */
+    private conversationOptions;
+    /** Raw dashboard retention (minutes; 0 = never; null = default). Persisted
+     *  with the session so a restore applies the same expiry rule. */
+    private conversationRetentionMinutes;
+    /** Persistence scope: internal orbs keep their memory under a separate key
+     *  so a public orb sharing the same appId can never read it. */
+    private conversationScope;
+    private loadingOlderExchanges;
+    private loadOlderTimer;
     private readonly listeners;
     private unsubscribeSpeech;
     constructor(config: FiodosWebAgentConfig);
+    private restorePersistedConversation;
+    private persistConversation;
     getState(): AgentState;
+    /** Update the REAL live activity and re-render (no-op when unchanged). */
+    private setActivity;
+    private setChainActive;
     /** Whether speech recognition can actually run (API present AND mic not denied). */
     get voiceAvailable(): boolean;
     /** Unlock audio playback inside a user gesture (orb tap) so the spoken reply
@@ -90,6 +136,22 @@ export declare class AgentController {
     /** Flag the mic as denied/unusable (called on a permission error or upfront
      *  permission detection) so the orb routes taps to the keyboard instead. */
     markVoiceBlocked(blocked: boolean): void;
+    /**
+     * Page one more block of older session messages into the bubble (scroll-to-top).
+     * The mount is deferred behind a short loading state so old messages stream in
+     * on demand instead of all rendering at once (keeps the open bubble light).
+     */
+    loadOlderExchanges(): void;
+    /**
+     * Apply the dashboard's context-retention setting (minutes; 0 = never clear,
+     * null/undefined = the 30-minute default). Called when the published config
+     * arrives/refreshes, so the developer's choice is live without a reload.
+     * `expandedMemory` = INTERNAL orb profile: use the expanded conversation
+     * memory window (more literal turns + longer rolling summary per request).
+     */
+    setConversationRetention(minutes?: number | null, expandedMemory?: boolean): void;
+    /** Collapse the bubble history back to the initial page (bubble closed). */
+    resetBubbleWindow(): void;
     subscribe(listener: (state: AgentState) => void): () => void;
     private emit;
     setEnabled(value: boolean): void;
@@ -109,6 +171,22 @@ export declare class AgentController {
     confirmPendingAction(): Promise<void>;
     cancelPendingAction(): void;
     private handleConfirmationTranscript;
+    private routeLabel;
+    private actionLabel;
+    /**
+     * Resolve ONE backend turn into user-facing reply/audio: run its action (or
+     * stage its confirmation), emit telemetry, and report whether the autonomous
+     * chain may take another step. Shared by the first turn and every
+     * continuation so both follow the exact same security path — disabled
+     * capabilities, confidentiality and sensitive confirmations apply per step.
+     */
+    private applyOutcome;
+    /**
+     * The autonomous continuation loop. Extracted so confirmPendingAction can
+     * RESUME the SAME chain after a sensitive step is confirmed. Capped at
+     * maxSteps, with no-progress detection and sensitive-confirmation pauses.
+     */
+    private runChainLoop;
     private handleTranscript;
     private onTranscript;
     private onSpeechError;
@@ -119,7 +197,12 @@ export declare class AgentController {
     }): Promise<void>;
     acceptConsent(): Promise<void>;
     declineConsent(): void;
-    cancelAll(): void;
+    /**
+     * Cancel everything in flight. If a first turn was still awaiting its reply,
+     * its message is removed from the panel and returned here so the UI can put
+     * it back into the input for editing; null otherwise.
+     */
+    cancelAll(): string | null;
     /** Best-effort backend warm-up (cold-start mitigation). */
     warmUp(): void;
     dispose(): void;