@fiodos/web-core 0.1.10 → 0.1.12

package/dist/cjs/speech/bubbleDictation.js

@@ -0,0 +1,88 @@
+"use strict";
+/** Push-to-talk dictation for the text bubble input (Web Speech API). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollTextInputToEnd = scrollTextInputToEnd;
+exports.createBubbleDictation = createBubbleDictation;
+function speechRecognitionCtor() {
+    if (typeof window === 'undefined')
+        return null;
+    const w = window;
+    return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
+}
+function speechLocale(locale) {
+    return locale.toLowerCase().startsWith('es') ? 'es-ES' : 'en-US';
+}
+/** Keep the trailing dictation visible inside a single-line text input. */
+function scrollTextInputToEnd(input) {
+    const len = input.value.length;
+    try {
+        input.setSelectionRange(len, len);
+    }
+    catch {
+        /* read-only or unsupported */
+    }
+    input.scrollLeft = input.scrollWidth;
+}
+function createBubbleDictation(locale) {
+    const Ctor = speechRecognitionCtor();
+    let recognition = null;
+    let listening = false;
+    let baseText = '';
+    const stop = () => {
+        recognition?.stop();
+    };
+    const dispose = () => {
+        stop();
+        recognition = null;
+        listening = false;
+    };
+    return {
+        isSupported: () => Ctor != null,
+        isListening: () => listening,
+        stop,
+        dispose,
+        toggle(getValue, setValue) {
+            if (!Ctor)
+                return;
+            if (listening) {
+                stop();
+                return;
+            }
+            baseText = getValue();
+            const rec = new Ctor();
+            rec.lang = speechLocale(locale);
+            rec.interimResults = true;
+            rec.continuous = true;
+            let finalText = '';
+            rec.onresult = (event) => {
+                let interim = '';
+                for (let i = event.resultIndex; i < event.results.length; i += 1) {
+                    const result = event.results[i];
+                    if (!result)
+                        continue;
+                    const chunk = result[0]?.transcript ?? '';
+                    if (result.isFinal)
+                        finalText += chunk;
+                    else
+                        interim += chunk;
+                }
+                const dictated = `${finalText}${interim}`.trimStart();
+                const combined = baseText
+                    ? `${baseText}${baseText.endsWith(' ') ? '' : ' '}${dictated}`
+                    : dictated;
+                setValue(combined);
+            };
+            rec.onend = () => {
+                listening = false;
+                recognition = null;
+            };
+            rec.onerror = () => {
+                listening = false;
+                recognition = null;
+            };
+            recognition = rec;
+            listening = true;
+            rec.start();
+        },
+    };
+}

package/dist/cjs/ui/messages.d.ts

