@adonis-agora/agent 0.61.0 → 0.63.0

package/dist/src/react/core/transcript/use-stick-to-bottom.js

@@ -0,0 +1,48 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * Follow a streaming transcript only while the reader is already at the bottom. Reading back
+ * through history during a stream is the case this exists for: an unconditional scroll-to-bottom
+ * yanks the viewport away mid-sentence on every token.
+ */
+export function useStickToBottom({ contentKey, threshold = 32, }) {
+    const containerRef = useRef(null);
+    const [isAtBottom, setIsAtBottom] = useState(true);
+    const measure = useCallback(() => {
+        const element = containerRef.current;
+        if (!element) {
+            return;
+        }
+        const distance = element.scrollHeight - element.scrollTop - element.clientHeight;
+        setIsAtBottom(distance <= threshold);
+    }, [threshold]);
+    const scrollToBottom = useCallback(() => {
+        const element = containerRef.current;
+        if (!element) {
+            return;
+        }
+        element.scrollTop = element.scrollHeight;
+        setIsAtBottom(true);
+    }, []);
+    const setContainer = useCallback((element) => {
+        containerRef.current = element;
+        if (element) {
+            measure();
+        }
+    }, [measure]);
+    // Re-pin as content arrives. Guarded on `isAtBottom` so a reader who scrolled up keeps their
+    // position for the rest of the stream, and re-pins the moment they scroll back down.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: `contentKey` IS the content dependency
+    useEffect(() => {
+        if (isAtBottom) {
+            scrollToBottom();
+        }
+    }, [contentKey, isAtBottom, scrollToBottom]);
+    const getContainerProps = useCallback(() => ({ ref: setContainer, onScroll: measure }), [setContainer, measure]);
+    return {
+        isAtBottom,
+        showJumpToLatest: !isAtBottom,
+        scrollToBottom,
+        getContainerProps,
+    };
+}
+//# sourceMappingURL=use-stick-to-bottom.js.map

package/dist/src/react/core/transcript/use-stick-to-bottom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stick-to-bottom.js","sourceRoot":"","sources":["../../../../../src/react/core/transcript/use-stick-to-bottom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AA8BjE;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAC/B,UAAU,EACV,SAAS,GAAG,EAAE,GACO;IACrB,MAAM,YAAY,GAAG,MAAM,CAAqB,IAAI,CAAC,CAAC;IACtD,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAEnD,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE;QAC/B,MAAM,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC;QACrC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,GAAG,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC;QACjF,aAAa,CAAC,QAAQ,IAAI,SAAS,CAAC,CAAC;IACvC,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAEhB,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;QACtC,MAAM,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC;QACrC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QACD,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,aAAa,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,YAAY,GAAG,WAAW,CAC9B,CAAC,OAA2B,EAAE,EAAE;QAC9B,YAAY,CAAC,OAAO,GAAG,OAAO,CAAC;QAC/B,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,EACD,CAAC,OAAO,CAAC,CACV,CAAC;IAEF,6FAA6F;IAC7F,qFAAqF;IACrF,kGAAkG;IAClG,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,UAAU,EAAE,CAAC;YACf,cAAc,EAAE,CAAC;QACnB,CAAC;IACH,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;IAE7C,MAAM,iBAAiB,GAAG,WAAW,CACnC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAChD,CAAC,YAAY,EAAE,OAAO,CAAC,CACxB,CAAC;IAEF,OAAO;QACL,UAAU;QACV,gBAAgB,EAAE,CAAC,UAAU;QAC7B,cAAc;QACd,iBAAiB;KAClB,CAAC;AACJ,CAAC"}

package/dist/src/react/core/use-agent-chat.d.ts

