@useago/sdk 1.5.5 → 1.7.0

package/dist/vue.d.ts

@@ -65,6 +65,10 @@ declare class AgoClient {
     private config;
     /** Conversations already warned about an empty reply (one warning each). */
     private warnedEmptyConversations;
+    /** Whether the placeholder-mode page-data warning has already been logged. */
+    private warnedPageDataPlaceholder;
+    /** `readPageData` companions this SDK registered, so cleanup only removes its own. */
+    private pageDataCompanions;
     /** Paused turns awaiting auto-resume, keyed by assistant message id. */
     private pendingResumes;
     /**
@@ -75,6 +79,20 @@ declare class AgoClient {
     private pendingApprovals;
     /** App-provided gate deciding WHEN a paused turn resumes (see {@link registerResumeGate}). */
     private resumeGate;
+    /** The turn currently streaming, or `null` when the client is idle. */
+    private activeTurn;
+    /**
+     * A turn that closed as `WAITING_CLIENT` and has not resumed yet. There is no
+     * open stream in that window, but the turn is still live for the user, so it
+     * stays stoppable (see {@link stop}).
+     */
+    private pausedTurn;
+    /**
+     * Turns stopped while they were paused on client functions. A resume may
+     * already be queued (or waiting on the resume gate) at that point; this drops
+     * it, so a stopped turn is never restarted.
+     */
+    private stoppedTurnIds;
     /**
      * Proactive-mode controller, set when the client was created with
      * `proactive` options or when `createAgoProactive(client, opts)` was called.
@@ -86,7 +104,53 @@ declare class AgoClient {
      * Send a message and receive a streaming response
      */
     sendMessage(content: string, options?: SendMessageOptions): Promise<AgoMessage>;
+    /**
+     * Fire the streaming request, returning `null` when the user stopped before
+     * the response came back. Any other failure ends the turn and propagates, so
+     * a real error still reaches the caller.
+     */
+    private sendRequest;
     private processSSEResponse;
+    /**
+     * Stop the turn that is generating right now: closes the stream so the UI
+     * stops immediately, and tells the backend to stop generating.
+     *
+     * Both halves matter. Closing the stream alone does NOT stop the agent — it
+     * keeps running and the full answer reappears the next time the conversation
+     * is loaded. The backend unwinds at its next safe point (any tool already
+     * running finishes, no further tool or reasoning round starts), keeps the text
+     * produced so far and finalizes the message as `CANCELED`.
+     *
+     * The in-flight `sendMessage` / `continueMessage` promise resolves normally
+     * with that partial message (it does not reject), `message:complete` fires
+     * with status `CANCELED`, then `message:stopped`.
+     *
+     * ```ts
+     * // "Stop" button
+     * stopButton.onclick = () => void client.stop();
+     * ```
+     *
+     * Returns the backend's verdict, or `null` when nothing was generating or the
+     * stop landed before the message had an id (the stream is still closed).
+     */
+    stop(): Promise<StopMessageResult | null>;
+    /**
+     * Ask the backend to stop a specific in-flight turn, without touching any
+     * local stream. Idempotent — stopping a finished turn answers
+     * `{ status: "not_running" }` rather than failing. Most apps want
+     * {@link stop} instead; use this to stop a turn started elsewhere (e.g. one
+     * still running after a page reload, found via `getConversation`).
+     */
+    stopMessage(messageId: string): Promise<StopMessageResult>;
+    /** Whether a turn is generating right now (i.e. {@link stop} has something to stop). */
+    isGenerating(): boolean;
+    /** Open a new turn, replacing any bookkeeping left by the previous one. */
+    private beginTurn;
+    private endTurn;
+    /** POST the stop for a turn, once, never letting the failure escape. */
+    private postStopForTurn;
+    /** The message a caller gets back when the stop beat the response. */
+    private buildStoppedMessage;
     private resolveClientFunctionsMode;
     /**
      * Register a gate deciding WHEN a paused turn resumes. The SDK still decides
@@ -314,13 +378,38 @@ declare class AgoClient {
      *   },
      * ]);
      * ```
+     *
+     * Pass `opts.data` and the agent also gets back **what the page now shows**,
+     * as the result of its own call, instead of having to wait for the next
+     * message's context. That also registers a read-only `readPageData`
+     * companion. See {@link AgoPageDataSource}.
      */
     registerPageStateFunction(controls: AgoStateControl[], opts?: AgoPageStateOptions): void;
     /**
-     * Unregister a page state function and its dynamic context provider.
-     * Mirror of unregistering `navigateToPage`.
+     * Unregister a page state function, its `readPageData` companion, and its
+     * dynamic context provider. Mirror of unregistering `navigateToPage`.
      */
     unregisterPageStateFunction(functionName?: string): void;
+    /**
+     * Size ceiling for a page snapshot, before the envelope is accounted for.
+     * Read at call time, not at registration, so `updateConfig` moves it.
+     */
+    private pageDataBudget;
+    /** Bytes the non-`data` part of the result costs, `data` included as `null`. */
+    private envelopeBytes;
+    /**
+     * Wait for the page to stop reloading, then read the snapshot. `get` and
+     * `isLoading` are re-read from `source` on every tick so a re-render that
+     * swaps the closures (without re-registering) is picked up mid-wait.
+     */
+    private readPageData;
+    /**
+     * The snapshot only reaches the agent inside the same turn in pause mode,
+     * where the SDK submits the tool result and resumes. In placeholder mode the
+     * turn is already over, so a `data` source looks broken from the outside:
+     * say so once rather than let the integrator hunt for an SDK bug.
+     */
+    private warnIfPlaceholderMode;
     /**
      * Register or update a piece of client-side context.
      * This context is sent with every message so the AI understands the user's situation.
@@ -488,6 +577,18 @@ declare interface AgoClientEvents {
         conversationId: string;
         messageId: string;
     };
+    /**
+     * The user stopped the turn (`client.stop()`): the stream was closed and the
+     * backend was told to stop generating. Always fires, so this is the event to
+     * finalize a UI on. When there was an answer to keep, a `message:complete`
+     * carrying it with status `CANCELED` fires first; there is none when the stop
+     * landed before the backend named the message (`messageId` is then an empty
+     * string) or when the stopped turn was paused on client functions.
+     */
+    "message:stopped": {
+        conversationId: string;
+        messageId: string;
+    };
     "message:error": {
         error: string;
         /** Stable error code (see configuration.md#error-codes) when the failure was an AgoError. */
@@ -681,6 +782,80 @@ export declare interface AgoMessage {
     createdAt: Date;
 }
 
+/**
+ * What the page currently displays, returned to the agent as the *result* of
+ * `setPageState` instead of only as context on the next message.
+ *
+ * Declare it when the agent should be able to act on what its own change
+ * produced ("search for dupont" → it can say who was found).
+ *
+ * A control change usually kicks off work (a refetch, a recomputation). The SDK
+ * has to wait for that work before reading, and there are two ways to tell it
+ * when the work is done. **Prefer the first.**
+ *
+ * **1. Return a promise from `get()`** — you own the await, so the SDK is
+ * exact: it resolves when your work resolves, with no polling and no timing
+ * assumption. With TanStack Query, `ensureQueryData` gives you that promise and
+ * shares the single in-flight request with the UI:
+ *
+ * ```ts
+ * useAgoPageState(controls, {
+ *   data: {
+ *     description: "The users matching the current filters.",
+ *     get: () => queryClient.ensureQueryData({
+ *       queryKey: ["users", filters],
+ *       queryFn: fetchUsers,
+ *     }),
+ *   },
+ * });
+ * ```
+ *
+ * **2. Declare `isLoading`** — for data you cannot get a promise for. The SDK
+ * polls it instead, which is a heuristic: the flag has to be up within ~100 ms
+ * of the change or the SDK concludes the page settled and reads the previous
+ * rows. Fine for a query library that flips `isFetching` on render, wrong for a
+ * debounced fetch.
+ *
+ * ```ts
+ * const { data: users, isFetching } = useQuery({ queryKey: ["users", filters], queryFn: fetchUsers });
+ *
+ * useAgoPageState(controls, {
+ *   data: {
+ *     description: "The users matching the current filters.",
+ *     get: () => users ?? [],
+ *     // isFetching, NOT isLoading: a background refetch must count as loading,
+ *     // otherwise the agent reads the rows from the previous search.
+ *     isLoading: () => isFetching,
+ *   },
+ * });
+ * ```
+ */
+export declare interface AgoPageDataSource<T = unknown> {
+    /** What this data is, for the LLM: "The users matching the current filters." */
+    description: string;
+    /**
+     * The snapshot handed back to the agent.
+     *
+     * Return a promise and the SDK awaits it: that promise resolving *is* the
+     * signal that the work the change triggered has finished, so nothing is
+     * guessed. It is bounded by `settleTimeoutMs`.
+     */
+    get: () => T | Promise<T>;
+    /**
+     * True while the page is (re)loading this data. Only needed when `get()`
+     * cannot return a promise. The SDK polls it every 50 ms and treats two
+     * consecutive `false` readings as settled, so a flag raised more than ~100 ms
+     * after the change is missed and the agent reads stale rows.
+     */
+    isLoading?: () => boolean;
+    /**
+     * Size ceiling for the returned snapshot, in bytes. Defaults to the client's
+     * `maxFunctionResultBytes`. Over the ceiling the snapshot keeps the first
+     * whole items that fit; `success` and `applied` are never dropped.
+     */
+    maxResultBytes?: number;
+}
+
 /**
  * Options for {@link AgoClient.registerPageStateFunction}.
  */
@@ -692,6 +867,23 @@ export declare interface AgoPageStateOptions {
      * {@link AgoConfig.approvalPolicy} — pause mode only. Defaults to `false`.
      */
     requiresApproval?: boolean;
+    /**
+     * Declare what the page displays so `setPageState` returns it. Omit it and
+     * the result stays exactly `{ success, applied }`.
+     *
+     * Also registers a read-only companion function (`readPageData`, derived from
+     * `functionName`) that returns the same snapshot without touching the page.
+     *
+     * The snapshot travels only when the agent calls one of those functions: it
+     * is deliberately kept out of the `page-state:` dynamic context, which would
+     * put it in every message.
+     */
+    data?: AgoPageDataSource;
+    /**
+     * How long to wait for the page to finish reloading before reading the
+     * snapshot. Defaults to 10 000 ms; on timeout whatever is there is returned.
+     */
+    settleTimeoutMs?: number;
 }
 
 /**
@@ -1020,13 +1212,21 @@ declare class HttpClient {
         keepalive?: boolean;
     }): Promise<T>;
     /**
-     * Make a POST request and return the raw Response (for streaming)
+     * Make a POST request and return the raw Response (for streaming).
+     *
+     * `signal` lets the caller close the stream mid-flight (see
+     * `AgoClient.stop`); an abort is rethrown as-is rather than wrapped in an
+     * `AgoNetworkError`, so a deliberate stop is not mistaken for a network drop.
      */
-    postStream(path: string, body?: unknown): Promise<Response>;
+    postStream(path: string, body?: unknown, options?: {
+        signal?: AbortSignal;
+    }): Promise<Response>;
     /**
      * Make a POST request with FormData (for file uploads)
      */
-    postFormData(path: string, formData: FormData): Promise<Response>;
+    postFormData(path: string, formData: FormData, options?: {
+        signal?: AbortSignal;
+    }): Promise<Response>;
     private request;
     private handleErrorResponse;
 }
@@ -1358,6 +1558,21 @@ declare interface SSEChunkData {
     waiting_tool_call_ids?: string[];
 }
 
+/**
+ * Response of `POST /messages/{id}/stop` (see `AgoClient.stopMessage`).
+ *
+ * - `"stopping"` — the request was accepted; the turn unwinds at its next safe
+ *   point and finalizes as `CANCELED`, keeping the text produced so far.
+ * - `"not_running"` — the turn had already finished. Harmless.
+ * - `"not_supported"` — a background agent run, which cannot be stopped once
+ *   started.
+ */
+declare interface StopMessageResult {
+    status: "stopping" | "not_running" | "not_supported";
+    /** The message's status when the stop was requested. */
+    messageStatus?: MessageStatus;
+}
+
 /** The slice of the Web Storage API that {@link createStore} relies on. */
 declare type StorageLike = Pick<Storage, "getItem" | "setItem">;
 
@@ -1519,6 +1734,19 @@ export declare function useAgoNavigation(navigate: (path: string) => void, route
  *   },
  * ]);
  * ```
+ *
+ * Pass `opts.data` to also hand the agent what the page ends up displaying, as
+ * the result of its own `setPageState` call:
+ *
+ * ```ts
+ * useAgoPageState(controls, {
+ *   data: {
+ *     description: "The rows matching the current filters.",
+ *     get: () => rows.value,
+ *     isLoading: () => isFetching.value,
+ *   },
+ * });
+ * ```
  */
 export declare function useAgoPageState(controls: AgoStateControl[], opts?: AgoPageStateOptions): void;
 
@@ -1637,6 +1865,7 @@ export declare function useChat(options?: UseChatOptions): {
     isLoading: Ref<boolean, boolean>;
     error: ComputedRef<Error | null>;
     sendMessage: (content: string, files?: File[]) => Promise<AgoMessage | null>;
+    stop: () => Promise<void>;
     clearMessages: () => void;
     conversationId: Ref<string | undefined, string | undefined>;
     conversations: Ref<    {
@@ -2158,6 +2387,7 @@ export declare function useMessages(options?: UseMessagesOptions): {
     error: Ref<Error | null, Error | null>;
     conversationId: Ref<string | undefined, string | undefined>;
     sendMessage: (content: string, files?: File[]) => Promise<AgoMessage | null>;
+    stop: () => Promise<void>;
     clearMessages: () => void;
 };
 

package/dist/vue.js

@@ -1,45 +1,58 @@
-import { t as E } from "./AgoClient-BI5esqbd.js";
-import { computed as M, inject as F, onMounted as d, onScopeDispose as S, onUnmounted as m, ref as l, shallowRef as A } from "vue";
-var N = /* @__PURE__ */ Symbol("ago-client"), b = { install(t, e) {
-  const n = new E(e);
-  t.provide(N, n);
+import { t as N } from "./AgoClient-PWPaekcg.js";
+import { computed as R, inject as F, onMounted as f, onScopeDispose as P, onUnmounted as m, ref as v, shallowRef as y } from "vue";
+var A = /* @__PURE__ */ Symbol("ago-client"), k = { install(t, e) {
+  const n = new N(e);
+  t.provide(A, n);
 } };
-function f(t) {
-  if (t) return new E(t);
-  const e = F(N);
+function g(t) {
+  if (t) return new N(t);
+  const e = F(A);
   if (!e) throw new Error("useAgo(): no AgoClient found. Either pass config or install AgoPlugin.");
   return e;
 }
-function R(t = {}) {
-  const e = t.client ?? f(), n = l([]), s = l(t.conversationId), o = l(!1), r = l(null), c = (a) => {
-    s.value || (s.value = a.conversationId);
-  }, p = (a) => {
-    const i = n.value.findIndex((v) => v.id === a.messageId);
-    i >= 0 && (n.value[i] = {
-      ...n.value[i],
-      content: n.value[i].content + a.content
+function x(t = {}) {
+  const e = t.client ?? g(), n = v([]), s = v(t.conversationId), a = v(!1), i = v(null), c = (o) => {
+    s.value || (s.value = o.conversationId);
+  }, p = (o) => {
+    const r = n.value.findIndex((u) => u.id === o.messageId);
+    r >= 0 && (n.value[r] = {
+      ...n.value[r],
+      content: n.value[r].content + o.content
     });
-  }, h = (a) => {
-    const i = n.value.findIndex((v) => v.id === a.id);
-    i >= 0 ? n.value[i] = a : n.value.push(a), o.value = !1;
-  }, C = (a) => {
-    r.value = new Error(a.error), o.value = !1;
+  }, h = (o) => {
+    const r = n.value.findIndex((u) => u.id === o.id);
+    r >= 0 ? n.value[r] = o : n.value.push(o), a.value = !1;
+  }, C = (o) => {
+    i.value = new Error(o.error), a.value = !1;
+  }, d = () => {
+    let o = -1;
+    for (let r = n.value.length - 1; r >= 0; r--) {
+      const u = n.value[r];
+      if (u.role === "assistant" && (u.status === "IN_PROGRESS" || u.status === "WAITING_CLIENT")) {
+        o = r;
+        break;
+      }
+    }
+    o >= 0 && (n.value[o].content ? n.value[o] = {
+      ...n.value[o],
+      status: "CANCELED"
+    } : n.value.splice(o, 1)), a.value = !1;
   };
-  d(() => {
-    e.on("message:start", c), e.on("message:chunk", p), e.on("message:complete", h), e.on("message:error", C);
+  f(() => {
+    e.on("message:start", c), e.on("message:chunk", p), e.on("message:complete", h), e.on("message:error", C), e.on("message:stopped", d);
   }), m(() => {
-    e.off("message:start", c), e.off("message:chunk", p), e.off("message:complete", h), e.off("message:error", C);
+    e.off("message:start", c), e.off("message:chunk", p), e.off("message:complete", h), e.off("message:error", C), e.off("message:stopped", d);
   });
-  async function g(a, i) {
-    o.value = !0, r.value = null;
-    const v = {
+  async function I(o, r) {
+    a.value = !0, i.value = null;
+    const u = {
       id: `temp-${Date.now()}`,
       conversationId: s.value || "",
-      content: a,
+      content: o,
       role: "user",
       status: "DONE",
       createdAt: /* @__PURE__ */ new Date()
-    }, L = {
+    }, M = {
       id: `temp-assistant-${Date.now()}`,
       conversationId: s.value || "",
       content: "",
@@ -47,85 +60,90 @@ function R(t = {}) {
       status: "IN_PROGRESS",
       createdAt: /* @__PURE__ */ new Date()
     };
-    n.value.push(v, L);
+    n.value.push(u, M);
     try {
-      const u = await e.sendMessage(a, {
+      const l = await e.sendMessage(o, {
         conversationId: s.value,
-        files: i
+        files: r
       });
-      u.conversationId && !s.value && (s.value = u.conversationId), n.value = n.value.filter((y) => !y.id.startsWith("temp-"));
-      const I = {
-        ...v,
-        id: v.id.replace("temp-", "user-"),
-        conversationId: u.conversationId
+      l.conversationId && !s.value && (s.value = l.conversationId), n.value = n.value.filter((E) => !E.id.startsWith("temp-"));
+      const w = {
+        ...u,
+        id: u.id.replace("temp-", "user-"),
+        conversationId: l.conversationId
       };
-      return n.value.some((y) => y.id === u.id) ? n.value.push(I) : n.value.push(I, u), u;
-    } catch (u) {
-      return r.value = u instanceof Error ? u : /* @__PURE__ */ new Error("Failed to send"), o.value = !1, n.value = n.value.filter((I) => !I.id.startsWith("temp-")), null;
+      return n.value.some((E) => E.id === l.id) ? n.value.push(w) : n.value.push(w, l), l;
+    } catch (l) {
+      return i.value = l instanceof Error ? l : /* @__PURE__ */ new Error("Failed to send"), a.value = !1, n.value = n.value.filter((w) => !w.id.startsWith("temp-")), null;
     }
   }
-  function w() {
-    n.value = [], s.value = void 0, r.value = null;
+  async function L() {
+    await e.stop();
+  }
+  function S() {
+    n.value = [], s.value = void 0, i.value = null;
   }
   return {
     messages: n,
-    isLoading: o,
-    error: r,
+    isLoading: a,
+    error: i,
     conversationId: s,
-    sendMessage: g,
-    clearMessages: w
+    sendMessage: I,
+    stop: L,
+    clearMessages: S
   };
 }
-function P(t = {}) {
-  const e = t.client ?? f(), n = t.autoLoad ?? !0, s = l([]), o = l(null), r = l(!1), c = l(null);
+function D(t = {}) {
+  const e = t.client ?? g(), n = t.autoLoad ?? !0, s = v([]), a = v(null), i = v(!1), c = v(null);
   async function p() {
-    r.value = !0, c.value = null;
+    i.value = !0, c.value = null;
     try {
       s.value = (await e.getConversations()).data;
-    } catch (g) {
-      c.value = g instanceof Error ? g : /* @__PURE__ */ new Error("Failed to load conversations");
+    } catch (d) {
+      c.value = d instanceof Error ? d : /* @__PURE__ */ new Error("Failed to load conversations");
     } finally {
-      r.value = !1;
+      i.value = !1;
     }
   }
-  async function h(g) {
-    r.value = !0, c.value = null;
+  async function h(d) {
+    i.value = !0, c.value = null;
     try {
-      o.value = await e.getConversation(g);
-    } catch (w) {
-      c.value = w instanceof Error ? w : /* @__PURE__ */ new Error("Failed to load conversation");
+      a.value = await e.getConversation(d);
+    } catch (I) {
+      c.value = I instanceof Error ? I : /* @__PURE__ */ new Error("Failed to load conversation");
     } finally {
-      r.value = !1;
+      i.value = !1;
     }
   }
   function C() {
-    o.value = null;
+    a.value = null;
   }
-  return d(() => {
+  return f(() => {
     n && p();
   }), {
     conversations: s,
-    currentConversation: o,
-    isLoading: r,
+    currentConversation: a,
+    isLoading: i,
     error: c,
     selectConversation: h,
     startNewConversation: C,
     refreshConversations: p
   };
 }
-function k(t = {}) {
-  const e = R({
+function G(t = {}) {
+  const e = x({
     client: t.client,
     conversationId: t.conversationId
-  }), n = P({
+  }), n = D({
     client: t.client,
     autoLoad: t.autoLoad
-  }), s = M(() => e.error.value || n.error.value);
+  }), s = R(() => e.error.value || n.error.value);
   return {
     messages: e.messages,
     isLoading: e.isLoading,
     error: s,
     sendMessage: e.sendMessage,
+    stop: e.stop,
     clearMessages: e.clearMessages,
     conversationId: e.conversationId,
     conversations: n.conversations,
@@ -137,8 +155,8 @@ function k(t = {}) {
   };
 }
 function O(t, e) {
-  const n = f();
-  d(() => {
+  const n = g();
+  f(() => {
     n.registerFunction(t, e.handler, {
       description: e.description,
       parameters: e.parameters,
@@ -148,69 +166,72 @@ function O(t, e) {
     n.unregisterFunction(t);
   });
 }
-function _(t, e) {
-  const n = f();
-  d(() => {
+function T(t, e) {
+  const n = g();
+  f(() => {
     n.registerNavigationFunction(t, e);
   }), m(() => {
     n.unregisterNavigationFunction();
   });
 }
-function B(t, e) {
-  const n = f(), s = e?.functionName ?? "setPageState";
-  d(() => {
-    n.registerPageStateFunction(t, { functionName: s });
+function W(t, e) {
+  const n = g(), s = e?.functionName ?? "setPageState";
+  f(() => {
+    n.registerPageStateFunction(t, {
+      ...e,
+      functionName: s
+    });
   }), m(() => {
     n.unregisterPageStateFunction(s);
   });
 }
-function G(t, e) {
-  const n = f();
-  d(() => {
+function B(t, e) {
+  const n = g();
+  f(() => {
     n.on(t, e);
   }), m(() => {
     n.off(t, e);
   });
 }
 function U(t) {
-  const e = A(t.get());
-  return S(t.subscribe((n) => {
+  const e = y(t.get());
+  return P(t.subscribe((n) => {
     e.value = n;
   })), e;
 }
-function W() {
-  const t = f(), e = A(null), n = (o) => {
-    e.value = o, t.proactive?.shown(o);
-  }, s = ({ nudge: o }) => {
-    e.value?.id === o.id && (e.value = null);
+function $() {
+  const t = g(), e = y(null), n = (a) => {
+    e.value = a, t.proactive?.shown(a);
+  }, s = ({ nudge: a }) => {
+    e.value?.id === a.id && (e.value = null);
   };
-  return d(() => {
+  return f(() => {
     t.on("nudge:ready", n), t.on("nudge:accepted", s), t.on("nudge:dismissed", s);
   }), m(() => {
     t.off("nudge:ready", n), t.off("nudge:accepted", s), t.off("nudge:dismissed", s);
   }), {
     nudge: e,
     accept: async () => {
-      const o = e.value;
-      o && (e.value = null, await t.proactive?.accept(o));
+      const a = e.value;
+      a && (e.value = null, await t.proactive?.accept(a));
     },
     dismiss: () => {
-      const o = e.value;
-      o && (e.value = null, t.proactive?.dismiss(o));
+      const a = e.value;
+      a && (e.value = null, t.proactive?.dismiss(a));
     }
   };
 }
 export {
-  N as AGO_CLIENT_KEY,
-  b as AgoPlugin,
-  f as useAgo,
-  G as useAgoEvents,
+  A as AGO_CLIENT_KEY,
+  k as AgoPlugin,
+  g as useAgo,
+  B as useAgoEvents,
   O as useAgoFunction,
-  _ as useAgoNavigation,
-  B as useAgoPageState,
+  T as useAgoNavigation,
+  W as useAgoPageState,
   U as useAgoStore,
-  k as useChat,
-  P as useConversation,
-  R as useMessages,
-  W as useProactiveNudge
+  G as useChat,
+  D as useConversation,
+  x as useMessages,
+  $ as useProactiveNudge
 };