@@ -26,8 +26,23 @@ export interface WebUiMessages {
     keyboardChipLabel: string;
     /** Send button label for the text bubble. */
     sendLabel: string;
+    /** Mic button label for dictating into the text bubble. */
+    micLabel: string;
+    /** Mic button label while dictation is active. */
+    micStopLabel: string;
     /** Spoken/shown when the browser lacks speech recognition. */
     voiceUnavailable: string;
+    /**
+     * REAL live-activity labels for the chat panel (dashboard
+     * `agentThinkingStepsEnabled`). Unlike the old canned walk-through, each line
+     * is shown only when it is actually true: the request is in flight, a
+     * navigation/action from the manifest just ran (`{label}` interpolated), or
+     * the agent is waiting for the user's confirmation.
+     */
+    activityThinking: string;
+    activityNavigating: string;
+    activityExecuting: string;
+    activityWaitingConfirmation: string;
 }
 export interface ResolveUiMessagesOptions {
     catalogs?: Record<string, WebUiMessages>;

package/dist/cjs/ui/messages.js

@@ -13,7 +13,13 @@ const en = {
     textPlaceholder: 'Type a message…',
     keyboardChipLabel: 'Type instead of talking',
     sendLabel: 'Send',
+    micLabel: 'Dictate message',
+    micStopLabel: 'Stop dictating',
     voiceUnavailable: 'Voice input is not available in this browser. You can type instead.',
+    activityThinking: 'Thinking…',
+    activityNavigating: 'Navigating to {label}…',
+    activityExecuting: 'Running {label}…',
+    activityWaitingConfirmation: 'Waiting for your confirmation…',
 };
 const es = {
     orbLabel: 'Asistente de voz',
@@ -27,7 +33,13 @@ const es = {
     textPlaceholder: 'Escribe un mensaje…',
     keyboardChipLabel: 'Escribir en lugar de hablar',
     sendLabel: 'Enviar',
+    micLabel: 'Dictar mensaje',
+    micStopLabel: 'Detener dictado',
     voiceUnavailable: 'La entrada por voz no está disponible en este navegador. Puedes escribir.',
+    activityThinking: 'Pensando…',
+    activityNavigating: 'Navegando a {label}…',
+    activityExecuting: 'Ejecutando {label}…',
+    activityWaitingConfirmation: 'Esperando tu confirmación…',
 };
 const CATALOGS = { en, es };
 function baseLanguage(locale) {

package/dist/cjs/version.d.ts

@@ -5,5 +5,5 @@
  * Auto-generated by scripts/sync-sdk-version.mjs from package.json. Do not edit
  * by hand — change package.json `version` and re-run the sync/release script.
  */
-export declare const SDK_VERSION = "0.1.10";
+export declare const SDK_VERSION = "0.1.12";
 export declare const SDK_PACKAGE = "@fiodos/web-core";

package/dist/cjs/version.js

@@ -8,5 +8,5 @@ exports.SDK_PACKAGE = exports.SDK_VERSION = void 0;
  * Auto-generated by scripts/sync-sdk-version.mjs from package.json. Do not edit
  * by hand — change package.json `version` and re-run the sync/release script.
  */
-exports.SDK_VERSION = '0.1.10';
+exports.SDK_VERSION = '0.1.12';
 exports.SDK_PACKAGE = '@fiodos/web-core';

package/dist/esm/api/backendClient.js

@@ -115,6 +115,21 @@ export 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);
@@ -125,11 +140,16 @@ export function createFiodosBackendClient(options) {
             catch {
                 throw new 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: parseAgentAction(data.action),
                 wasTruncated: data.was_truncated === true,
+                taskStatus,
             };
         },
         async previewTts(voice, text) {

package/dist/esm/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;
 } | {
@@ -40,6 +56,12 @@ export interface FiodosWebAgentConfig {
     telemetry?: TelemetryAdapter;
     /** Host auth check, required by manifest actions declaring requiresAuth. */
     isAuthenticated?: () => boolean;
+    /**
+     * Host end-user identity. Conversation memory is namespaced per identity
+     * (hashed LOCALLY, never sent by this module): logout/account switches swap
+     * to that identity's own conversation instead of leaking the previous one.
+     */
+    getUserId?: () => string | null;
     messages?: {
         catalogs?: Record<string, MessageCatalog>;
         overrides?: Partial<AgentMessages>;
@@ -59,5 +81,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/esm/config/types.js

@@ -4,3 +4,8 @@ export const DEFAULT_AGENT_TIMINGS = {
     confirmationVoiceWindowMs: 8000,
     minTranscriptChars: 2,
 };
+export const DEFAULT_AGENT_CHAINING = {
+    enabled: false,
+    maxSteps: 6,
+    dwellMs: 450,
+};

package/dist/esm/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;
@@ -65,7 +89,7 @@ export declare class AgentController {
     private consentModalVisible;
     private readonly sessionId;
     private sessionStarted;
-    private readonly conversation;
+    private conversation;
     private pending;
     private confirmationReasked;
     private confirmationVoiceActive;
@@ -77,10 +101,52 @@ 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;
+    /** Current identity segment (LOCAL hash of the host's getUserId; never sent
+     *  anywhere). The conversation belongs to (app, scope, identity). */
+    private conversationIdentity;
+    private removeIdentityListeners;
+    private loadingOlderExchanges;
+    private loadOlderTimer;
     private readonly listeners;
     private unsubscribeSpeech;
     constructor(config: FiodosWebAgentConfig);
+    private restorePersistedConversation;
+    private persistConversation;
+    /**
+     * Re-evaluates the host identity and, when it changed, swaps conversations:
+     * the outgoing identity's session is saved under ITS private key (so a user
+     * who logs back in recovers it, honouring "never clear"), all in-memory
+     * state and UI are wiped, and the incoming identity's own session (usually
+     * empty) is restored. An anonymous visitor after a logout always starts
+     * clean — the previous user's transcript is never inherited.
+     */
+    private syncConversationIdentity;
+    /**
+     * Wipes the CURRENT identity's conversation: live memory, panel and the
+     * persisted blob. Hosts can call it from their logout for a hard wipe (by
+     * default a logout only parks the conversation under the user's private
+     * local key).
+     */
+    resetConversation(): void;
     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 +156,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 +191,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 +217,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;