@useago/sdk 1.5.2 → 1.5.4

package/dist/react.d.ts

@@ -1,5 +1,21 @@
 import { default as default_2 } from 'react';
 
+export declare interface ActivityEntry {
+    ts: number;
+    actor: "user" | "agent";
+    name: string;
+    summary: string;
+    data?: Record<string, unknown>;
+}
+
+export declare interface ActivityInput {
+    actor?: "user" | "agent";
+    name: string;
+    summary: string;
+    data?: Record<string, unknown>;
+    ts?: number;
+}
+
 /**
  * One normalized entry in the agent's activity feed. Merges a tool call
  * (`toolCall:received`) or a client-function invocation (`function:invoke` /
@@ -91,6 +107,8 @@ declare class AgoClient {
     private functionRegistry;
     private contextRegistry;
     private eventEmitter;
+    private activityLedger;
+    private lastSentPageState;
     private config;
     /** Conversations already warned about an empty reply (one warning each). */
     private warnedEmptyConversations;
@@ -104,6 +122,12 @@ declare class AgoClient {
     private pendingApprovals;
     /** App-provided gate deciding WHEN a paused turn resumes (see {@link registerResumeGate}). */
     private resumeGate;
+    /**
+     * Proactive-mode controller, set when the client was created with
+     * `proactive` options or when `createAgoProactive(client, opts)` was called.
+     * `null` otherwise.
+     */
+    proactive: ProactiveController | null;
     constructor(config: AgoConfig);
     /**
      * Send a message and receive a streaming response
@@ -274,6 +298,14 @@ declare class AgoClient {
      * Get all registered function schemas
      */
     getRegisteredFunctions(): ClientFunctionSchema[];
+    /**
+     * Execute a registered client function locally, through the same
+     * FunctionRegistry path (result-size guard, error wrapping) as agent-invoked
+     * calls. Used by proactive nudge actions, where the user's explicit click on
+     * the action button constitutes the approval — nothing is submitted to the
+     * backend (there is no tool call to answer).
+     */
+    executeClientFunction(name: string, args: Record<string, unknown>): Promise<unknown>;
     /**
      * Register a navigation function that lets AGO navigate users to different pages.
      *
@@ -375,6 +407,9 @@ declare class AgoClient {
      */
     notifyContextChanged(): void;
     /* Excluded from this release type: emitFormEvent */
+    /* Excluded from this release type: emitProactiveEvent */
+    /* Excluded from this release type: getHttp */
+    /* Excluded from this release type: getConfiguredAgent */
     /**
      * Enable automatic capture of the current browser page (URL + title).
      * Injected as a dynamic context entry named `browser-page`.
@@ -384,6 +419,19 @@ declare class AgoClient {
      * Get the current context snapshot.
      */
     getContextSnapshot(): ContextSnapshot | null;
+    private buildSendContext;
+    /**
+     * Record something the user just did so the agent is aware of it on the next
+     * message. `actor` defaults to `"user"`. Keep `summary` short and high-signal
+     * (no raw payloads, secrets, or PII).
+     */
+    recordActivity(entry: ActivityInput): void;
+    /** Recent user + agent actions, oldest first (a copy). */
+    getRecentActivity(): ActivityEntry[];
+    clearActivity(): void;
+    private addActivity;
+    private recordAgentAction;
+    private registerActivityContext;
     /**
      * Subscribe to an event
      */
@@ -419,6 +467,7 @@ declare class AgoClient {
      * Clean up resources
      */
     destroy(): void;
+    /* Excluded from this release type: reviveAfterDestroy */
 }
 
 /**
@@ -535,6 +584,27 @@ declare interface AgoClientEvents {
     "connection:status": {
         connected: boolean;
     };
+    /**
+     * A proactive nudge passed every governor gate and is ready to display.
+     * `useProactiveNudge` / `<AgoNudge>` consume this; custom UIs should call
+     * `client.proactive.shown(nudge)` when they render it (impression tracking
+     * + frequency caps), then `accept(nudge)` / `dismiss(nudge)`.
+     */
+    "nudge:ready": ProactiveNudgeInstance;
+    /** A nudge was displayed to the user (fires once per nudge). */
+    "nudge:shown": {
+        nudge: ProactiveNudgeInstance;
+    };
+    /** The user dismissed the nudge (its trigger is suppressed, see governor). */
+    "nudge:dismissed": {
+        nudge: ProactiveNudgeInstance;
+    };
+    /** The user accepted the nudge (its action ran / the chat is being seeded). */
+    "nudge:accepted": {
+        nudge: ProactiveNudgeInstance;
+    };
+    /** A user- or agent-action was recorded into the activity ledger. */
+    "activity:recorded": ActivityEntry;
 }
 
 /**
@@ -596,6 +666,24 @@ export declare interface AgoConfig {
      * with `maxResultBytes` on its definition; `Infinity` disables the guard.
      */
     maxFunctionResultBytes?: number;