@@ -0,0 +1,341 @@
+import type { DataUIPart, UIDataTypes, UIMessage } from 'ai';
+import type { UiCapabilities } from '../../genui/index.js';
+import type { QuotaBlock, ThreadSummary } from '../../index.js';
+import { type ReconnectOptions, type StreamConnectionState } from './agent-chat-transport.js';
+import { type AttachmentsState, type UseAttachmentsOptions } from './attachments/use-attachments.js';
+import { type AgentBackend } from './backend.js';
+import { type BackgroundRun } from './background-runs.js';
+import { type ModelOption, type ModelsState } from './catalog/use-models.js';
+import type { ChatQueue, SendWhileRunning, WhileRunning } from './queue/model.js';
+import { type QuotaState } from './quota/use-quota.js';
+import type { AgentRunFailure } from './run-errors.js';
+import type { ChatStatus } from './transcript/model.js';
+import { type AnswerInput, type ApproveInput, type ChatTranscript, type MessageActionInput, type RejectInput, type SkipInput, type UseChatTranscriptOptions } from './transcript/use-chat-transcript.js';
+export interface UseAgentChatOptions<B extends AgentBackend = AgentBackend> {
+    uiCapabilities?: UiCapabilities;
+    proposalPollMs?: number;
+    /** Enable proposal reads even when history and resume are both disabled. */
+    proposals?: boolean;
+    /**
+     * What the chat talks to — see {@link AgentBackend}. Omitted → the enclosing `<AgentProvider>`'s,
+     * else a same-origin client on `/agent`. Must be stable across renders.
+     */
+    backend?: B;
+    /**
+     * Retry a stream that dropped mid-run from its last frame (`GET <base>/chat/:runId/stream?after=`),
+     * with exponential backoff. `status` reads `'reconnecting'` meanwhile. Default on; `false` turns
+     * it off.
+     */
+    reconnect?: ReconnectOptions | false;
+    /** Named agent to run each turn. */
+    agent?: string;
+    /**
+     * One of the agent's personas (`GET <base>/agents` lists them) to answer as. Read per send, so a
+     * picker can switch it between messages; the server pins it on the thread, and `threadPersona`
+     * reports it back. Omitted → the thread's pinned persona, else the agent's default. A single send
+     * can name its own: `sendMessage(message, { body: { persona } })`.
+     */
+    persona?: string;
+    /**
+     * Thread this chat is bound to. Omitted → the backend creates one on the first send
+     * ({@link UseAgentChatOptions.onThreadCreated}). Changing it switches the chat to that thread:
+     * its history loads and a turn still streaming on it is re-attached. Switching to the thread this
+     * chat just created (syncing a URL) keeps the live conversation as it is.
+     */
+    threadId?: string;
+    /**
+     * Load a `threadId`'s persisted history into the chat (`GET <base>/threads/:id`). Default `true`;
+     * skipped when {@link UseAgentChatOptions.initialMessages} is given. `false` opts out.
+     */
+    history?: boolean;
+    /** Persisted history you already have — seeds the chat instead of loading it (read per thread). */
+    initialMessages?: UIMessage[];
+    /**
+     * Re-attach to a turn that was still streaming on `threadId` when the page (re)loaded — read off
+     * the thread's `activeRunId`, so a reload mid-answer keeps streaming it. Default `true`; `false`
+     * opts out.
+     */
+    resume?: boolean;
+    /**
+     * A run id you already know is streaming — attached to on mount without reading the thread first.
+     * Rarely needed: {@link UseAgentChatOptions.resume} finds it by itself.
+     */
+    resumeRunId?: string;
+    /**
+     * The model every turn runs on, controlled by you. Omitted → `chat.models.selected` (what
+     * `chat.models.select(id)` picked), else the thread's pinned model, else the server default. A
+     * single send can still override it with `sendMessage(msg, { body: { model } })`. Sent as the
+     * turn's `model`, which the server applies to that turn only — pinning a model on the thread is
+     * `chat.models.pinToThread(id)`.
+     */
+    model?: string;
+    /**
+     * Read the caller's budget (`GET <base>/quota`) and refuse sends while a window is exhausted.
+     * Default `true` when the backend implements `getQuota`; `false` skips the request.
+     */
+    quota?: boolean;
+    /**
+     * Override the quota gate: `null` never blocks, a {@link QuotaBlock} always does. Omitted → the
+     * gate follows {@link UseAgentChatOptions.quota}'s report. While blocked, `sendMessage` and
+     * `regenerate` refuse with {@link QuotaBlockedError}.
+     */
+    blocked?: QuotaBlock | null;
+    /** Validation and upload for `chat.composer.files` — see `useAttachments`. */
+    composer?: Omit<UseAttachmentsOptions, 'backend'>;
+    /**
+     * What `composer.submit()` and `sendMessage` do while a turn is still running. Default `'queue'`:
+     * the message waits in the thread's queue (server-side — it survives a reload) and runs when the
+     * turn settles; `chat.queue` lists and edits what is waiting. `'interrupt'` cancels the running
+     * turn and runs the message next. `'block'` refuses the send (`composer.blockedBy === 'busy'`).
+     * A backend without `enqueueMessage` behaves as `'block'`. One send can answer differently:
+     * `composer.submit({ mode })`, `sendMessage(message, { mode })`.
+     */
+    whileRunning?: WhileRunning;
+    /**
+     * Overrides for `chat.transcript` — anything `useChatTranscript` takes (`sources`, `editable` +
+     * `onEditSubmit`, `followUps`, `getUsage`, a `toolCatalog` of your own, `onApprove: null`, …).
+     * Yours win over the chat's own wiring.
+     */
+    transcript?: Partial<Omit<UseChatTranscriptOptions, 'messages' | 'status'>>;
+    /** Read at every send to capture a page snapshot for the page-assistant. */
+    getPageContext?: () => Record<string, unknown> | null;
+    /** Fired after each streamed turn finishes (e.g. to refetch the sidebar). */
+    onFinish?: () => void;
+    /**
+     * Fired when this chat moves to a thread it created: the first send of a threadless chat (the
+     * backend created one), or `chat.fork(…)`. Carries the id so the host can sync its URL/router.
+     * The hook already remembers a created thread, so every later send reuses it even before the
+     * host navigates.
+     */
+    onThreadCreated?: (threadId: string) => void;
+    /**
+     * Fired exactly once per run when its stream settles — normally (`'completed'`) or via a thrown
+     * failure / the backend's `event: error` frame (`'failed'`) — including a RESUMED stream's own
+     * completion. By the time this fires, the server has already derived and persisted the thread's
+     * title (and the run's terminal state).
+     *
+     * Skipped when the attempt never got far enough to learn a run id. A user-initiated `cancel()`
+     * reports `'completed'` (the server-side cancel records its own terminal state).
+     */
+    onRunSettled?: (outcome: {
+        runId: string;
+        status: 'completed' | 'failed';
+    }) => void;
+    /**
+     * Every data part the stream delivers, as it arrives — including transient ones that are never
+     * stored on a message (`data-title`, `data-cancelled`). Pushed components arrive as `data-ui`,
+     * approval metadata as `data-approval-requested`, and a frame kind this version does not map as
+     * `data-<kind>`. See `AgentChatTransport` for the full mapping.
+     */
+    onData?: (part: DataUIPart<UIDataTypes>) => void;
+    /** The server set or changed the thread's title while a turn streamed. */
+    onTitle?: (title: string) => void;
+    /**
+     * Track DETACHED sub-agents this conversation started: which are still working, and their answers
+     * as they land (see {@link ChatBackground}). Default `false`.
+     */
+    background?: boolean;
+    /**
+     * How often to re-read the thread while a detached sub-agent is still working, in ms. Default
+     * 5000; `0` turns the interval off, leaving {@link ChatBackground.refresh} as the only trigger.
+     */
+    backgroundPollMs?: number;
+}
+/** Sub-agents this conversation started and did not wait for. See {@link BackgroundRun}. */
+export interface ChatBackground {
+    runs: BackgroundRun[];
+    /** True while any of them is still working — what a "2 agents running" affordance reads. */
+    isWorking: boolean;
+    /** Re-read the thread now, instead of waiting for the next poll. */
+    refresh: () => Promise<void>;
+}
+/**
+ * The chat's model picker state. Loaded the first time `list`/`providers`/`defaultModel`/`locked`
+ * is read.
+ *
+ * Two different choices: `select(id)` picks the model this chat's following sends name — each send
+ * carries it as `model`, which the server applies to that turn only and never stores; the pick is
+ * this conversation's, so switching threads drops it. `pinToThread(id)` stores a model on the
+ * thread (`PATCH threads/:id { model }`), which every later turn without a `model` of its own runs
+ * on, across reloads and devices.
+ */
+export interface ChatModels {
+    /** Every model the caller may pick, flattened (`[]` until loaded). */
+    readonly list: ModelOption[];
+    /** The same, grouped by provider. */
+    readonly providers: ModelsState['providers'];
+    /**
+     * What the next turn runs on: the lock, the `model` option, the pick, the thread's pin, else the
+     * default.
+     */
+    selected: string | null;
+    /** The model pinned on the thread (`null` when none, or before the thread is read). */
+    pinned: string | null;
+    /** The catalog's default — what a turn runs on when nothing is picked or pinned (`null` until loaded). */
+    readonly defaultModel: string | null;
+    /**
+     * The agent always runs on one model (`{ model, reason? }`), or `null`. While locked, `select`
+     * does nothing and `selected` is the locked model.
+     */
+    readonly locked: ModelsState['locked'];
+    /** Run this chat's following sends on `id` — each send's `model`, that turn only. */
+    select: (id: string) => void;
+    /**
+     * Pin `id` on the thread (`null` unpins) — every later turn without its own `model` runs on it,
+     * across reloads. Replaces the pick, so the next send runs on the pin. On a chat with no thread
+     * yet, the pin lands when the first send creates one.
+     */
+    pinToThread: (id: string | null) => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+}
+/** Why the composer cannot send right now. */
+export type ComposerBlock = 'empty' | 'busy' | 'uploading' | 'quota';
+/** A headless composer: the draft, its files, and whether (and why not) it can send. */
+export interface ChatComposer {
+    text: string;
+    setText: (text: string) => void;
+    /** The staged attachments — `useAttachments` state on the chat's backend. */
+    files: AttachmentsState;
+    canSend: boolean;
+    /** Why `canSend` is false, or `null`. */
+    blockedBy: ComposerBlock | null;
+    /**
+     * Send the draft with the ready files attached, then clear both. A no-op while blocked.
+     *
+     * `submit({ mode })` says what to do if a turn is running, for this send only — `'interrupt'`
+     * for a "send now" button next to a plain send that queues. It overrides `whileRunning`
+     * (`'block'` included) and clears the draft like any other submit.
+     */
+    submit: (options?: SendWhileRunning) => Promise<void>;
+}
+interface AddToolResultArgs {
+    tool: string;
+    toolCallId: string;
+    output: unknown;
+}
+/**
+ * The agent chat, wired: the AI SDK v7 `useChat` over `AgentChatTransport`, a thread's history
+ * loaded and a streaming turn re-attached on its own, a quota send gate, a model picker, a headless
+ * composer with attachments, and a transcript whose approve/reject/answer/skip/stop/fork/regenerate
+ * are already bound. Every piece is also a hook of its own (`useChatTranscript`, `useAttachments`,
+ * `useModels`, `useQuota`, `useThreads`) for a host that wants to wire it differently.
+ */
+export declare function useAgentChat<B extends AgentBackend = AgentBackend>(options?: UseAgentChatOptions<B>): {
+    messages: UIMessage<unknown, UIDataTypes, import("ai").UITools>[];
+    resumeStream: (options?: import("ai").ChatRequestOptions) => Promise<void>;
+    clearError: () => void;
+    addToolApprovalResponse: import("ai").ChatAddToolApproveResponseFunction;
+    addToolOutput: import("ai").ChatAddToolOutputFunction<UIMessage<unknown, UIDataTypes, import("ai").UITools>>;
+    stop: () => Promise<void>;
+    id: string;
+    setMessages: (messages: UIMessage<unknown, UIDataTypes, import("ai").UITools>[] | ((messages: UIMessage<unknown, UIDataTypes, import("ai").UITools>[]) => UIMessage<unknown, UIDataTypes, import("ai").UITools>[])) => void;
+    error: Error | undefined;
+    status: ChatStatus;
+    /** Where the live stream stands — see {@link StreamConnectionState}. */
+    connection: StreamConnectionState;
+    sendMessage: (message?: Parameters<(message?: {
+        text: string;
+        files?: FileList | import("ai").FileUIPart[];
+        metadata?: unknown;
+        parts?: never;
+        messageId?: string;
+    } | {
+        files: FileList | import("ai").FileUIPart[];
+        metadata?: unknown;
+        parts?: never;
+        messageId?: string;
+    } | (Omit<UIMessage<unknown, UIDataTypes, import("ai").UITools>, "id" | "role"> & {
+        id?: string;
+        role?: "assistant" | "system" | "user";
+    } & {
+        text?: never;
+        files?: never;
+        messageId?: string;
+    }) | undefined, options?: import("ai").ChatRequestOptions) => Promise<void>>[0], options?: Parameters<(message?: {
+        text: string;
+        files?: FileList | import("ai").FileUIPart[];
+        metadata?: unknown;
+        parts?: never;
+        messageId?: string;
+    } | {
+        files: FileList | import("ai").FileUIPart[];
+        metadata?: unknown;
+        parts?: never;
+        messageId?: string;
+    } | (Omit<UIMessage<unknown, UIDataTypes, import("ai").UITools>, "id" | "role"> & {
+        id?: string;
+        role?: "assistant" | "system" | "user";
+    } & {
+        text?: never;
+        files?: never;
+        messageId?: string;
+    }) | undefined, options?: import("ai").ChatRequestOptions) => Promise<void>>[1] & SendWhileRunning) => Promise<void>;
+    addToolResult: ({ tool, toolCallId, output }: AddToolResultArgs) => void | PromiseLike<void>;
+    /** Sub-agents this conversation started and did not wait for. */
+    background: ChatBackground;
+    proposals: import("./approvals/use-action-proposals.js").ActionProposalsState;
+    runId: string | undefined;
+    /** The loaded thread's running turn, or `null` once read with none. */
+    activeRunId: string | null;
+    /** The thread's history is being read. */
+    isLoadingHistory: boolean;
+    /** Reading the thread's history failed. */
+    historyError: Error | null;
+    /**
+     * How the last run's stream said it failed — the `event: error` frame's `code` and `message` —
+     * or `null`. Cleared when the next attempt starts and when the chat moves to another thread.
+     * `chat.error` still carries the message; this is where the `code` is, so the app can word each
+     * failure itself (`replay_diverged`, `model_no_output`, `run_failed`, `quota_exceeded`, …).
+     */
+    runError: AgentRunFailure | null;
+    /**
+     * The thread this chat is on right now: the `threadId` option, else the one the backend created
+     * on the first send. A getter, because the created id is learned mid-stream.
+     */
+    getThreadId: () => string | undefined;
+    /** The backend this chat talks to — the same one every other hook under the provider uses. */
+    backend: B;
+    /** The transcript model, with every action already bound to this chat. */
+    transcript: ChatTranscript;
+    /** A headless composer: draft, files, send gate, `submit()`. */
+    composer: ChatComposer;
+    /**
+     * Messages sent while a turn was running, waiting their turn (server-side): list, edit, move,
+     * remove, clear, and resume a paused queue.
+     */
+    queue: ChatQueue;
+    /** The model picker: `list`, `selected`, `select(id)`, `pinToThread(id)`. */
+    models: ChatModels;
+    /**
+     * The persona pinned on this thread (`ThreadSummary.persona`), or `null` when none is — what a
+     * persona picker on a reopened thread starts from (`?? agent.defaultPersona`).
+     */
+    threadPersona: string | null;
+    /** The caller's budget (`GET <base>/quota`); `quota.blocked` gates sends. */
+    quota: QuotaState;
+    /** The window blocking sends right now (the `blocked` option, else the quota report's). */
+    blocked: QuotaBlock | null;
+    cancel: () => Promise<void>;
+    approve: ({ toolCallId, target, remember, via }: ApproveInput) => Promise<void>;
+    reject: ({ toolCallId, target, reason, via }: RejectInput) => Promise<void>;
+    answer: ({ toolCallId, answers, via }: AnswerInput) => Promise<void>;
+    skip: ({ toolCallId, via }: SkipInput) => Promise<void>;
+    regenerate: (_input?: Partial<MessageActionInput>) => void;
+    fork: ({ messageId, threadId, }: MessageActionInput & {
+        threadId?: string;
+    }) => Promise<ThreadSummary>;
+    truncateFrom: ({ messageId, threadId }: MessageActionInput & {
+        threadId?: string;
+    }) => Promise<void>;
+    promote: ({ threadId }?: {
+        threadId?: string;
+    }) => Promise<void>;
+};
+/** A send refused on the client because a quota window is exhausted. */
+export declare class QuotaBlockedError extends Error {
+    readonly block: QuotaBlock;
+    constructor(block: QuotaBlock);
+}
+export {};
+//# sourceMappingURL=use-agent-chat.d.ts.map

package/dist/src/react/core/use-agent-chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-agent-chat.d.ts","sourceRoot":"","sources":["../../../../src/react/core/use-agent-chat.ts"],"names":[],"mappings":"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"}