@fiodos/web-core 0.1.19 → 0.1.21

package/dist/cjs/api/backendClient.js

@@ -151,6 +151,9 @@ function createFiodosBackendClient(options) {
                         intent: request.lastStep.intent,
                         ...(request.lastStep.label ? { label: request.lastStep.label } : {}),
                         success: request.lastStep.success,
+                        // Technical error of a FAILED step: the backend renders it in the
+                        // RECOVERY block so the model can diagnose and change path.
+                        ...(request.lastStep.error ? { error: request.lastStep.error } : {}),
                         // Bounded result payload of the executed step (product search
                         // results…): the backend renders it so the model can read real
                         // ids for the NEXT step's parameters.

package/dist/cjs/api/backendTelemetry.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFiodosTelemetry = createFiodosTelemetry;
+/** Bound on the technical error string shipped with action_failed events. */
+const MAX_ERROR_DETAIL_CHARS = 200;
 function mapEvent(params) {
     const intent = params.intentDetected ?? null;
     const sessionId = params.sessionId ?? null;
@@ -16,6 +18,19 @@ function mapEvent(params) {
             }
             return events;
         }
+        // Failures are the events that make field reports diagnosable: without
+        // them, "the orb said it couldn't do it" leaves the developer blind. Only
+        // the technical error string travels (HTTP status + path, template
+        // param…), never any message content.
+        case 'action_failed':
+            return [
+                {
+                    type: 'action_failed',
+                    intent,
+                    session_id: sessionId,
+                    error: (params.errorDetail ?? '').slice(0, MAX_ERROR_DETAIL_CHARS) || null,
+                },
+            ];
         case 'action_confirmation_requested':
             return [{ type: 'confirmation_requested', intent, session_id: sessionId }];
         default:

package/dist/cjs/controller/AgentController.js

@@ -28,6 +28,13 @@ const speechSession_1 = require("../speech/speechSession");
 const turnEngine_1 = require("../core/turnEngine");
 const types_1 = require("../config/types");
 const messages_1 = require("../ui/messages");
+/**
+ * How many FAILED-step recovery turns one chain may consume. A failed action
+ * (invented handle → 404, wrong id kind → 422, transient 5xx) no longer kills
+ * the task: the model gets the technical error back and picks a different
+ * path — bounded so a persistently failing action can never loop.
+ */
+const MAX_CHAIN_RECOVERIES = 2;
 function randomSessionId() {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -494,7 +501,11 @@ class AgentController {
             intentDetected: pending.intent,
             sessionId: this.sessionId,
             actionExecuted: { intent: pending.intent, confirmed: true },
+            ...(!result.success ? { errorDetail: result.error ?? null } : {}),
         });
+        if (!result.success) {
+            console.warn(`[fyodos] action "${pending.intent}" failed: ${result.error ?? 'unknown error'}`);
+        }
         if (result.message) {
             if (this.lastExchange)
                 this.lastExchange = { ...this.lastExchange, replyText: result.message };
@@ -521,6 +532,28 @@ class AgentController {
                     step: chainState.step,
                     lastStep: chainState.pendingStep ?? chainState.lastStep,
                     visitedKeys: chainState.visitedKeys,
+                    recoveries: chainState.recoveries,
+                });
+            }
+            else if (!result.success && this.chaining.enabled) {
+                // The CONFIRMED action failed: same recovery contract as any other
+                // failed step — the model reads the technical error and takes a
+                // different path (bounded by the recovery budget). The user's
+                // confirmation covered THIS intent; a recovery that re-attempts it
+                // stages a NEW confirmation, so the human gate is never bypassed.
+                const failedStep = {
+                    type: 'execute',
+                    intent: pending.intent,
+                    label: this.actionLabel(pending.intent),
+                    success: false,
+                    ...(result.error ? { error: String(result.error).slice(0, 300) } : {}),
+                };
+                await this.runChainLoop({
+                    userMessage: chainState.userMessage,
+                    step: chainState.step,
+                    lastStep: failedStep,
+                    visitedKeys: chainState.visitedKeys,
+                    recoveries: (chainState.recoveries ?? 0) + 1,
                 });
             }
             else if (!result.success) {
@@ -688,6 +721,7 @@ class AgentController {
         let pendingInProgress = false;
         let pendingStep;
         let pendingKey;
+        let stepFailed = false;
         if (decision.kind === 'executed') {
             const r = decision.result;
             // REAL activity for the panel: this action actually just ran — the
@@ -722,6 +756,7 @@ class AgentController {
                     intentDetected: turn.action.intent,
                     sessionId: this.sessionId,
                     actionExecuted: { intent: turn.action.intent, confirmed: false },
+                    ...(!r.success && !r.recoverable ? { errorDetail: r.error ?? null } : {}),
                 });
             }
             if (r.recoverable) {
@@ -744,6 +779,30 @@ class AgentController {
                 outReply = this.messages.actionFailed;
                 outAudio = null;
             }
+            if (!r.success) {
+                // Developer signal: the user only hears a generic failure phrase; the
+                // TECHNICAL cause (HTTP status + path, missing template param…) must
+                // be findable in the console or every field report is undebuggable.
+                console.warn(`[fyodos] action "${turn.action?.intent ?? '?'}" failed: ${r.error ?? 'unknown error'}`);
+            }
+            // RECOVERY signal: the step RAN and FAILED (not a recoverable guidance
+            // case). Feed the technical error back as a failed lastStep so the model
+            // can diagnose (invented handle → 404, wrong id kind → 422…) and take a
+            // DIFFERENT path, exactly like a human agent. The chain loop bounds how
+            // many of these turns run (MAX_CHAIN_RECOVERIES); task_status is
+            // irrelevant here — the model believed the step would succeed.
+            if (turn.action?.type === 'execute' && !r.success && !r.recoverable) {
+                const intent = turn.action.intent ?? '';
+                lastStep = {
+                    type: 'execute',
+                    intent,
+                    label: this.actionLabel(intent),
+                    success: false,
+                    ...(r.error ? { error: String(r.error).slice(0, 300) } : {}),
+                };
+                stepFailed = true;
+                canContinue = this.chaining.enabled;
+            }
             // Chain signal: only a cleanly EXECUTED, non-recoverable step may advance,
             // and only when the backend asked to continue (task_status=in_progress).
             if (turn.action &&
@@ -819,6 +878,7 @@ class AgentController {
             pendingInProgress,
             pendingStep,
             pendingKey,
+            stepFailed,
         };
     }
     /**
@@ -829,6 +889,7 @@ class AgentController {
     async runChainLoop(state) {
         let step = state.step;
         let lastStep = state.lastStep;
+        let recoveries = state.recoveries ?? 0;
         const visitedKeys = state.visitedKeys;
         // Keep the panel's live row visible for the WHOLE chain (including the
         // dwell between steps), so the real narration never flickers away.
@@ -925,6 +986,7 @@ class AgentController {
                             visitedKeys,
                             pendingKey: oc.pendingKey,
                             pendingStep: oc.pendingStep,
+                            recoveries,
                         }
                         : null;
                     this.beginConfirmationVoiceWindow();
@@ -932,6 +994,21 @@ class AgentController {
                 }
                 if (this.phase !== 'speaking')
                     this.setPhase('idle');
+                // Failed step: consume one recovery slot. The budget is what keeps a
+                // persistently failing action from looping; a chain that exhausts it
+                // ends with the (honest) failure reply already on screen.
+                if (oc.stepFailed) {
+                    recoveries += 1;
+                    if (recoveries > MAX_CHAIN_RECOVERIES) {
+                        this.telemetry.logEvent({
+                            eventType: 'agent_chain_aborted',
+                            sessionId: this.sessionId,
+                            chainStep: step,
+                            chainAbortReason: 'no_progress',
+                        });
+                        return;
+                    }
+                }
                 if (oc.actionKey && visitedKeys.has(oc.actionKey)) {
                     this.telemetry.logEvent({
                         eventType: 'agent_chain_aborted',
@@ -1114,7 +1191,8 @@ class AgentController {
             this.setPhase('idle');
         }
         // Kick off the autonomous chain when the first step executed cleanly and
-        // the backend asked to continue (no sensitive confirmation pending).
+        // the backend asked to continue (no sensitive confirmation pending) — or
+        // when the first step FAILED and a recovery turn should diagnose it.
         if (this.chaining.enabled && outcome.canContinue && !hasPending) {
             this.telemetry.logEvent({
                 eventType: 'agent_chain_started',
@@ -1129,6 +1207,7 @@ class AgentController {
                 step: 1,
                 lastStep: outcome.lastStep,
                 visitedKeys,
+                recoveries: outcome.stepFailed ? 1 : 0,
             });
         }
         // Final reply is on screen: the live narrative disappears (unless the

package/dist/cjs/embed/global.d.ts

@@ -27,7 +27,7 @@ import { createScreenContextStore } from '../context/screenContextStore';
 import { connectDynamicsFormContext, dynamicsFormSnapshot, normalizeDynamicsId } from './dynamics';
 import { buildApiActionRegistries, validateManifest } from '@fiodos/core';
 declare const api: {
-    readonly version: "0.1.19";
+    readonly version: "0.1.21";
     readonly createFiodosAgent: typeof createFiodosAgent;
     readonly mountOrb: typeof mountOrb;
     readonly AgentController: typeof AgentController;

package/dist/cjs/orb/mountOrb.js

@@ -57,6 +57,8 @@ const CSS = `
 .fyodos-bubble-exchange:first-child .fyodos-bubble-user{padding-right:22px;}
 .fyodos-bubble-user{flex:1;min-width:0;font-size:13px;line-height:18px;opacity:.75;}
 .fyodos-bubble-reply{font-size:15px;line-height:21px;white-space:pre-wrap;}
+.fyodos-bubble-greeting{font-size:15px;line-height:21px;white-space:pre-wrap;animation:fyodos-fade-in .18s ease-out;}
+.fyodos-bubble--expanded .fyodos-bubble-greeting{font-size:17px;line-height:25px;}
 .fyodos-bubble-busy{display:flex;gap:5px;padding:8px 14px;align-items:center;}
 .fyodos-bubble-busy span{width:6px;height:6px;border-radius:50%;opacity:.5;animation:fyodos-blink 1s infinite;}
 .fyodos-bubble-busy span:nth-child(2){animation-delay:.18s;}
@@ -210,13 +212,9 @@ function mountOrb(controller, options = {}) {
         haptics.trigger('orbTap');
         controller.primeAudio();
         if (enableTextInput) {
-            const prompt = resolveCurrentBubblePrompt();
-            openTextPanel(prompt
-                ? (0, core_1.bubblePromptToAffirmative)(prompt, {
-                    locale: currentBubbleLocale(),
-                    messages: controller.messages,
-                })
-                : undefined);
+            // The bubble's question moves INTO the panel as an assistant greeting
+            // (openTextPanel shows it) — never pre-typed into the user's input.
+            openTextPanel();
             return;
         }
         userTriedVoice = true;
@@ -458,7 +456,30 @@ function mountOrb(controller, options = {}) {
     loaderRow.style.display = 'none';
     const exchangeList = document.createElement('div');
     exchangeList.className = 'fyodos-bubble-exchanges';
-    exchangeScroll.append(loaderRow, exchangeList);
+    // Screen-aware GREETING: the thought bubble's question, shown INSIDE the
+    // panel as an assistant message when it opens (tapping the bubble or opening
+    // the chat traditionally). Ephemeral by design: it never enters the
+    // conversation history and disappears the moment the user sends a message.
+    const greetingEl = document.createElement('div');
+    greetingEl.className = 'fyodos-bubble-greeting';
+    greetingEl.style.display = 'none';
+    exchangeScroll.append(loaderRow, exchangeList, greetingEl);
+    function showPanelGreeting() {
+        const prompt = resolveCurrentBubblePrompt();
+        if (!prompt) {
+            greetingEl.style.display = 'none';
+            return;
+        }
+        const t = { ...DEFAULT_MODAL_THEME, ...(modalTheme ?? {}) };
+        greetingEl.textContent = prompt;
+        greetingEl.style.color = t.titleColor;
+        greetingEl.style.display = '';
+        exchangeScroll.scrollTop = exchangeScroll.scrollHeight;
+    }
+    function hidePanelGreeting() {
+        if (greetingEl.style.display !== 'none')
+            greetingEl.style.display = 'none';
+    }
     // Signature of the rendered list so state emits that do not change the
     // transcript (volume, phase…) never re-render it nor fight the user's scroll.
     let renderedSignature = '';
@@ -752,6 +773,8 @@ function mountOrb(controller, options = {}) {
         else {
             bubbleDictation.stop();
             syncMicButton();
+            // Ephemeral greeting never survives a close (recomputed on next open).
+            hidePanelGreeting();
             // Collapse the paged history back to the initial page for the next open.
             controller.resetBubbleWindow();
             // Closing the panel returns the orb to idle (also clears mic fallback).
@@ -781,6 +804,9 @@ function mountOrb(controller, options = {}) {
         syncMicButton();
         haptics.trigger('send');
         textInput.value = '';
+        // The greeting is a welcome, not part of the conversation: the user's
+        // first real message replaces it.
+        hidePanelGreeting();
         // Silent turn: the reply is SHOWN in the bubble (not spoken), and the bubble
         // STAYS OPEN. This is the unified, reference-matching behaviour.
         void controller.submitTextTurn(value);
@@ -793,6 +819,11 @@ function mountOrb(controller, options = {}) {
         const draft = explicitSeed || cancelled || '';
         textInput.value = draft;
         setBubble(true);
+        // Welcome the user with this screen's bubble question as an assistant
+        // message (both open paths: bubble tap AND traditional open). It vanishes
+        // with the user's first message — never enters the history.
+        if (!draft)
+            showPanelGreeting();
         // Only an explicit seed may auto-send; a restored cancelled message must
         // wait for the user to edit/resend it.
         if (autoSend && explicitSeed) {
@@ -1156,6 +1187,9 @@ function mountOrb(controller, options = {}) {
         syncActivityStep(rowBusy, state);
         // Text bubble: show recent exchanges + busy state.
         if (bubbleOpen) {
+            // A turn in flight (typed OR voice) replaces the ephemeral greeting.
+            if (state.isBusy)
+                hidePanelGreeting();
             loaderRow.style.display = state.loadingOlderExchanges ? 'flex' : 'none';
             renderBubbleExchanges(state.recentExchanges);
             exchangeScroll.style.display = 'flex';

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.19";
+export declare const SDK_VERSION = "0.1.21";
 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.19';
+exports.SDK_VERSION = '0.1.21';
 exports.SDK_PACKAGE = '@fiodos/web-core';