+    /**
+     * Max number of recent actions kept in the in-memory activity ledger that
+     * rides along as the `activity:recent` context entry. Older entries drop
+     * first. Default `10`. Larger values give the agent more history at the cost
+     * of tokens on every message. Each entry's `data` is also size-clamped (long
+     * strings truncated, large arrays capped) so one event can't bloat the context.
+     */
+    maxActivityEntries?: number;
+    /**
+     * Enable the proactive mode: declarative triggers evaluated client-side
+     * against friction signals (dwell/idle time, rage clicks, route bounces…)
+     * that can surface a nudge before the user opens the chat. Equivalent to
+     * calling `createAgoProactive(client, proactive)` — the resulting controller
+     * is available as `client.proactive`. Requires the tenant-level kill-switch
+     * (`GET /api/sdk/v1/config` → `proactive.enabled`) to be on; disabled by
+     * default otherwise.
+     */
+    proactive?: ProactiveOptions;
 }
 
 /**
@@ -639,6 +727,33 @@ export declare interface AgoMessage {
     createdAt: Date;
 }
 
+/**
+ * Prebuilt proactive-nudge toast: a small, always-dismissable bubble anchored
+ * near the chat launcher. Never modal — it never blocks the page. Renders the
+ * nudge message, its optional action button, and an "open chat" affordance
+ * for nudges that expand into a conversation.
+ */
+export declare const AgoNudge: default_2.FC<AgoNudgeProps>;
+
+export declare interface AgoNudgeProps {
+    /** The AGO client instance. If omitted, reads from AgoProvider context. */
+    client?: AgoClient;
+    /**
+     * Called after accepting a nudge that expands into the chat (agent-sourced
+     * or with a `goal`) — open your chat UI here. The conversation is already
+     * pre-seeded with a hidden kickoff message.
+     */
+    onExpand?: UseProactiveNudgeOptions["onExpand"];
+    /** Auto-dismiss after this many ms. Off by default (nudges stay until acted on). */
+    autoHideMs?: number;
+    /** Corner to anchor to (near the chat launcher). Default `"bottom-right"`. */
+    position?: "bottom-right" | "bottom-left";
+    /** Label of the open-chat affordance. Default `"Open chat"`. */
+    openChatLabel?: string;
+    /** Additional CSS class (consumer hook only; the SDK ships no CSS for it). */
+    className?: string;
+}
+
 /**
  * Options for {@link AgoClient.registerPageStateFunction}.
  */
@@ -1173,6 +1288,43 @@ export declare interface FormSubmitResult {
     error?: string;
 }
 
+/**
+ * HTTP client with authentication headers
+ */
+declare class HttpClient {
+    private baseUrl;
+    private headers;
+    constructor(config: AgoConfig);
+    /**
+     * Update configuration (e.g., JWT token)
+     */
+    updateConfig(config: Partial<AgoConfig>): void;
+    /**
+     * Make a GET request
+     */
+    get<T>(path: string): Promise<T>;
+    /**
+     * Make a POST request with JSON body.
+     *
+     * `keepalive: true` lets the request survive a page unload (used by the
+     * proactive event tracker's flush-on-hide — sendBeacon can't carry the auth
+     * headers, so it's a keepalive fetch instead).
+     */
+    post<T>(path: string, body?: unknown, options?: {
+        keepalive?: boolean;
+    }): Promise<T>;
+    /**
+     * Make a POST request and return the raw Response (for streaming)
+     */
+    postStream(path: string, body?: unknown): Promise<Response>;
+    /**
+     * Make a POST request with FormData (for file uploads)
+     */
+    postFormData(path: string, formData: FormData): Promise<Response>;
+    private request;
+    private handleErrorResponse;
+}
+
 /**
  * Async sibling of {@link createFormCollector} that pulls the form's definition
  * (description + schema + submit target) from the backend by name — the single
@@ -1267,6 +1419,182 @@ declare interface MockAgoClientOptions {
 
 declare type MockFn = (...args: any[]) => any;
 
+/**
+ * Optional action attached to a nudge. Accepting a `functionName` action
+ * executes the registered client function (same `FunctionRegistry` path as
+ * agent-invoked calls); `setPageState` applies values through the registered
+ * page-state controls.
+ */
+export declare type NudgeAction = {
+    label: string;
+    functionName: string;
+    arguments?: Record<string, unknown>;
+} | {
+    label: string;
+    setPageState: Record<string, unknown>;
+};
+
+/**
+ * Controller returned by {@link createAgoProactive} (also available as
+ * `client.proactive`).
+ */
+export declare interface ProactiveController {
+    /** Persistently opt this browser out of proactive nudges. */
+    optOut(): void;
+    /** Undo {@link optOut}. */
+    optIn(): void;
+    isOptedOut(): boolean;
+    /**
+     * Tell the governor the user is already engaged (e.g. the chat widget is
+     * open) — nudges are suppressed while `true`. Call from the UI layer.
+     */
+    setEngaged(engaged: boolean): void;
+    /** App-pushed field error counter (field NAME only — never values). */
+    signalFieldError(fieldName: string): void;
+    /** Current aggregated friction snapshot. */
+    getSignalsSnapshot(): SignalsSnapshot;
+    /** The nudge currently occupying the single-nudge slot, if any. */
+    getActiveNudge(): ProactiveNudgeInstance | null;
+    /**
+     * Mark the nudge as displayed. Idempotent per nudge; counts it against the
+     * frequency caps, tracks the impression, and emits `nudge:shown`.
+     */
+    shown(nudge: ProactiveNudgeInstance): void;
+    /**
+     * Accept the nudge: run its action (if any), emit `nudge:accepted`, track,
+     * and — for agent nudges or nudges with a `goal` — pre-seed the chat with a
+     * hidden kickoff message so the agent starts the turn with full context.
+     */
+    accept(nudge: ProactiveNudgeInstance): Promise<void>;
+    /** Dismiss the nudge: suppress the trigger, track, emit `nudge:dismissed`. */
+    dismiss(nudge: ProactiveNudgeInstance): void;
+    /** Report a downstream conversion attributable to the nudge (analytics only). */
+    markConverted(nudge: ProactiveNudgeInstance): void;
+    /** Detach everything: listeners, timers, context provider, event flush. */
+    destroy(): void;
+}
+
+/** A concrete nudge produced by the engine, carried by every `nudge:*` event. */
+export declare interface ProactiveNudgeInstance {
+    /** Client-generated uuid for this nudge instance (`client_nudge_id`). */
+    id: string;
+    triggerId: string;
+    /** `static` = configured message; `agent` = backend LLM evaluation. */
+    source: "static" | "agent";
+    message: string;
+    action?: NudgeAction;
+    goal?: string;
+    /** See {@link ProactiveTrigger.kickoff}. */
+    kickoff?: string;
+    createdAt: Date;
+    /** Server-side nudge id (agent nudges only). */
+    serverNudgeId?: string;
+}
+
+/** Options for {@link createAgoProactive} / `AgoConfig.proactive`. */
+export declare interface ProactiveOptions {
+    triggers: ProactiveTrigger[];
+    /**
+     * Global caps on nudges actually shown. `perSession` is in-memory (page
+     * lifetime); `perDay` is persisted in localStorage with a date rollover —
+     * best-effort by design (private browsing resets it); the costly LLM path is
+     * additionally capped server-side.
+     */
+    frequencyCap?: {
+        perSession?: number;
+        perDay?: number;
+    };
+    /** Evaluation tick, ms. Default 1000. Zero network per tick. */
+    tickMs?: number;
+    /** Storage backend for persisted governance state. Default `localStorage`. */
+    storage?: StorageLike;
+    /** Storage key for persisted governance state. Default `"ago_proactive"`. */
+    storageKey?: string;
+    /** Tuning of the signal detectors (rage-click window, throttles…). */
+    signals?: SignalCollectorTuning;
+    /**
+     * Local demos and tests ONLY: bypass the remote kill-switch. When set, the
+     * `GET /config` fetch is skipped and the kill-switch takes this value.
+     * Leave unset in production — the tenant admin controls the feature, and
+     * the evaluate endpoint stays gated server-side regardless.
+     */
+    enabledOverride?: boolean;
+}
+
+/** A declarative proactive trigger. */
+export declare interface ProactiveTrigger {
+    /** Stable id, used for cooldowns, dismissal memory, and analytics. */
+    id: string;
+    /** Conjunction of matchers (see {@link ProactiveTriggerWhen}). */
+    when: ProactiveTriggerWhen;
+    /**
+     * Min time between two firings of this trigger (persisted across reloads).
+     * A firing is the moment the trigger passes the gates — including an agent
+     * evaluation that decides NOT to intervene, so a persistent condition can't
+     * hammer the evaluate endpoint. Default 60 000.
+     */
+    cooldownMs?: number;
+    /**
+     * `'agent'` asks the backend's fast-LLM second filter whether (and how) to
+     * intervene; a `static` object shows the given message with no network call.
+     */
+    intervene: "agent" | {
+        type: "static";
+        message: string;
+        action?: NudgeAction;
+    };
+    /**
+     * What the agent should help with. Sent to the evaluate endpoint, and used to
+     * pre-seed the chat turn when the user accepts the nudge.
+     */
+    goal?: string;
+    /**
+     * User-voice line used to OPEN the conversation when the user accepts this
+     * nudge and no conversation exists yet — a hidden kickoff cannot start one
+     * (the backend rejects it). Sent as a visible user message, so write it in
+     * the app's language ("Oui, aidez-moi à choisir !"). When a conversation is
+     * already open, the SDK sends a hidden meta kickoff instead and this field
+     * is unused. Without it, accepting with no open conversation skips the chat
+     * pre-seed (the nudge action still runs).
+     */
+    kickoff?: string;
+    /**
+     * How long a dismissal of this trigger's nudge suppresses it (persisted).
+     * Default 24h.
+     */
+    resurfaceAfterMs?: number;
+}
+
+/**
+ * Conditions of a proactive trigger. Pure conjunction: EVERY specified matcher
+ * must pass against the current {@link SignalsSnapshot}. Numeric fields are
+ * `>=` thresholds.
+ */
+declare interface ProactiveTriggerWhen {
+    /**
+     * Route pattern the current pathname must match. Supports the SDK's route
+     * styles: exact (`/billing`), `:param` segments (`/users/:id`), single-segment
+     * wildcards (`/a/*` / `/b`), and a trailing `/*` that matches one or more
+     * remaining segments (`/dossier/*`).
+     */
+    route?: string;
+    /** Min time since the last user activity, ms. */
+    idleMs?: number;
+    /** Min time spent on the current route, ms. */
+    dwellMs?: number;
+    /**
+     * Partial deep match against the registered page state (funnel step,
+     * filters…). Every key present here must deep-match the live value.
+     */
+    pageState?: Partial<Record<string, unknown>>;
+    /** Min rage-click bursts on the current route. */
+    rageClicks?: number;
+    /** Min A→B→A→B route oscillations this session. */
+    routeBounces?: number;
+    /** Per-field minimum error counts (field NAME → min count). */
+    fieldErrors?: Record<string, number>;
+}
+
 /**
  * Hook run before a paused turn is resumed, so the app controls WHEN the
  * continuation fires (e.g. wait for the destination page to mount after a
@@ -1299,6 +1627,54 @@ declare interface SendMessageOptions {
     clientFunctionsMode?: ClientFunctionsMode;
 }
 
+/** Tuning knobs for the collector's detectors. All optional. */
+declare interface SignalCollectorTuning {
+    /** Min gap between heavy activity work (route checks, notifications), ms. Default 250. */
+    activityThrottleMs?: number;
+    /** Rage click: clicks needed to count a burst. Default 3. */
+    rageClickCount?: number;
+    /** Rage click: max time between first and last click of a burst, ms. Default 1000. */
+    rageClickWindowMs?: number;
+    /** Rage click: max radius between clicks of a burst, px. Default 24. */
+    rageClickRadiusPx?: number;
+    /** Max routes kept in the recent-route sequence. Default 10. */
+    maxRecentRoutes?: number;
+    /** Max typed signals kept in the ring buffer. Default 50. */
+    maxSignals?: number;
+}
+
+/**
+ * Aggregated view of the current friction state. Registered as a dynamic
+ * context provider (key `friction_signals`) so it rides along as
+ * `client_context` on every message, and sent as `signals` to the proactive
+ * evaluate endpoint.
+ */
+declare interface SignalsSnapshot {
+    /** Current pathname. */
+    route: string;
+    /** Time spent on the current route, ms. */
+    dwellMs: number;
+    /** Time since the last user activity (pointer/key/scroll/touch), ms. */
+    idleMs: number;
+    /** Rage-click bursts detected on the current route. */
+    rageClicks: number;
+    /**
+     * A→B→A→B route oscillations detected in the recent route sequence. Rolling
+     * session counter (cross-route by nature); trigger cooldowns and dismissal
+     * memory keep it from re-firing forever.
+     */
+    routeBounces: number;
+    /** App-pushed field error counters (field NAME → count), current route only. */
+    fieldErrors: Record<string, number>;
+    /** Most recent pathnames, oldest first (bounded). */
+    recentRoutes: string[];
+    /**
+     * Merged `AgoStateControl.get()` snapshot of the registered page-state
+     * controls (funnel step, filters…), or `null` when none are registered.
+     */
+    pageState: Record<string, unknown> | null;
+}
+
 /**
  * SSE stream chunk data
  */
@@ -1342,6 +1718,9 @@ declare interface SSEChunkData {
     waiting_tool_call_ids?: string[];
 }
 
+/** The slice of the Web Storage API that {@link createStore} relies on. */
+declare type StorageLike = Pick<Storage, "getItem" | "setItem">;
+
 /**
  * A minimal observable store: one value, synchronous subscriptions, and
  * optional persistence via {@link PersistOptions} (localStorage by default).
@@ -1451,6 +1830,20 @@ export declare function useAgo(config: UseAgoOptions | null): {
  */
 export declare function useAgoActivity(options?: UseAgoActivityOptions): UseAgoActivityResult;
 
+/** Recent user + agent activity, kept in sync with the client's ledger. */
+export declare function useAgoActivityLog(options?: UseAgoActivityLogOptions): UseAgoActivityLogResult;
+
+export declare interface UseAgoActivityLogOptions {
+    client?: AgoClient;
+}
+
+export declare interface UseAgoActivityLogResult {
+    entries: ActivityEntry[];
+    latest?: ActivityEntry;
+    record: (entry: ActivityInput) => void;
+    clear: () => void;
+}
+
 export declare interface UseAgoActivityOptions {
     /** The AGO client. If omitted, reads from AgoProvider context. */
     client?: AgoClient;
@@ -1816,4 +2209,41 @@ export declare interface UseMessagesResult {
  */
 export declare function useOptionalAgoClient(): AgoClient | null;
 
+/**
+ * Consume proactive nudges (see `createAgoProactive` / `AgoConfig.proactive`).
+ * Receiving a nudge marks it as shown (impression tracking + frequency caps),
+ * so only render ONE consumer of this hook per nudge surface — or use the
+ * prebuilt `<AgoNudge />`.
+ *
+ * ```tsx
+ * const { nudge, accept, dismiss } = useProactiveNudge({
+ *   onExpand: () => setChatOpen(true),
+ * });
+ * if (!nudge) return null;
+ * return <MyToast text={nudge.message} onAccept={accept} onClose={dismiss} />;
+ * ```
+ */
+export declare function useProactiveNudge(options?: UseProactiveNudgeOptions): UseProactiveNudgeResult;
+
+export declare interface UseProactiveNudgeOptions {
+    /** The AGO client instance. If omitted, reads from AgoProvider context. */
+    client?: AgoClient;
+    /**
+     * Called after `accept()` when the nudge should expand into the chat (it
+     * came from `intervene: 'agent'` or carries a `goal`). The SDK has already
+     * pre-seeded the conversation with a hidden kickoff message at this point;
+     * use this to open your chat UI (widget, panel…).
+     */
+    onExpand?: (nudge: ProactiveNudgeInstance) => void;
+}
+
+export declare interface UseProactiveNudgeResult {
+    /** The active nudge, or `null` when none is ready. */
+    nudge: ProactiveNudgeInstance | null;
+    /** Accept the nudge: run its action, seed the chat when relevant, clear it. */
+    accept: () => Promise<void>;
+    /** Dismiss the nudge (suppresses its trigger, see the governor). */
+    dismiss: () => void;
+}
+
 export { }