@fiodos/web-core 0.1.19 → 0.1.21

package/dist/esm/api/backendClient.js

@@ -147,6 +147,9 @@ export 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/esm/api/backendTelemetry.js

@@ -1,3 +1,5 @@
+/** 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;
@@ -13,6 +15,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/esm/controller/AgentController.js

@@ -25,6 +25,13 @@ import { createSpeechSession } from '../speech/speechSession.js';
 import { classifyPendingReply, decideAction, } from '../core/turnEngine.js';
 import { DEFAULT_AGENT_TIMINGS, DEFAULT_AGENT_CHAINING, } from '../config/types.js';
 import { resolveUiMessages } from '../ui/messages.js';
+/**
+ * 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)}`;
 }
@@ -491,7 +498,11 @@ export 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 };
@@ -518,6 +529,28 @@ export 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) {
@@ -685,6 +718,7 @@ export 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
@@ -719,6 +753,7 @@ export 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) {
@@ -741,6 +776,30 @@ export 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 &&
@@ -816,6 +875,7 @@ export class AgentController {
             pendingInProgress,
             pendingStep,
             pendingKey,
+            stepFailed,
         };
     }
     /**
@@ -826,6 +886,7 @@ export 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.
@@ -922,6 +983,7 @@ export class AgentController {
                             visitedKeys,
                             pendingKey: oc.pendingKey,
                             pendingStep: oc.pendingStep,
+                            recoveries,
                         }
                         : null;
                     this.beginConfirmationVoiceWindow();
@@ -929,6 +991,21 @@ export 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',
@@ -1111,7 +1188,8 @@ export 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',
@@ -1126,6 +1204,7 @@ export 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/esm/embed/global.d.ts

@@ -27,7 +27,7 @@ import { createScreenContextStore } from '../context/screenContextStore.js';
 import { connectDynamicsFormContext, dynamicsFormSnapshot, normalizeDynamicsId } from './dynamics.js';
 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/esm/orb/mountOrb.js

@@ -16,7 +16,7 @@
  *  - CONFIRMATIONS: the same security model (manifest decides; strict phrase /
  *    deliberate tap for payment-grade; loose "yes" never resolves strict).
  */
-import { DEFAULT_ORB_SCREEN_POSITION, createWebOrbHaptics, matchRouteIntent, resolveBubblePrompt, bubblePromptToAffirmative, resolveBubbleTheme, resolveBubblePadding, bubbleShapeToCss, applyBubbleShapeCss, resolveOrbAnchorPx, resolveOrbDeployment, snapOrbScreenPositionToSide, viewportPixelsToOrbScreenPosition, fiodosInputInkColor, fiodosInputMutedInkColor, shouldHideInternalOrb, } from '@fiodos/core';
+import { DEFAULT_ORB_SCREEN_POSITION, createWebOrbHaptics, matchRouteIntent, resolveBubblePrompt, resolveBubbleTheme, resolveBubblePadding, bubbleShapeToCss, applyBubbleShapeCss, resolveOrbAnchorPx, resolveOrbDeployment, snapOrbScreenPositionToSide, viewportPixelsToOrbScreenPosition, fiodosInputInkColor, fiodosInputMutedInkColor, shouldHideInternalOrb, } from '@fiodos/core';
 import { buildKeyboardChip, createOrbVisual, DEFAULT_ORB_APPEARANCE, } from './orbView.js';
 import { watchPublishedConfig } from './publishedConfig.js';
 import { createBubbleDictation, scrollTextInputToEnd } from '../speech/bubbleDictation.js';
@@ -54,6 +54,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;}
@@ -207,13 +209,9 @@ export function mountOrb(controller, options = {}) {
         haptics.trigger('orbTap');
         controller.primeAudio();
         if (enableTextInput) {
-            const prompt = resolveCurrentBubblePrompt();
-            openTextPanel(prompt
-                ? 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;
@@ -455,7 +453,30 @@ export 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 = '';
@@ -749,6 +770,8 @@ export 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).
@@ -778,6 +801,9 @@ export 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);
@@ -790,6 +816,11 @@ export 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) {
@@ -1153,6 +1184,9 @@ export 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/esm/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/esm/version.js

@@ -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 const SDK_VERSION = '0.1.19';
+export const SDK_VERSION = '0.1.21';
 export const SDK_PACKAGE = '@fiodos/web-core';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiodos/web-core",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Framework-agnostic browser layer for the Fiodos agent: a vanilla AgentController (orchestrator), DOM adapters (navigation/voice/storage), HTTP client and decision engine over @fiodos/core. Shared base for @fiodos/vue, @fiodos/svelte and @fiodos/angular (no framework imports).",
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {