@dudousxd/nestjs-agent-react 0.20.0 → 0.22.0

package/README.md

@@ -19,24 +19,58 @@ pnpm add @dudousxd/nestjs-agent-react @ai-sdk/react ai react
 import { useAgentChat, MessageList, ChatInput } from '@dudousxd/nestjs-agent-react';
 
 function Chat() {
-  const chat = useAgentChat({
-    baseUrl: '/agent',
-    getHeaders: () => ({ 'x-actor-id': me.id, 'x-actor-role': me.roles.join(',') }),
-  });
+  const chat = useAgentChat(); // same-origin, `/agent` — no provider needed
   return (
     <>
-      <MessageList
-        messages={chat.messages}
-        status={chat.status}
-        regeneratable
-        onRegenerate={() => chat.regenerate()}
-      />
+      <MessageList messages={chat.messages} status={chat.status} />
       <ChatInput onSubmit={(text) => chat.sendMessage({ text })} />
     </>
   );
 }
 ```
 
+`useAgentChat` does the wiring itself: give it a `threadId` and it loads that thread's history and
+re-attaches to a turn still streaming on it (`history: false` / `resume: false` opt out); it gates
+sends on the reported quota; approvals and question sets in the transcript are actionable with no
+handlers passed. On top of the AI SDK chat it returns:
+
+| On `chat` | What it is |
+|---|---|
+| `transcript` | `useChatTranscript` already bound to the chat — approve/reject/answer/skip, stop, fork, regenerate, the tool catalog, and timestamps/usage read from message metadata. Override any of it with `useAgentChat({ transcript: { … } })`. |
+| `composer` | `{ text, setText, files, canSend, blockedBy, submit() }` — `files` is `useAttachments` on the chat's backend; `submit()` sends the draft with the ready files attached and clears both; `blockedBy` is `'empty' \| 'busy' \| 'uploading' \| 'quota'`. |
+| `models` | `{ list, providers, selected, select(id), pinToThread(id) }` — loaded the first time `list` is read. |
+| `quota` / `blocked` | `useQuota`'s state, and the window blocking sends (the `blocked` option overrides it). |
+| `approve` / `reject` / `answer` / `skip` | `({ toolCallId, … })` — the same object shape the transcript's handlers take. |
+| `fork` / `truncateFrom` / `promote` | `({ messageId, threadId? })` / `({ threadId? })`, defaulting to this chat's thread. |
+| `cancel`, `regenerate`, `getThreadId`, `backend`, `runId`, `activeRunId`, `isLoadingHistory`, `connection`, `background` | — |
+
+Threads (list, rename, delete) are `useThreads()`; the granular hooks stay the escape hatch.
+
+### Configure the connection once: `<AgentProvider>`
+
+Every hook (`useAgentChat`, `useThreads`, `useModels`, `useAgents`, `useQuota`, `useToolCatalog`,
+`useMessageFeedback`, `useAttachments`) talks to the enclosing provider's backend unless handed a
+`backend` of its own. Without a provider they share one same-origin client on `/agent`.
+
+```tsx
+import { AgentProvider } from '@dudousxd/nestjs-agent-react';
+import { mediaAttachments } from '@dudousxd/nestjs-agent-react/media';
+
+<AgentProvider
+  baseUrl="https://api.example.com" // origin only; default '' (same origin)
+  path="api/agent"                  // AgentModule's `path` + global prefix; default 'agent'
+  credentials="include"
+  getHeaders={() => ({ 'X-XSRF-TOKEN': readCookie('XSRF-TOKEN') })}
+  attachments={{ upload: mediaAttachments() }} // optional
+  genui={{ registry, catalog }}                // optional — same props as <GenuiProvider>
+>
+  <App />
+</AgentProvider>
+```
+
+`<AgentProvider backend={myBackend}>` takes any `AgentBackend` instead of the connection props.
+`useAgentBackend()` returns the backend in scope, for your own calls.
+
 ## Bring your own UI
 
 The package is **headless by design**, in four layers, and only the top one renders anything:
@@ -58,15 +92,15 @@ tool grouping, the edit machine, or the copy flash, and it never imports `Messag
 import { useAgentChat, useChatTranscript } from '@dudousxd/nestjs-agent-react';
 
 function Chat() {
-  const chat = useAgentChat({ baseUrl: '/agent' });
+  const chat = useAgentChat();
+  // `chat.transcript` is this, pre-wired; `useChatTranscript` directly for any AI SDK chat.
   const transcript = useChatTranscript({
     messages: chat.messages,
     status: chat.status,
     editable: true,
-    onEditSubmit: (id, text) => chat.sendMessage({ text }),
-    onFork: (id) => chat.forkThread(threadId, id),
+    onEditSubmit: ({ text }) => chat.sendMessage({ text }),
+    onFork: ({ messageId }) => chat.fork({ messageId }),
     onStop: () => chat.cancel(),
-    getUsage: (message) => readUsage(message),
   });
 
   return (
@@ -134,8 +168,8 @@ catalog to the transcript and every tool call carries a `description`, and every
 `activity` grouping:
 
 ```tsx
-const chat = useAgentChat({ baseUrl: '/agent' });
-const { catalog } = useToolCatalog({ client: chat.client });
+const chat = useAgentChat();
+const { catalog } = useToolCatalog(); // the provider's backend; `{ backend, agent }` to override
 const transcript = useChatTranscript({ messages: chat.messages, status: chat.status, toolCatalog: catalog });
 
 // in a `tools` block:
@@ -330,11 +364,11 @@ the model, so a `/` menu and the agent's own reach cannot drift apart:
 ```tsx
 import { createSkillsSource, useAgentChat } from '@dudousxd/nestjs-agent-react';
 
-const chat = useAgentChat({ baseUrl: '/agent', onThreadCreated: setThreadId });
+const chat = useAgentChat({ onThreadCreated: setThreadId });
 // Identity-stable so the list is read once per thread, not once per keystroke.
 const sources = useMemo(
-  () => [createSkillsSource({ client: chat.client, getThreadId: () => threadId })],
-  [chat.client],
+  () => [createSkillsSource({ backend: chat.backend, getThreadId: () => threadId })],
+  [chat.backend],
 );
 ```
 
@@ -420,14 +454,11 @@ import { isTextUIPart, isToolUIPart } from 'ai';
 
 function CustomChat({ threadId }: { threadId?: string }) {
   const chat = useAgentChat({
-    baseUrl: '/agent',
     // Omit the key entirely when absent — `UseAgentChatOptions` is built with
     // `exactOptionalPropertyTypes`, so an explicit `threadId: undefined` doesn't type-check.
     ...(threadId !== undefined ? { threadId } : {}),
     agent: 'support',
-    // Reattach to a turn still streaming when the page loaded — survives a refresh.
-    resume: true,
-    getHeaders: () => ({ 'x-actor-id': currentUser.id }),
+    // A `threadId` loads its history and re-attaches to a turn still streaming — by default.
     onThreadCreated: (newThreadId) => router.replace(`/chat/${newThreadId}`),
     // Fires once per run when the SERVER is done writing (title + terminal state persisted) —
     // the right signal to refetch a thread list/sidebar; `onFinish` only means "a turn rendered".
@@ -472,10 +503,7 @@ disables itself while busy never noticed; a double-submitted one, and StrictMode
 effect, did.
 
 `chat` is the AI SDK v7 `useChat` return value (`messages`, `status`, `sendMessage`, `stop`, …) spread
-together with the extras: `runId`/`activeRunId`, `connection`, `getThreadId`, `backend` (the `AgentBackend`; also
-under its old name `client`), thread list/CRUD
-(`threads`, `loadThreads`, `loadThread`, `deleteThread`, `forkThread`, `renameThread`, `promoteThread`,
-`truncateFromMessage`), `quota`/`loadQuota`, `cancel`, HITL `approve`/`reject` and `answer`/`skip`, and `regenerate`.
+together with the extras in the table above.
 `MyToolCard`'s `part` prop above types as the exported `AnyToolUIPart` (`ToolUIPart | DynamicToolUIPart`
 — `MessageItem` uses the same union for its own `renderToolPart` callback).
 
@@ -517,7 +545,8 @@ const backend: AgentBackend = {
   setMessageFeedback: (id, input) => api.messages.feedback(id, input),
 };
 
-const chat = useAgentChat({ backend }); // chat.backend === backend, typed as yours
+<AgentProvider backend={backend}>…</AgentProvider>; // every hook below uses it
+const chat = useAgentChat({ backend }); // or per hook — chat.backend === backend, typed as yours
 ```
 
 Calling a hook method whose optional backend member is missing throws
@@ -528,15 +557,17 @@ attachments?, pageContext?, regenerate? }`; the SSE it returns and the REST shap
 **Cookie session + CSRF with the default client.** `credentials` and `getHeaders` are all it takes —
 `getHeaders` runs per request, so a rotated token is picked up:
 
-```ts
+```tsx
 const readCookie = (name: string) =>
   decodeURIComponent(document.cookie.match(new RegExp(`(?:^|; )${name}=([^;]*)`))?.[1] ?? '');
 
-useAgentChat({
-  baseUrl: '/api',
-  credentials: 'include', // 'same-origin' (the fetch default) is enough when the API is same-origin
-  getHeaders: () => ({ 'X-XSRF-TOKEN': readCookie('XSRF-TOKEN') }),
-});
+<AgentProvider
+  path="api/agent"
+  credentials="include" // 'same-origin' (the fetch default) is enough when the API is same-origin
+  getHeaders={() => ({ 'X-XSRF-TOKEN': readCookie('XSRF-TOKEN') })}
+>
+  <App />
+</AgentProvider>;
 ```
 
 ### Reconnecting a dropped stream
@@ -554,8 +585,8 @@ the last failed attempt the turn ends with an error.
 ```tsx
 import { useMessageFeedback, useThreads } from '@dudousxd/nestjs-agent-react';
 
-const { threads, isLoading, rename, remove, refresh } = useThreads({ backend: chat.backend });
-const feedback = useMessageFeedback({ backend: chat.backend, threadId: chat.getThreadId });
+const { threads, isLoading, rename, remove, refresh } = useThreads();
+const feedback = useMessageFeedback({ threadId: chat.getThreadId });
 
 <button aria-pressed={feedback.feedbackOf(message)?.value === 'up'}
         onClick={() => feedback.toggle(message, 'up')}>Helpful</button>
@@ -570,14 +601,10 @@ its run persisted (the live message carries `metadata.runId`).
 ### Picking a model and an agent
 
 ```tsx
-import { useAgents, useModels } from '@dudousxd/nestjs-agent-react';
+const chat = useAgentChat();
+const { providers, selected, select } = chat.models; // loaded on first read
 
-const [model, setModel] = useState<string | undefined>();
-const chat = useAgentChat({ backend, model }); // sent as the body's `model` on every turn
-const { providers, find, defaultModel } = useModels({ backend: chat.backend, agent: 'support' });
-const { agents } = useAgents({ backend: chat.backend });
-
-<select value={model ?? defaultModel ?? ''} onChange={(e) => setModel(e.target.value)}>
+<select value={selected ?? ''} onChange={(e) => select(e.target.value)}>
   {providers.map((p) => (
     <optgroup key={p.id} label={p.label}>
       {p.models.map((m) => (
@@ -590,10 +617,14 @@ const { agents } = useAgents({ backend: chat.backend });
 </select>
 ```
 
-`useModels` reads `GET <base>/models?agent=` (models grouped by provider, with badges and
-availability; `models` is the same list flattened, `find(id)` looks one up). A single send can
-override with `sendMessage(msg, { body: { model } })`; `chat.setThreadModel(id)` pins a model on
-the thread (`null` unpins), so every later turn without its own runs on it. The server refuses a
+`chat.models` reads `GET <base>/models?agent=` (models grouped by provider, with badges and
+availability; `list` is the same flattened) the first time `list`/`providers` is read. `select(id)`
+runs the following turns on it (sent as the body's `model`); `selected` is the pick, else the
+thread's pin, else the server default. `pinToThread(id)` pins it on the thread (`null` unpins) so
+it survives reloads — on a chat with no thread yet, the pin lands when the first send creates one.
+`useAgentChat({ model })` controls the model yourself; a single send can override it with
+`sendMessage(msg, { body: { model } })`. `useModels()` / `useAgents()` are the standalone hooks
+(an agent picker: `useAgents().agents`, sent as `useAgentChat({ agent })`). The server refuses a
 model its catalog does not offer as available.
 
 ### Quota
@@ -601,17 +632,19 @@ model its catalog does not offer as available.
 ```tsx
 import { QuotaBlockedError, useQuota } from '@dudousxd/nestjs-agent-react';
 
-const quota = useQuota({ backend });                // GET <base>/quota
-const chat = useAgentChat({ backend, blocked: quota.blocked });
+const chat = useAgentChat(); // reads GET <base>/quota and gates sends on it
+const { quota } = chat;
 
 <meter value={quota.month?.usedUsd} max={quota.month?.limitUsd} />
-{quota.blocked ? <p>{quota.blocked.reason}</p> : null}
+{chat.blocked ? <p>{chat.blocked.reason}</p> : null}
 ```
 
-`useQuota` returns every window (`day`, `month`, …) with its usage and ceilings, and `blocked` when
-one is exhausted; it re-reads after every run a chat on the same backend settles (`pollMs` to poll
-as well). With `blocked` passed in, `sendMessage`/`regenerate` reject with `QuotaBlockedError`
-instead of starting a turn the server would refuse with `429`.
+`chat.quota` (and the standalone `useQuota()`) returns every window (`day`, `month`, …) with its
+usage and ceilings, and `blocked` when one is exhausted; it re-reads after every run a chat on the
+same backend settles. While a window is exhausted, `sendMessage`/`regenerate` reject with
+`QuotaBlockedError` (and `chat.composer.blockedBy` is `'quota'`) instead of starting a turn the server
+would refuse with `429`. `useAgentChat({ blocked })` overrides the gate (`null` never blocks);
+`quota: false` skips the request.
 
 ### The transport, standalone
 
@@ -623,7 +656,7 @@ import { useChat } from '@ai-sdk/react';
 import { AgentChatTransport } from '@dudousxd/nestjs-agent-react';
 
 const transport = new AgentChatTransport({
-  baseUrl: '/agent',
+  path: 'agent', // the default
   getHeaders: () => ({ 'x-actor-id': currentUser.id }),
   onMeta: ({ runId, threadId }) => console.log('turn started', runId, threadId),
 });
@@ -647,16 +680,15 @@ contract — for a backend that serves these routes without this library's loop
 
 ### Loading persisted history
 
-A reloaded thread's `StoredMessage[]` (from `AgentClient.getThread`) needs converting to `UIMessage[]`
-before it can seed `useChat`'s `initialMessages`:
+`useAgentChat({ threadId })` loads it for you. To seed a chat with history you already have (SSR,
+a cache), convert the thread's `StoredMessage[]` and pass it as `initialMessages` — the hook then
+skips its own read:
 
 ```ts
 import { storedThreadToUiMessages } from '@dudousxd/nestjs-agent-react';
 
-const detail = await chat.client.getThread(threadId);
 const initialMessages = storedThreadToUiMessages(detail.messages);
-// Feed into useAgentChat({ threadId, initialMessages, ... }) on the mount that owns this thread —
-// `initialMessages` is only read once, on mount.
+useAgentChat({ threadId, initialMessages });
 ```
 
 `storedThreadToUiMessages` merges the store's one-row-per-model-iteration turns (a turn with tool
@@ -668,19 +700,17 @@ persisted pushed components as `data-ui` parts, so a reloaded thread shows what
 
 ### Attachments
 
-`useAttachments` is the composer's file tray without the tray: validation, one upload per file
-with progress and cancel, retry, image previews, and the handlers for a file input, a drop zone and
-paste.
+`chat.composer.files` (or `useAttachments()` on its own) is the composer's file tray without the
+tray: validation, one upload per file with progress and cancel, retry, image previews, and the
+handlers for a file input, a drop zone and paste. `chat.composer.submit()` sends the ready files
+with the draft and clears them.
 
 ```tsx
-import { messageFiles, useAttachments } from '@dudousxd/nestjs-agent-react';
-
-const files = useAttachments({
-  backend: chat.backend, // or `upload: (file, { signal, onProgress }) => myUpload(file)`
-  accept: 'image/*,.pdf',
-  maxBytes: 20 * 1024 * 1024,
-  maxFiles: 5,
+const chat = useAgentChat({
+  // optional — or `upload: (file, { signal, onProgress }) => myUpload(file)`
+  composer: { accept: 'image/*,.pdf', maxBytes: 20 * 1024 * 1024, maxFiles: 5 },
 });
+const { files } = chat.composer;
 
 <div {...files.dropZoneProps} data-dragging={files.isDragging}>
   <textarea onPaste={files.onPaste} />
@@ -695,13 +725,8 @@ const files = useAttachments({
   ))}
 </div>
 
-<button
-  disabled={files.isUploading}
-  onClick={async () => {
-    await chat.sendMessage({ text }, { body: { attachments: files.refs } });
-    files.clear();
-  }}
-/>
+<textarea value={chat.composer.text} onChange={(e) => chat.composer.setText(e.target.value)} />
+<button disabled={!chat.composer.canSend} onClick={() => chat.composer.submit()} />
 ```
 
 An item is `uploading`, `ready`, `error` (retry with `files.retry(id)`) or `rejected` (failed
@@ -713,25 +738,25 @@ flight. `messageFiles(message)` reads the files back off any message — live or
 
 With `AgentMediaAttachmentsModule` on the server (`@dudousxd/nestjs-agent/media`), one option turns
 it on — uploads go in chunks through nestjs-media's tus endpoint, with progress, abort (`remove`)
-and retry, on the chat client's own connection (base url, headers, credentials):
+and retry, on the client's own connection (origin, path, headers, credentials):
 
 ```tsx
 import { mediaAttachments } from '@dudousxd/nestjs-agent-react/media';
 
-const chat = useAgentChat({ attachments: mediaAttachments() });
-const files = useAttachments({ backend: chat.backend });
+<AgentProvider attachments={{ upload: mediaAttachments() }}>…</AgentProvider>;
+const files = useAttachments(); // uploads resumably
 ```
 
 Headless; `@dudousxd/nestjs-media-client` is an optional peer only this subpath uses. Extending it:
 
-- `mediaAttachments({ path: '/api/agent', chunkSize, retries })` — a prefixed API, tuning.
-- `new AgentClient({ …connection, attachments: mediaAttachments() })` — your own client instance.
-- `withMediaUploads(backend, connection)` — any other `AgentBackend`; `createMediaUpload(connection)`
-  — a bare `upload` for `useAttachments({ upload })`.
+- `mediaAttachments({ chunkSize, retries })` — tuning (the path comes from the client's `path`).
+- `new AgentClient({ …connection, attachments: { upload: mediaAttachments() } })` — your own client.
+- `createMediaUpload(connection)` — a bare `upload` for `useAttachments({ upload })`, or the
+  `uploadAttachment` member of your own `AgentBackend`.
 - Refusals throw `MediaUploadError` with the HTTP `status` (`413`, `415`, …); an aborted or failed
   upload is discarded on the server.
 
-Your own storage instead: `useAgentChat({ attachments: (file, { signal, onProgress }, connection) => … })`
+Your own storage instead: `<AgentProvider attachments={{ upload: (file, { signal, onProgress }, connection) => … }}>`
 (an `AttachmentUploadStrategy`), or `useAttachments({ upload })`, resolving to a
 `{ mediaId, url, contentType, name }` your server's `AGENT_ATTACHMENT_STAGING` recognises.
 

package/dist/{client-0Wd-WPsu.d.cts → client-CYlhK7XD.d.cts}

@@ -1,4 +1,4 @@
-import { ThreadSummary, ThreadDetail, MessageAttachment, ToolCatalogEntry, SkillCatalogEntry, QuotaView, QuotaReport, ModelCatalogView, AgentCatalogEntry, MessageFeedbackValue, MessageFeedback } from '@dudousxd/nestjs-agent-core';
+import { ThreadSummary, ThreadDetail, MessageAttachment, ToolCatalogEntry, SkillCatalogEntry, QuotaReport, ModelCatalogView, AgentCatalogEntry, MessageFeedbackValue, MessageFeedback } from '@dudousxd/nestjs-agent-core';
 
 /**
  * Partial update accepted by `PATCH <base>/threads/:threadId`. `defaultAgent: null` clears a
@@ -54,15 +54,17 @@ interface UploadAttachmentOptions {
 }
 /** How {@link AgentClient} reaches the server — handed to an {@link AttachmentUploadStrategy}. */
 interface AgentConnection {
-    /** Origin + base path, trailing slash removed (`''` for same-origin). */
+    /** The server's origin, trailing slash removed (`''` for same-origin). */
     baseUrl: string;
+    /** The agent's route prefix, normalized to a leading slash (`'/agent'`), or `''`. */
+    path: string;
     /** The client's static + per-request headers, resolved now (auth, CSRF). */
     headers: () => Promise<Record<string, string>>;
     credentials?: RequestCredentials;
     fetch: typeof fetch;
 }
 /**
- * Replaces {@link AgentClient}'s own `uploadAttachment` (`POST <base>/agent/attachments`) — e.g.
+ * Replaces {@link AgentClient}'s own `uploadAttachment` (`POST <path>/attachments`) — e.g.
  * `mediaAttachments()` from `@dudousxd/nestjs-agent-react/media`, or your own storage. Gets the
  * client's connection so it needs no configuration of its own. Resolve with the attachment your
  * server's `AGENT_ATTACHMENT_STAGING` recognises by `mediaId`.
@@ -73,7 +75,8 @@ type AttachmentUploadStrategy = (file: File, options: UploadAttachmentOptions, c
  * hooks) and whatever serves the agent. {@link AgentClient} is the default implementation, over the
  * library's own REST routes with `fetch`. An app with its own client — a generated one, a different
  * auth scheme (cookie session + CSRF header), a backend that is not this library at all but speaks
- * docs/stream-protocol.md — implements this instead and passes it as `useAgentChat({ backend })`.
+ * docs/stream-protocol.md — implements this instead and passes it as `<AgentProvider backend>` (or
+ * per hook, `useAgentChat({ backend })`).
  *
  * The streaming, thread and cancel members are required: without them there is no chat. The rest
  * are optional; a hook that needs one the backend does not have throws
@@ -114,7 +117,6 @@ interface AgentBackend {
     uploadAttachment?(file: File, options?: UploadAttachmentOptions): Promise<MessageAttachment>;
     listTools?(agent?: string): Promise<ToolCatalogEntry[]>;
     listSkills?(threadId?: string): Promise<SkillCatalogEntry[]>;
-    getQuotaToday?(): Promise<QuotaView>;
     /** `GET <base>/quota` — every budget window, and which one blocks sends, if any. */
     getQuota?(): Promise<QuotaReport>;
     /** `GET <base>/models?agent=` — what a model picker offers. */
@@ -149,8 +151,6 @@ declare class AgentHttpError extends Error {
     readonly path: string;
     constructor(status: number, method: string, path: string, statusText: string);
 }
-/** The quota-today read-model: usage, the configured limit (null → unlimited), and USD spend. */
-type QuotaToday = QuotaView;
 interface CancelResult {
     aborted: boolean;
 }
@@ -158,8 +158,16 @@ interface OkResult {
     ok: boolean;
 }
 interface AgentClientOptions {
-    /** Origin + base path, e.g. `https://api.example.com`. Defaults to `''`. */
+    /**
+     * The server's origin, e.g. `https://api.example.com`. Defaults to `''` (same origin). The
+     * agent's route prefix is {@link AgentClientOptions.path}, not part of this.
+     */
     baseUrl?: string;
+    /**
+     * The agent's route prefix — `AgentModule`'s `path`, with any global prefix in front
+     * (`'api/agent'`). Leading/trailing slashes are optional. Defaults to `'agent'`.
+     */
+    path?: string;
     /** Static headers merged into every request. */
     headers?: Record<string, string>;
     /**
@@ -175,12 +183,15 @@ interface AgentClientOptions {
     credentials?: RequestCredentials;
     /** Injectable for tests / non-browser runtimes. */
     fetch?: typeof fetch;
-    /**
-     * How `uploadAttachment` uploads. Omitted → `POST <base>/agent/attachments` (multipart). Pass
-     * `mediaAttachments()` from `@dudousxd/nestjs-agent-react/media` for resumable uploads through
-     * nestjs-media, or your own {@link AttachmentUploadStrategy}.
-     */
-    attachments?: AttachmentUploadStrategy;
+    /** Attachment uploads. */
+    attachments?: {
+        /**
+         * How `uploadAttachment` uploads. Omitted → `POST <path>/attachments` (multipart). Pass
+         * `mediaAttachments()` from `@dudousxd/nestjs-agent-react/media` for resumable uploads through
+         * nestjs-media, or your own {@link AttachmentUploadStrategy}.
+         */
+        upload?: AttachmentUploadStrategy;
+    };
 }
 /**
  * Framework-agnostic REST client for the nestjs-agent endpoints — the default {@link AgentBackend}.
@@ -189,10 +200,10 @@ interface AgentClientOptions {
 declare class AgentClient implements AgentBackend {
     private readonly options;
     constructor(options?: AgentClientOptions);
-    /** `POST /agent/chat` → the turn's SSE stream. Throws {@link AgentHttpError} on a non-2xx. */
+    /** `POST <path>/chat` → the turn's SSE stream. Throws {@link AgentHttpError} on a non-2xx. */
     openChatStream(request: ChatStreamRequest): Promise<ChatStreamResponse>;
     /**
-     * `GET /agent/chat/:runId/stream[?after=<seq>]` → the run's SSE stream, or `null` when nothing is
+     * `GET <path>/chat/:runId/stream[?after=<seq>]` → the run's SSE stream, or `null` when nothing is
      * streaming under that id (404).
      */
     resumeChatStream(request: ResumeStreamRequest): Promise<ChatStreamResponse | null>;
@@ -220,25 +231,23 @@ declare class AgentClient implements AgentBackend {
     getThread(id: string): Promise<ThreadDetail>;
     deleteThread(id: string): Promise<void>;
     forkFromMessage(threadId: string, messageId: string): Promise<ThreadSummary>;
-    renameThread(id: string, title: string): Promise<OkResult>;
-    /** General `PATCH /agent/threads/:threadId` — title and/or the thread's pinned default agent. */
+    /** General `PATCH <path>/threads/:threadId` — title and/or the thread's pinned default agent. */
     updateThread(id: string, patch: ThreadPatch): Promise<OkResult>;
     /**
      * Uploads a file (image/PDF) for a vision-capable model turn. Multipart, field name `file` —
-     * mirrors the backend's `POST /agent/attachments`. The returned {@link MessageAttachment} is
+     * mirrors the backend's `POST <path>/attachments`. The returned {@link MessageAttachment} is
      * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
      */
     uploadAttachment(file: File, options?: UploadAttachmentOptions): Promise<MessageAttachment>;
     private uploadWithProgress;
     promoteThread(id: string): Promise<OkResult>;
     truncateFromMessage(threadId: string, messageId: string): Promise<OkResult>;
-    /** `GET /agent/models?agent=` — the models this caller may pick, grouped by provider. */
+    /** `GET <path>/models?agent=` — the models this caller may pick, grouped by provider. */
     listModels(agent?: string): Promise<ModelCatalogView>;
-    /** `GET /agent/agents` — the registered agents, the default one flagged. */
+    /** `GET <path>/agents` — the registered agents, the default one flagged. */
     listAgents(): Promise<AgentCatalogEntry[]>;
-    /** `GET /agent/quota` — the caller's budget windows and the one blocking sends, if any. */
+    /** `GET <path>/quota` — the caller's budget windows and the one blocking sends, if any. */
     getQuota(): Promise<QuotaReport>;
-    getQuotaToday(): Promise<QuotaToday>;
     cancelStream(runId: string): Promise<CancelResult>;
     /**
      * `remember` approves later calls of the same tool in the same thread; `via` names the surface
@@ -276,10 +285,13 @@ declare class AgentClient implements AgentBackend {
     /** This client's connection, for an {@link AttachmentUploadStrategy}. */
     private connection;
     private baseUrl;
+    private agentPath;
+    /** Origin + agent path: what every route hangs off. */
+    private root;
     private resolveHeaders;
     private credentials;
     private request;
     private handleResponse;
 }
 
-export { type AgentBackend as A, type CancelResult as C, type MessageFeedbackInput as M, type QuotaToday as Q, type ResumeStreamRequest as R, type ThreadPatch as T, type UploadAttachmentOptions as U, AgentClient as a, type AttachmentUploadStrategy as b, AgentBackendUnsupportedError as c, type AgentClientOptions as d, type AgentConnection as e, AgentHttpError as f, type ChatStreamRequest as g, type ChatStreamResponse as h, requireBackendMethod as r };
+export { type AgentBackend as A, type CancelResult as C, type MessageFeedbackInput as M, type ResumeStreamRequest as R, type ThreadPatch as T, type UploadAttachmentOptions as U, type AttachmentUploadStrategy as a, AgentBackendUnsupportedError as b, AgentClient as c, type AgentClientOptions as d, type AgentConnection as e, AgentHttpError as f, type ChatStreamRequest as g, type ChatStreamResponse as h, requireBackendMethod as r };