@dudousxd/nestjs-agent-react 0.19.0 → 0.21.0

package/README.md

@@ -19,10 +19,7 @@ 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
@@ -37,6 +34,31 @@ function Chat() {
 }
 ```
 
+### 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,7 +80,7 @@ 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();
   const transcript = useChatTranscript({
     messages: chat.messages,
     status: chat.status,
@@ -134,8 +156,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 +352,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 +442,12 @@ 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 }),
     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".
@@ -517,7 +537,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 +549,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 +577,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>
@@ -573,9 +596,9 @@ its run persisted (the live message carries `metadata.runId`).
 import { useAgents, useModels } from '@dudousxd/nestjs-agent-react';
 
 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 });
+const chat = useAgentChat({ model }); // sent as the body's `model` on every turn
+const { providers, find, defaultModel } = useModels({ agent: 'support' });
+const { agents } = useAgents();
 
 <select value={model ?? defaultModel ?? ''} onChange={(e) => setModel(e.target.value)}>
   {providers.map((p) => (
@@ -601,8 +624,8 @@ 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 quota = useQuota();                           // GET <base>/quota
+const chat = useAgentChat({ blocked: quota.blocked });
 
 <meter value={quota.month?.usedUsd} max={quota.month?.limitUsd} />
 {quota.blocked ? <p>{quota.blocked.reason}</p> : null}
@@ -623,7 +646,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),
 });
@@ -653,7 +676,7 @@ before it can seed `useChat`'s `initialMessages`:
 ```ts
 import { storedThreadToUiMessages } from '@dudousxd/nestjs-agent-react';
 
