@fiodos/web-core 0.1.17 → 0.1.19

package/dist/esm/api/anonUserId.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Stable per-browser ANONYMOUS caller id, sent as `x-user-id` when the host
+ * app provides no getUserId (public storefronts, marketing sites…).
+ *
+ * Why: the backend's fairness rate-limit buckets anonymous callers by source
+ * IP. Behind shopper NATs / proxies that means MANY real visitors share one
+ * bucket and an active session can starve itself into 429 ("Too many
+ * requests"). A random per-browser id gives each visitor their own fairness
+ * bucket without identifying anyone: it is random, local, never derived from
+ * personal data, and never used for conversation identity (that stays 'anon').
+ */
+/** Returns the stable anonymous caller id for this browser (creates it once). */
+export declare function getAnonCallerId(): string;
+/**
+ * Wraps the host's getUserId so anonymous visitors still send a stable
+ * per-browser caller id for rate-limit fairness. The host's real user id
+ * always wins when present.
+ */
+export declare function withAnonCallerFallback(getUserId?: () => string | null): () => string | null;

package/dist/esm/api/anonUserId.js

@@ -0,0 +1,59 @@
+/**
+ * Stable per-browser ANONYMOUS caller id, sent as `x-user-id` when the host
+ * app provides no getUserId (public storefronts, marketing sites…).
+ *
+ * Why: the backend's fairness rate-limit buckets anonymous callers by source
+ * IP. Behind shopper NATs / proxies that means MANY real visitors share one
+ * bucket and an active session can starve itself into 429 ("Too many
+ * requests"). A random per-browser id gives each visitor their own fairness
+ * bucket without identifying anyone: it is random, local, never derived from
+ * personal data, and never used for conversation identity (that stays 'anon').
+ */
+const STORAGE_KEY = 'fyodos:anon-caller:v1';
+let inMemoryId = null;
+function randomId() {
+    try {
+        const c = globalThis.crypto;
+        if (c?.randomUUID)
+            return `anon-${c.randomUUID()}`;
+    }
+    catch {
+        /* fall through */
+    }
+    return `anon-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+}
+/** Returns the stable anonymous caller id for this browser (creates it once). */
+export function getAnonCallerId() {
+    if (inMemoryId)
+        return inMemoryId;
+    try {
+        const stored = window.localStorage.getItem(STORAGE_KEY);
+        if (stored) {
+            inMemoryId = stored;
+            return stored;
+        }
+        const fresh = randomId();
+        window.localStorage.setItem(STORAGE_KEY, fresh);
+        inMemoryId = fresh;
+        return fresh;
+    }
+    catch {
+        // Private mode / storage blocked: keep a per-page-load id (still better
+        // than sharing the IP bucket with every other visitor).
+        inMemoryId = inMemoryId ?? randomId();
+        return inMemoryId;
+    }
+}
+/**
+ * Wraps the host's getUserId so anonymous visitors still send a stable
+ * per-browser caller id for rate-limit fairness. The host's real user id
+ * always wins when present.
+ */
+export function withAnonCallerFallback(getUserId) {
+    return () => {
+        const real = getUserId?.();
+        if (real)
+            return real;
+        return getAnonCallerId();
+    };
+}

package/dist/esm/api/backendClient.js

@@ -57,7 +57,13 @@ async function errorFromResponse(res) {
         return new AgentApiError('unauthorized', detail, res.status);
     }
     if (res.status === 429) {
-        const quotaSignal = typeof body.remaining === 'number' || (detail ?? '').toLowerCase().includes('quota');
+        // The backend marks plan/budget 429s with error:"quota_exceeded" (rate
+        // limits carry error:"rate_limited"); the detail/remaining checks cover
+        // older backends. Getting this right matters: a quota 429 shown as "too
+        // many requests" sends the developer chasing rate limits that are fine.
+        const quotaSignal = body.error === 'quota_exceeded' ||
+            typeof body.remaining === 'number' ||
+            (detail ?? '').toLowerCase().includes('quota');
         return new AgentApiError(quotaSignal ? 'quota_exceeded' : 'rate_limited', detail, res.status);
     }
     if (res.status === 404)

package/dist/esm/api/clientBootstrap.d.ts

@@ -33,6 +33,7 @@ export declare function fetchClientManifest(opts: {
     baseUrl: string;
     apiKey: string;
 }): Promise<ManifestBootstrapResult>;
+export declare function markEmbedDistribution(): void;
 /**
  * Best-effort heartbeat proving the orb booted. Never throws and never blocks
  * the orb — failures are swallowed (the dashboard simply won't flip to ✓).

package/dist/esm/api/clientBootstrap.js

@@ -37,11 +37,21 @@ export async function fetchClientManifest(opts) {
     }
     return { status: 'ready', manifest: data.manifest };
 }
+/**
+ * Set by the embed bundle entrypoint (dist/embed/fiodos-embed.js). Embeds are
+ * loaded from a CDN `@latest` URL (Shopify themes, Dynamics…), so they update
+ * THEMSELVES — the heartbeat marks them so the dashboard never shows an
+ * "update available / npm install" notice the developer cannot act on.
+ */
+let embedDistribution = false;
+export function markEmbedDistribution() {
+    embedDistribution = true;
+}
 function detectPlatform() {
-    if (typeof navigator !== 'undefined' && /Mobi|Android|iPhone|iPad/i.test(navigator.userAgent)) {
-        return 'web-mobile';
-    }
-    return 'web';
+    const mobile = typeof navigator !== 'undefined' && /Mobi|Android|iPhone|iPad/i.test(navigator.userAgent);
+    if (embedDistribution)
+        return mobile ? 'web-embed-mobile' : 'web-embed';
+    return mobile ? 'web-mobile' : 'web';
 }
 /**
  * Best-effort heartbeat proving the orb booted. Never throws and never blocks

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

@@ -18,14 +18,20 @@ export interface AgentTimings {
 }
 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
+ * Autonomous multi-step chaining. ON by default: 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).
+ *
+ * Default ON is a product invariant, not a tuning choice: data actions
+ * (search, get-cart…) are INVISIBLE — without the continuation turn the orb
+ * runs them and then goes silent ("I'll look for products…" and nothing
+ * happens). Every install (embeds included, which pass no config) must get
+ * the full act→observe→act loop. Pass `chaining: { enabled: false }` to opt
+ * out and return to one-action-per-turn.
  */
 export interface AgentChaining {
-    /** Master switch. Default false (retrocompatible, one action per turn). */
+    /** Master switch. Default true (the agent completes multi-step tasks). */
     enabled: boolean;
     /** Hard cap on steps per user request (safety). Default 6. */
     maxSteps: number;

package/dist/esm/config/types.js

@@ -5,7 +5,7 @@ export const DEFAULT_AGENT_TIMINGS = {
     minTranscriptChars: 2,
 };
 export const DEFAULT_AGENT_CHAINING = {
-    enabled: false,
+    enabled: true,
     maxSteps: 6,
     dwellMs: 450,
 };

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

@@ -104,6 +104,12 @@ export declare class AgentController {
     private pendingConsentIntent;
     /** Parked chain state (set when a chain pauses on a sensitive action). */
     private chainState;
+    /**
+     * Intent whose showcase escort was DEFERRED mid-chain (suppressEscort):
+     * flushed when the chain ends so the user is walked to where the last
+     * action's effect is visible — never in the middle of a running chain.
+     */
+    private deferredEscortIntent;
     /** REAL live activity for the panel (replaces the old canned walk-through). */
     private liveActivity;
     private chainActive;
@@ -221,6 +227,13 @@ export declare class AgentController {
      * maxSteps, with no-progress detection and sensitive-confirmation pauses.
      */
     private runChainLoop;
+    /**
+     * Runs the showcase escort that was deferred while the chain was executing
+     * (see suppressEscort in applyOutcome). Skipped while a confirmation is
+     * pending: the chain may resume after the user answers, and the confirmed
+     * action escorts on its own.
+     */
+    private flushDeferredEscort;
     private handleTranscript;
     private onTranscript;
     private onSpeechError;

package/dist/esm/controller/AgentController.js

@@ -60,6 +60,12 @@ export class AgentController {
         this.pendingConsentIntent = null;
         /** Parked chain state (set when a chain pauses on a sensitive action). */
         this.chainState = null;
+        /**
+         * Intent whose showcase escort was DEFERRED mid-chain (suppressEscort):
+         * flushed when the chain ends so the user is walked to where the last
+         * action's effect is visible — never in the middle of a running chain.
+         */
+        this.deferredEscortIntent = null;
         /** REAL live activity for the panel (replaces the old canned walk-through). */
         this.liveActivity = null;
         this.chainActive = false;
@@ -539,6 +545,7 @@ export class AgentController {
         // Declining a sensitive action stops any chain it was part of, cleanly.
         const chainState = this.chainState;
         this.chainState = null;
+        this.deferredEscortIntent = null;
         if (chainState) {
             this.telemetry.logEvent({
                 eventType: 'agent_chain_aborted',
@@ -658,6 +665,10 @@ export class AgentController {
         let outAudio = turn.audioBase64;
         if (outReply)
             this.serverTtsUnavailable = !outAudio;
+        // Mid-chain: hold the showcase escort. On multi-page hosts (Shopify
+        // embeds) the escort is a full page load that would kill the chain
+        // before its continuation turn; the chain escorts once when it ends.
+        const escortDeferred = this.chaining.enabled && turn.taskStatus === 'in_progress';
         const decision = await decideAction({
             action: turn.action,
             manifest: this.config.manifest,
@@ -665,6 +676,7 @@ export class AgentController {
             context: snapshotContext,
             messages: this.messages,
             userMessage,
+            suppressEscort: escortDeferred,
         });
         let canContinue = false;
         let lastStep;
@@ -735,6 +747,15 @@ export class AgentController {
                 (turn.action.type === 'navigate' || turn.action.type === 'execute') &&
                 r.success &&
                 !r.recoverable) {
+                // Deferred-escort bookkeeping: remember the intent whose escort was
+                // held (flushed at chain end); a navigate — or an execute whose escort
+                // already ran inside the executor — supersedes any earlier deferral.
+                if (turn.action.type === 'execute') {
+                    this.deferredEscortIntent = escortDeferred ? (turn.action.intent ?? null) : null;
+                }
+                else {
+                    this.deferredEscortIntent = null;
+                }
                 const intent = turn.action.intent ?? '';
                 // Feed the step's RESULT DATA back to the next chain turn (bounded):
                 // it is how the model reads real technical values (variant ids, line
@@ -938,8 +959,23 @@ export class AgentController {
         }
         finally {
             this.setChainActive(false);
+            this.flushDeferredEscort();
         }
     }
+    /**
+     * Runs the showcase escort that was deferred while the chain was executing
+     * (see suppressEscort in applyOutcome). Skipped while a confirmation is
+     * pending: the chain may resume after the user answers, and the confirmed
+     * action escorts on its own.
+     */
+    flushDeferredEscort() {
+        if (this.pending != null)
+            return;
+        const intent = this.deferredEscortIntent;
+        this.deferredEscortIntent = null;
+        if (intent)
+            this.executor.escortForIntent(intent);
+    }
     // ── Main turn ────────────────────────────────────────────────────────────────
     async handleTranscript(rawText) {
         const text = rawText.trim();
@@ -1223,6 +1259,7 @@ export class AgentController {
         this.config.voice.stopPlayback();
         this.pending = null;
         this.chainState = null;
+        this.deferredEscortIntent = null;
         this.confirmationMessage = null;
         this.confirmationVoiceHint = null;
         this.liveActivity = null;

package/dist/esm/core/turnEngine.d.ts

@@ -52,6 +52,12 @@ export interface DecideActionParams {
     context: AgentScreenContext;
     messages: AgentMessages;
     userMessage: string;
+    /**
+     * Skip the post-action showcase escort (mid-chain steps): on multi-page
+     * hosts the escort is a full page load that would kill the running chain.
+     * The orchestrator escorts once at the END of the chain.
+     */
+    suppressEscort?: boolean;
 }
 /**
  * Decides what to do with a backend-proposed action. Sensitive actions are

package/dist/esm/core/turnEngine.js

@@ -27,7 +27,7 @@ function findManifestAction(manifest, intent) {
  * never executed here — they return `needs-confirmation`.
  */
 export async function decideAction(params) {
-    const { action, manifest, executor, context, messages, userMessage } = params;
+    const { action, manifest, executor, context, messages, userMessage, suppressEscort } = params;
     if (!action || action.type === 'none') {
         return { kind: 'noop' };
     }
@@ -39,7 +39,7 @@ export async function decideAction(params) {
         const manifestAction = findManifestAction(manifest, action.intent);
         const needsConfirmation = manifestAction?.requireConfirmation === true;
         if (!needsConfirmation) {
-            const result = await executor.execute(action, context);
+            const result = await executor.execute(action, context, { suppressEscort });
             return { kind: 'executed', result };
         }
         // Precheck (context + idempotency) BEFORE asking: applying an already-applied

package/dist/esm/dropin/createFiodosAgent.js

@@ -21,6 +21,7 @@ import { AgentController } from '../controller/AgentController.js';
 import { mountOrb } from '../orb/mountOrb.js';
 import { showOrbDevError } from '../orb/devErrorBadge.js';
 import { DEFAULT_WEB_API_URL, fetchClientManifest, sendOrbSeen } from '../api/clientBootstrap.js';
+import { withAnonCallerFallback } from '../api/anonUserId.js';
 function defaultNavigate(route) {
     if (typeof window !== 'undefined' && window.location)
         window.location.assign(route);
@@ -60,15 +61,18 @@ function assemble(options, manifest, baseUrl) {
     const fallback = browserLocale();
     const locale = resolveAgentLocale(options);
     const sttLocale = options.sttLocale ?? options.locale ?? fallback.sttLocale;
+    // Rate-limit fairness: anonymous visitors still send a stable per-browser
+    // caller id (never used for conversation identity — that stays 'anon').
+    const callerId = withAnonCallerFallback(options.getUserId);
     const backend = createFiodosBackendClient({
         baseUrl,
         apiKey: options.apiKey,
-        getUserId: options.getUserId,
+        getUserId: callerId,
     });
     const telemetry = createFiodosTelemetry({
         baseUrl,
         apiKey: options.apiKey,
-        getUserId: options.getUserId,
+        getUserId: callerId,
     });
     const config = {
         manifest,

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.17";
+    readonly version: "0.1.19";
     readonly createFiodosAgent: typeof createFiodosAgent;
     readonly mountOrb: typeof mountOrb;
     readonly AgentController: typeof AgentController;

package/dist/esm/embed/global.js

@@ -26,7 +26,11 @@ import { AgentController } from '../controller/AgentController.js';
 import { createScreenContextStore } from '../context/screenContextStore.js';
 import { connectDynamicsFormContext, dynamicsFormSnapshot, normalizeDynamicsId, } from './dynamics.js';
 import { SDK_VERSION } from '../version.js';
+import { markEmbedDistribution } from '../api/clientBootstrap.js';
 import { buildApiActionRegistries, validateManifest } from '@fiodos/core';
+// This bundle is served from a CDN `@latest` URL and updates itself: mark the
+// heartbeat so the dashboard never shows an npm update command for it.
+markEmbedDistribution();
 const api = {
     version: SDK_VERSION,
     createFiodosAgent,

package/dist/esm/speech/bubbleDictation.js

@@ -25,12 +25,29 @@ export function createBubbleDictation(locale) {
     let listening = false;
     let baseText = '';
     const stop = () => {
-        recognition?.stop();
+        const rec = recognition;
+        if (!rec)
+            return;
+        // DISCARD-ON-STOP: recognition engines fire one last consolidated
+        // `onresult` AFTER stop() is requested. If the user hits send while still
+        // dictating, that late result would rewrite the input we just cleared and
+        // the message would reappear (duplicate-send bug). Once a stop is
+        // requested, nothing may ever write to the input again.
+        rec.onresult = null;
+        recognition = null;
+        listening = false;
+        try {
+            if (typeof rec.abort === 'function')
+                rec.abort();
+            else
+                rec.stop();
+        }
+        catch {
+            /* already stopped */
+        }
     };
     const dispose = () => {
         stop();
-        recognition = null;
-        listening = false;
     };
     return {
         isSupported: () => Ctor != null,
@@ -68,11 +85,18 @@ export function createBubbleDictation(locale) {
                     : dictated;
                 setValue(combined);
             };
+            // Identity-guarded teardown: a session stopped via stop() may fire its
+            // onend AFTER the user already started a NEW dictation — it must never
+            // tear down the new session.
             rec.onend = () => {
+                if (recognition !== rec)
+                    return;
                 listening = false;
                 recognition = null;
             };
             rec.onerror = () => {
+                if (recognition !== rec)
+                    return;
                 listening = false;
                 recognition = null;
             };

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiodos/web-core",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "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": {
@@ -30,7 +30,7 @@
     "prepublishOnly": "node ../../scripts/sync-sdk-version.mjs && npm run build"
   },
   "dependencies": {
-    "@fiodos/core": "^0.1.10"
+    "@fiodos/core": "^0.1.13"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",