-const detail = await chat.client.getThread(threadId);
+const detail = await chat.backend.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.
@@ -676,7 +699,7 @@ paste.
 import { messageFiles, useAttachments } from '@dudousxd/nestjs-agent-react';
 
 const files = useAttachments({
-  backend: chat.backend, // or `upload: (file, { signal, onProgress }) => myUpload(file)`
+  // uploads through the provider's backend; or `upload: (file, { signal, onProgress }) => myUpload(file)`
   accept: 'image/*,.pdf',
   maxBytes: 20 * 1024 * 1024,
   maxFiles: 5,
@@ -709,6 +732,32 @@ An item is `uploading`, `ready`, `error` (retry with `files.retry(id)`) or `reje
 flight. `messageFiles(message)` reads the files back off any message — live or replayed — with a
 `kind` (`image`, `pdf`, `text`, …), the extension and, for replayed ones, the stored `mediaId`.
 
+#### Resumable uploads on nestjs-media (`@dudousxd/nestjs-agent-react/media`)
+
+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 client's own connection (origin, path, headers, credentials):
+
+```tsx
+import { mediaAttachments } from '@dudousxd/nestjs-agent-react/media';
+
+<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({ 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: `<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.
+
 The rest of `AgentClient` works outside `useAgentChat` too — e.g. a standalone approvals inbox:
 
 ```ts

package/dist/client-ePlgRwP-.d.cts

@@ -0,0 +1,302 @@
+import { ThreadSummary, ThreadDetail, MessageAttachment, ToolCatalogEntry, SkillCatalogEntry, QuotaView, QuotaReport, ModelCatalogView, AgentCatalogEntry, MessageFeedbackValue, MessageFeedback } from '@dudousxd/nestjs-agent-core';
+
+/**
+ * Partial update accepted by `PATCH <base>/threads/:threadId`. `defaultAgent: null` clears a
+ * previously-set default back to the module's own default; omitting it leaves the thread's
+ * current default untouched.
+ */
+interface ThreadPatch {
+    title?: string;
+    defaultAgent?: string | null;
+    /** Pin a catalog model on the thread; `null` unpins it. */
+    model?: string | null;
+}
+/** Starting a turn: the body `POST <base>/chat` takes (see docs/stream-protocol.md). */
+interface ChatStreamRequest {
+    /** `{ message, threadId?, agent?, model?, attachments?, pageContext?, regenerate?, … }`. */
+    body: Record<string, unknown>;
+    /** Per-request headers the AI SDK was handed for this send. */
+    headers?: Record<string, string>;
+    /** Aborted when the user stops the turn. */
+    signal?: AbortSignal;
+}
+/** Attaching to a run that is already streaming: `GET <base>/chat/:runId/stream?after=<seq>`. */
+interface ResumeStreamRequest {
+    runId: string;
+    /**
+     * The sequence number (SSE `id:`) of the last frame the client already has. Omitted → replay
+     * from the first frame. A backend that cannot skip may ignore it: the transport also drops frames
+     * at or below it.
+     */
+    after?: number;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * An open chat stream: the raw `text/event-stream` bytes in the stream-protocol framing, plus the
+ * identity a backend may learn before the first frame (the `X-Agent-Run-Id` / `X-Agent-Thread-Id`
+ * headers). The body's own `event: meta` frame supplies them otherwise.
+ */
+interface ChatStreamResponse {
+    body: ReadableStream<Uint8Array>;
+    runId?: string;
+    threadId?: string;
+}
+/** What `POST <base>/messages/:id/feedback` takes. `value: null` clears the rating. */
+interface MessageFeedbackInput {
+    value: MessageFeedbackValue | null;
+    comment?: string;
+}
+interface UploadAttachmentOptions {
+    signal?: AbortSignal;
+    /** Called with 0..1 as the upload progresses, when the backend can observe it. */
+    onProgress?: (fraction: number) => void;
+}
+/** How {@link AgentClient} reaches the server — handed to an {@link AttachmentUploadStrategy}. */
+interface AgentConnection {
+    /** 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 <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`.
+ */
+type AttachmentUploadStrategy = (file: File, options: UploadAttachmentOptions, connection: AgentConnection) => Promise<MessageAttachment>;
+/**
+ * Everything the React layer asks of a server — the seam between `useAgentChat` (and the other
+ * 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 `<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
+ * {@link AgentBackendUnsupportedError} when it is called, so a backend only implements what its
+ * server supports.
+ */
+interface AgentBackend {
+    /** Start a turn and return its SSE stream. Throw on a non-2xx answer. */
+    openChatStream(request: ChatStreamRequest): Promise<ChatStreamResponse>;
+    /** Attach to a streaming run. Resolve `null` when nothing is streaming under that id (HTTP 404). */
+    resumeChatStream(request: ResumeStreamRequest): Promise<ChatStreamResponse | null>;
+    /** Hard-stop a run server-side. */
+    cancelStream(runId: string): Promise<unknown>;
+    listThreads(): Promise<ThreadSummary[]>;
+    getThread(id: string): Promise<ThreadDetail>;
+    updateThread(id: string, patch: ThreadPatch): Promise<unknown>;
+    deleteThread(id: string): Promise<unknown>;
+    forkFromMessage?(threadId: string, messageId: string): Promise<ThreadSummary>;
+    promoteThread?(id: string): Promise<unknown>;
+    truncateFromMessage?(threadId: string, messageId: string): Promise<unknown>;
+    approveToolCall?(input: {
+        toolCallId: string;
+        remember?: boolean;
+        via?: string;
+    }): Promise<unknown>;
+    rejectToolCall?(input: {
+        toolCallId: string;
+        reason?: string;
+        via?: string;
+    }): Promise<unknown>;
+    answerToolCall?(input: {
+        toolCallId: string;
+        answers?: Record<string, string[]>;
+    }): Promise<unknown>;
+    skipToolCall?(input: {
+        toolCallId: string;
+    }): Promise<unknown>;
+    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. */
+    listModels?(agent?: string): Promise<ModelCatalogView>;
+    /** `GET <base>/agents` — what an agent picker offers. */
+    listAgents?(): Promise<AgentCatalogEntry[]>;
+    setMessageFeedback?(messageId: string, input: MessageFeedbackInput): Promise<{
+        feedback: MessageFeedback | null;
+    }>;
+}
+/** An optional {@link AgentBackend} member the bound backend does not implement was called. */
+declare class AgentBackendUnsupportedError extends Error {
+    readonly method: string;
+    constructor(method: string);
+}
+type OptionalMethod = {
+    [K in keyof AgentBackend]-?: undefined extends AgentBackend[K] ? K : never;
+}[keyof AgentBackend];
+/**
+ * The optional backend method `name`, bound — or a throw naming it. For hook code that has to call
+ * something a backend may not offer.
+ */
+declare function requireBackendMethod<K extends OptionalMethod>(backend: AgentBackend, name: K): NonNullable<AgentBackend[K]>;
+
+/**
+ * Thrown by {@link AgentClient} on a non-2xx response. Carries the HTTP `status` so callers can
+ * branch (e.g. 403 → "not your thread", 429 → quota) instead of string-matching a generic Error.
+ */
+declare class AgentHttpError extends Error {
+    readonly status: number;
+    readonly method: string;
+    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;
+}
+interface OkResult {
+    ok: boolean;
+}
+interface AgentClientOptions {
+    /**
+     * 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>;
+    /**
+     * Resolved per request — for short-lived bearer tokens, or a CSRF header read from a cookie
+     * (`{ 'X-XSRF-TOKEN': readCookie('XSRF-TOKEN') }`), which has to be read at request time because
+     * the server may rotate it.
+     */
+    getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+    /**
+     * Forwarded to fetch so cookie auth works. Same-origin requests send cookies by default; set
+     * `'include'` when the API lives on another origin (and have it answer with credentialed CORS).
+     */
+    credentials?: RequestCredentials;
+    /** Injectable for tests / non-browser runtimes. */
+    fetch?: typeof fetch;
+    /** 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}.
+ * Used by `useAgentChat`, but standalone-usable (vanilla fetch, no React).
+ */
+declare class AgentClient implements AgentBackend {
+    private readonly options;
+    constructor(options?: AgentClientOptions);
+    /** `POST <path>/chat` → the turn's SSE stream. Throws {@link AgentHttpError} on a non-2xx. */
+    openChatStream(request: ChatStreamRequest): Promise<ChatStreamResponse>;
+    /**
+     * `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>;
+    /**
+     * Rate a message (`'up'`/`'down'`, optional comment) or clear its rating (`value: null`). Answers
+     * the stored rating.
+     */
+    setMessageFeedback(messageId: string, input: MessageFeedbackInput): Promise<{
+        feedback: MessageFeedback | null;
+    }>;
+    listThreads(): Promise<ThreadSummary[]>;
+    /**
+     * The skills this caller can invoke right now, scope-resolved — the same list, built by the same
+     * call, that the model is offered, so what a user can type after a `/` and what the agent can
+     * reach cannot drift apart. `threadId` reaches the host's own resolver, which may scope a skill to
+     * one conversation; omitted, the server reads it as a brand-new thread.
+     */
+    listSkills(threadId?: string): Promise<SkillCatalogEntry[]>;
+    /**
+     * The tools this caller can reach through `agent` (the default agent when omitted), each with the
+     * server-declared `presentation` a chat narrates it by — the same list the model is offered.
+     * Prefer {@link useToolCatalog}, which fetches it once and shares it.
+     */
+    listTools(agent?: string): Promise<ToolCatalogEntry[]>;
+    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 <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 <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 <path>/models?agent=` — the models this caller may pick, grouped by provider. */
+    listModels(agent?: string): Promise<ModelCatalogView>;
+    /** `GET <path>/agents` — the registered agents, the default one flagged. */
+    listAgents(): Promise<AgentCatalogEntry[]>;
+    /** `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
+     * the decision came through (the server records `'web'` when omitted).
+     */
+    approveToolCall(input: {
+        toolCallId: string;
+        remember?: boolean;
+        via?: string;
+    }): Promise<void>;
+    rejectToolCall(input: {
+        toolCallId: string;
+        reason?: string;
+        via?: string;
+    }): Promise<void>;
+    /**
+     * Settle a parked question set. `answers` is questionId → chosen option values; a question left
+     * out takes the pre-picked default the request carried, resolved server-side against the request
+     * the run already holds. Omit the whole object and the user has confirmed every pre-picked
+     * answer — which is the point of the surface, so it is a valid submission rather than a blank.
+     */
+    answerToolCall(input: {
+        toolCallId: string;
+        answers?: Record<string, string[]>;
+    }): Promise<void>;
+    /**
+     * Decline to answer and let the agent proceed on its own pre-picked values. Lands on the same
+     * values a confirmation would, and persists differently on purpose — only one of them is
+     * evidence the user chose them.
+     */
+    skipToolCall(input: {
+        toolCallId: string;
+    }): Promise<void>;
+    private fetchImpl;
+    /** 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, 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 };