@dudousxd/nestjs-agent 1.39.0 → 2.0.0

package/dist/index.d.ts

@@ -1,17 +1,20 @@
-import { DynamicModule, Type, OnApplicationBootstrap, OnModuleInit, ConflictException, OnModuleDestroy } from '@nestjs/common';
-import { b as AgentModuleOptions, c as AgentModuleAsyncOptions, d as AgentProtocolAdapter, A as AgentDepsFactory, e as AgentSkillsOptions, C as ChatQueueService } from './chat-queue.service-YjiKVTKE.js';
-export { f as AGENT_TOOL_BRAND, g as AgentAttachmentsOptions, h as AgentDeps, i as AgentEngine, j as AgentMemoryOptions, a as AgentSurface, F as FunctionalTool, L as LedgerQuotaProvider, Q as QueuePlan, k as QueueSettleOutcome, l as QueuedTurn, m as QueuedTurnStarter, n as QuotaLimits, o as QuotaWindowLimits, p as defineTool, q as delegateToolName, r as provideAgentTool, s as provideAgentTools, u as utcDay } from './chat-queue.service-YjiKVTKE.js';
+import { DynamicModule, OnModuleInit, Type, OnApplicationBootstrap, ConflictException, OnModuleDestroy } from '@nestjs/common';
+import { b as AgentModuleOptions, c as AgentModuleAsyncOptions, d as AgentProtocolAdapter, A as AgentDepsFactory, e as AgentSkillsOptions, C as ChatQueueService } from './chat-queue.service-BjPCw4Pf.js';
+export { f as AGENT_TOOL_BRAND, g as AgentAttachmentsOptions, h as AgentDeps, i as AgentDurableOptions, j as AgentEngine, k as AgentFunctionCaller, l as AgentMemoryOptions, a as AgentSurface, F as FunctionalTool, L as LedgerQuotaProvider, Q as QueuePlan, m as QueueSettleOutcome, n as QueuedTurn, o as QueuedTurnStarter, p as QuotaLimits, q as QuotaWindowLimits, r as defaultAgentFunctionCaller, s as defineTool, t as delegateToolName, u as durableEngineOf, v as provideAgentTool, w as provideAgentTools, x as utcDay } from './chat-queue.service-BjPCw4Pf.js';
 import * as _dudousxd_nestjs_agent_core from '@dudousxd/nestjs-agent-core';
-import { ActorResolver, AttachmentStagingStore, AgentApprovalPort, Actor, AgentStore, StagedAttachment, MessageAttachment, ModelCatalog, AgentClientConfig, ToolSpec, ToolPresentation, AgentHistoryWindow, AgentIntake, Persona, SkillContext, ToolRegistry, AgentRegistry, PromptContributor, SkillsConfig, SkillCatalogEntry, MessageFeedbackValue, MessageFeedback, ModelCatalogView, ToolCatalogEntry, MemoryConfig, MemoryDigestEntry, SkillProvider, AgentRunner, AgentRunInput, AgentRunStartOptions, HumanReply, ChatQueueState, TokenStreamSink, SinkWriter, SubscribeOptions, ActionProposalOutcome, ActionProposal } from '@dudousxd/nestjs-agent-core';
+import { ModelProvider, ModelCatalog, ModelTurnArgs, ModelTurnResult, DescribedModel, PriceCatalogEntry, ToolPresentation, ToolSpec, RolesPolicy, Actor, ActorResolver, AttachmentStagingStore, AgentApprovalPort, AgentStore, StagedAttachment, MessageAttachment, AgentClientConfig, ToolCanRequirement, AgentHistoryWindow, AgentIntake, Persona, SkillContext, ToolRegistry, AgentRegistry, PromptContributor, SkillsConfig, SkillCatalogEntry, MessageFeedbackValue, MessageFeedback, ModelCatalogView, ToolCatalogEntry, MemoryConfig, MemoryDigestEntry, SkillProvider, AgentRunner, AgentRunInput, AgentRunStartOptions, HumanReply, ChatQueueState, TokenStreamSink, SinkWriter, SubscribeOptions, ActionProposalOutcome, ActionProposal, PageContext, AgentCatalogEntry } from '@dudousxd/nestjs-agent-core';
 export * from '@dudousxd/nestjs-agent-core';
 export { FunctionalToolDefinition } from '@dudousxd/nestjs-agent-core';
+import { ModuleRef, DiscoveryService, MetadataScanner } from '@nestjs/core';
+import { AiModels, AiModuleOptions, AgentFunctionOptions } from '@nestjs/ai';
+import { ResilienceService } from '@nestjs/resilience';
+import { AuthorizationService } from '@nestjs/authorization';
 import { A2uiOptions } from '@dudousxd/nestjs-agent-core/a2ui';
 import { Request, Response } from 'express';
-import { A as AgentService, a as ActionProposalService } from './index-De98CGXa.js';
-export { b as A2uiAdapterOptions, c as A2uiRunHandler, d as AttachmentLimits, C as ChatParams, e as ChatSendMode, f as ChatSendResult, D as DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES, g as DEFAULT_MAX_ATTACHMENT_BYTES, F as ForkThreadParams, M as MAX_ATTACHMENTS_PER_MESSAGE, N as NO_USER_MESSAGE_CODE, Q as QueuedSend, T as ThreadDefaultAgentReader, h as ThreadModelReader, i as a2uiAdapter, j as attachmentLimits } from './index-De98CGXa.js';
+import { A as AgentService, a as ActionProposalService } from './index-CRCbsO6E.js';
+export { b as A2uiAdapterOptions, c as A2uiRunHandler, d as AttachmentLimits, C as ChatParams, e as ChatSendMode, f as ChatSendResult, D as DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES, g as DEFAULT_MAX_ATTACHMENT_BYTES, F as ForkThreadParams, M as MAX_ATTACHMENTS_PER_MESSAGE, N as NO_USER_MESSAGE_CODE, Q as QueuedSend, T as ThreadDefaultAgentReader, h as ThreadModelReader, i as a2uiAdapter, j as attachmentLimits } from './index-CRCbsO6E.js';
 import { AgentGenui } from './genui/index.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { DiscoveryService, MetadataScanner } from '@nestjs/core';
 import '@dudousxd/nestjs-agent-core/genui';
 
 declare class AgentModule {
@@ -19,6 +22,121 @@ declare class AgentModule {
     static forRootAsync(options: AgentModuleAsyncOptions): DynamicModule;
 }
 
+/**
+ * The agent's model when `AgentModule` is given none: `@nestjs/ai`'s `AiModule`, found wherever the
+ * application imports it (it need not be global, nor imported next to `AgentModule`). Resolved once
+ * every provider exists (`onModuleInit`); a turn, the picker and boot pricing all come after that.
+ */
+declare class NestAiModelsBinding implements ModelProvider, OnModuleInit {
+    #private;
+    private readonly options;
+    private readonly moduleRef;
+    constructor(options: AgentModuleOptions, moduleRef: ModuleRef);
+    /** Whether the agent's turns run on `AiModule`'s models (no `model` and no `engine` configured). */
+    get active(): boolean;
+    onModuleInit(): void;
+    /** The picker's catalog, read through to `AiModule`'s models once they are resolved. */
+    readonly catalog: ModelCatalog;
+    runTurn(args: ModelTurnArgs): Promise<ModelTurnResult>;
+    describeModels(): DescribedModel[];
+    /** `AiModule`'s `pricing`, as price rows boot pricing seeds. */
+    prices(): PriceCatalogEntry[];
+    private get provider();
+    private find;
+}
+
+/** What {@link nestAiModelProvider} reads off `@nestjs/ai`. */
+interface NestAiModelProviderOptions {
+    /** `AiModule`'s model registry: the names a turn picks from, and the `LanguageModel` behind each. */
+    models: AiModels;
+    /** `AiModule`'s options (`AI_MODULE_OPTIONS`): each model's settings, pricing and fallback, and `defaults`. */
+    options: AiModuleOptions;
+    /** Resolves a model's `resilience: 'preset'`. Required only when a model or `defaults` names one. */
+    resilience?: ResilienceService;
+    /** Names the agent's model calls in `onUsage` events. Default `'agent'`. */
+    label?: string;
+}
+/** A {@link ModelProvider} over `@nestjs/ai`'s models, with the picker's catalog and their prices. */
+interface NestAiModelProvider extends ModelProvider {
+    catalog: ModelCatalog;
+    /** Price rows for the models `AiModule` prices (`pricing`), in its unit — read as USD per 1M tokens. */
+    prices(): PriceCatalogEntry[];
+}
+/**
+ * The agent's models are `@nestjs/ai`'s: a turn picks one of `AiModule.forRoot({ models })` by name
+ * (the picker lists them all), and runs under what `AiModule` configures for it — its generation
+ * settings, its `retry` and `timeout` (or its `resilience` policy or preset), its `fallback` models,
+ * `onUsage`, and its `pricing` for cost.
+ *
+ * `@nestjs/ai`'s own calls offer the model only `@AgentFunction()` tools and run them themselves; the
+ * agent's tools are governed, journaled and approved by the agent loop instead. So the turn itself is
+ * one AI SDK call with the loop's tools offered and not run, put under the same policies `@nestjs/ai`
+ * puts its calls under, with the same semantics: the timeout is the time to the first frame, and once
+ * a frame has reached the reader nothing is retried and no other model takes over — the reader would
+ * see the answer twice.
+ */
+declare function nestAiModelProvider(config: NestAiModelProviderOptions): NestAiModelProvider;
+
+/**
+ * What the agent adds to `@nestjs/ai`'s `@AgentFunction()` options: everything `@AiTool` declares
+ * that `@nestjs/ai` has no word for.
+ */
+interface AgentFunctionGovernance {
+    /**
+     * `read` runs as the model asks; `action` waits for a person's approval (HITL), as an `action`
+     * `@AiTool` does. Default `read` — the same default as `@AiTool`.
+     */
+    kind?: 'read' | 'action';
+    /** Roles allowed to call it, gated by the `RolesPolicy`. Omit → the policy's `defaultRoles`. */
+    roles?: string[];
+    /** Whether the tool exists in this deployment at all. Omit → it does. */
+    enabled?: boolean | (() => boolean | Promise<boolean>);
+    /** How the approval card and the tool-call row present it. */
+    presentation?: ToolPresentation;
+    /** The turn ends once this tool has run. */
+    terminal?: boolean;
+    /** Explicit identity for pending-only replacement of an `action` (see `@AiTool`). */
+    replacementKey?: ToolSpec['replacementKey'];
+}
+/** `@nestjs/ai`'s `@AgentFunction()` options, and the agent's governance. */
+type GovernedAgentFunctionOptions = AgentFunctionOptions & AgentFunctionGovernance;
+/**
+ * `@nestjs/ai`'s `@AgentFunction()`, with the agent's governance: the method is an agent function
+ * (`@nestjs/ai`'s calls offer it, through its guards, interceptors and pipes), and the agent offers
+ * it too, governed — an `action` waits for a person's approval, `roles` gate who is offered it.
+ * Authorization is `@nestjs/authorization`'s `@Can()`, stacked on the method: the agent offers the
+ * tool only to an actor its abilities allow, and the guard checks the call.
+ *
+ * ```ts
+ * import { AgentFunction } from '@dudousxd/nestjs-agent';
+ *
+ * @AgentFunction({
+ *   name: 'refund',
+ *   description: 'Refund an order',
+ *   inputSchema: RefundInput,
+ *   kind: 'action',
+ *   roles: ['SUPPORT'],
+ * })
+ * refund(input: RefundInput, ctx: AgentFunctionContext) { … }
+ * ```
+ *
+ * A method with `@nestjs/ai`'s own `@AgentFunction()` is offered to the agent as well, as a `read`
+ * tool under the policy's default roles; this one is that, plus the governance. A method takes one
+ * of the two, not both.
+ */
+declare function AgentFunction(options?: GovernedAgentFunctionOptions): MethodDecorator;
+
+/** The user `@nestjs/authorization`'s policies receive for the turn's actor. */
+type AuthorizationUserOf = (actor: Actor) => unknown;
+/**
+ * The agent's gate, with `@nestjs/authorization` in it: a tool that requires abilities
+ * (`ToolSpec.can`) is offered to, and callable by, an actor every one of them allows
+ * (`AuthorizationService.can(policy, ability, user)`) — and, when it names `roles` too, an actor
+ * holding one of them. A tool that requires none is the inner policy's call alone. Without an
+ * `AuthorizationService` to ask, a tool that requires one reaches nobody: fail closed.
+ */
+declare function authorizationGate(inner: RolesPolicy, service: () => AuthorizationService | undefined, userOf: AuthorizationUserOf): RolesPolicy;
+
 interface AgUiAdapterOptions {
     /** Where the route mounts, under the agent's path. Default `'ag-ui'` → `POST <path>/ag-ui`. */
     path?: string;
@@ -243,12 +361,6 @@ interface AiToolOptions {
      * import time, and can't reach the container.
      */
     enabled?: boolean | (() => boolean | Promise<boolean>);
-    /**
-     * Authz ability checked by an ability-aware RolesPolicy (e.g. `AgentAuthzModule`'s
-     * `AuthzRolesPolicy` → `gate.forUser(actor).allows(ability)`). Ignored by the default
-     * role-based policy, which uses `roles`.
-     */
-    ability?: string;
     /**
      * How a chat surface talks about this tool without naming it — sentence templates over the
      * call's input, an icon key, the approval prompt's wording, and how its output reads. Never shown
@@ -281,6 +393,12 @@ declare function toolNameFromClass(className: string): string;
 /**
  * Marks a provider class as an AI tool. The class must implement `execute(input, ctx)`.
  * `AiToolDiscoveryService` registers every `@AiTool` provider into the `ToolRegistry` at boot.
+ *
+ * `execute()` is also a `@nestjs/ai` `@AgentFunction()` (when the input schema produces JSON Schema,
+ * as Zod 4's does): with `AiModule` imported, the agent's calls run through the guards, interceptors
+ * and pipes `execute()` and the class declare, and `@nestjs/ai`'s own calls can offer the tool —
+ * outside a turn, an `action` is refused (only a turn asks a person) and `roles` are checked
+ * against the call's `user`.
  * Only `description` and `input` are required:
  *
  * ```ts
@@ -355,14 +473,15 @@ interface AgentOptions {
      * orchestrator and worth backgrounding in another, and only the person wiring the edge knows
      * which side of that the user is sitting on.
      *
-     * `roles` / `ability` gate who may delegate along the edge (the delegate tool's own), e.g.
-     * `{ agent: Helper, roles: ['personal_agent'] }` to let a personal agent's turn delegate.
+     * `roles` / `can` gate who may delegate along the edge (the delegate tool's own), e.g.
+     * `{ agent: Helper, roles: ['personal_agent'] }` to let a personal agent's turn delegate, or
+     * `{ agent: Billing, can: [{ policy: BillingPolicy, ability: 'delegate' }] }`.
      */
     handoff?: (Type | {
         agent: Type;
         detached?: boolean;
         roles?: string[];
-        ability?: string;
+        can?: readonly ToolCanRequirement[];
     })[];
     /**
      * How much of the thread this agent's turns carry, overriding `AgentModule.forRoot({ history })`.
@@ -497,9 +616,17 @@ declare class AiToolDiscoveryService implements OnApplicationBootstrap {
     private readonly registry;
     private readonly agents;
     private readonly options;
+    private readonly moduleRef;
     private readonly logger;
-    constructor(discovery: DiscoveryService, registry: ToolRegistry, agents: AgentRegistry, options: AgentModuleOptions);
+    constructor(discovery: DiscoveryService, registry: ToolRegistry, agents: AgentRegistry, options: AgentModuleOptions, moduleRef: ModuleRef);
     onApplicationBootstrap(): void;
+    /**
+     * How the agent runs an `@AiTool`: through `AiTools.call` when its `execute()` is an agent
+     * function `AiModule` found (so its enhancers run), else by calling it.
+     */
+    private executorOf;
+    /** `@nestjs/ai`'s agent functions, wherever the application imports `AiModule`; none without it. */
+    private findAiTools;
     /**
      * Registers a functional tool's `{ spec, handler }`, skipping it if a tool of the same name is
      * already registered. Returns whether it was newly registered.
@@ -1043,4 +1170,177 @@ declare class ActionProposalWorkerService implements OnModuleInit, OnModuleDestr
     onModuleDestroy(): Promise<void>;
 }
 
-export { AGENT_CHAT_QUEUE, AGENT_METADATA, AGENT_SERVICE, AI_TOOL_METADATA, ATTACHMENT_PAGE_SIZE, type ActionProposalAdmittedListener, ActionProposalController, ActionProposalService, type ActionProposalSettledListener, ActionProposalWorkerService, type AgUiAdapterOptions, AgUiRunHandler, Agent, AgentApprovalPortAdapter, AgentDepsFactory, AgentDiscoveryService, AgentModule, AgentModuleAsyncOptions, AgentModuleOptions, type AgentOptions, AgentProtocolAdapter, AgentService, AgentSkillsOptions, AiTool, AiToolDiscoveryService, type AiToolOptions, type AnonymousActorOptions, AnonymousActorResolver, AttachmentsController, ChatQueueService, ConfigController, type DeclaredSkill, HeaderActorResolver, InProcessTokenStreamSink, InlineAgentRunner, MemoriesController, MessagesController, ModelsController, QueueController, type RequestUserMapper, type ResolvedAiToolOptions, RunNotActiveException, SKILL_METADATA, SYSTEM_PROMPT_CONTRIBUTOR_METADATA, SYSTEM_PROMPT_METADATA, Skill, type SkillBody, SkillDiscoveryService, type SkillOptions, SkillsController, SystemPrompt, SystemPromptContributor, type ThreadPersonaReader, ToolsController, agUiAdapter, declaredSkillProvider, defaultRequestUserMapper, readAgentMetadata, readAiToolMetadata, readSkillMetadata, requestUserActorResolver, resolveSkillsConfig, skillScope, threadPersona, toolNameFromClass };
+interface ChatBody {
+    uiCapabilities?: unknown;
+    message: string;
+    threadId?: string;
+    /** Name of the agent to run (orchestrator or a sub-agent). Defaults to the module's default. */
+    agent?: string;
+    /**
+     * One of the agent's personas (`@Agent({ personas })`) to answer as — pinned on the thread. 400
+     * `persona_not_found` when the agent declares none by that id.
+     */
+    persona?: string;
+    /**
+     * Files attached to this message (image/PDF), named by the `mediaId` `POST /agent/attachments`
+     * (or the host's own upload) returned. Any other field sent alongside it is ignored.
+     */
+    attachments?: unknown;
+    pageContext?: PageContext;
+    /** Re-run the last exchange on `threadId` instead of adding a new message. */
+    regenerate?: boolean;
+    /** Start a new thread transient (hidden from history until promoted). Ignored with `threadId`. */
+    transient?: boolean;
+    /** Run this turn on a catalog model (see `GET models`) instead of the thread's pinned one. */
+    model?: string;
+    /**
+     * What to do when the thread already has a turn running: `'auto'` (default) queues it, `'queue'`
+     * always queues it (behind anything already waiting), `'interrupt'` cancels the running turn and
+     * runs this next. See `ChatSendMode`.
+     */
+    mode?: unknown;
+    /** Shorthand for `mode: 'interrupt'`. */
+    interrupt?: boolean;
+}
+declare class ChatController {
+    private readonly agent;
+    private readonly actorResolver;
+    constructor(agent: AgentService, actorResolver: ActorResolver);
+    /**
+     * Start a turn and stream it — or, when the thread already has one running, queue the message and
+     * answer `202 { queued: true, messageId, position, queue, … }` (JSON, no stream): it runs when the
+     * turn ahead of it settles, and the stream of the run holding the thread announces it with a
+     * `queue` frame.
+     */
+    chat(req: Request, res: Response, body: ChatBody): Promise<void>;
+    /**
+     * Attach to a run's stream: every buffered frame, then live ones. `?after=<seq>` (or the SSE
+     * `Last-Event-ID` header a browser `EventSource` sends on its own) skips the frames a reconnecting
+     * client already has — see {@link pipe} for how frames are numbered.
+     */
+    stream(req: Request, runId: string, res: Response, after?: string): Promise<void>;
+    cancel(req: Request, runId: string): Promise<{
+        aborted: boolean;
+    }>;
+    /**
+     * Every `data:` frame carries an SSE `id:` — its 1-based sequence number within the run. The
+     * number is a pure function of the run's buffered stream (every sink replays a run from its first
+     * chunk, in write order), so the same frame gets the same number on the POST that started the run
+     * and on any later `GET …/stream`, whichever replica serves it. A reconnecting client passes the
+     * last one it saw as `?after=`; frames at or below it are read off the sink but not re-sent.
+     * `meta`, `done` and `error` carry no id: `meta` is re-sent on every attach, the terminals once.
+     *
+     * A reader that disconnects aborts `gone`, which the sink honours by ending the subscription even
+     * while the run is silent (parked on a person, or never writing again).
+     */
+    private pipe;
+}
+
+interface UpdateThreadBody {
+    title?: string;
+    /** `null` clears the thread's default agent. Omitted → left untouched. */
+    defaultAgent?: string | null;
+    /** `null` unpins the thread's model. Omitted → left untouched. Must be offered by the catalog. */
+    model?: string | null;
+    /** `null` clears the thread's persona. Omitted → left untouched. Must be one the agent declares. */
+    persona?: string | null;
+}
+declare class ThreadsController {
+    private readonly agent;
+    private readonly actorResolver;
+    constructor(agent: AgentService, actorResolver: ActorResolver);
+    list(req: Request): Promise<_dudousxd_nestjs_agent_core.ThreadSummary[]>;
+    detail(req: Request, id: string): Promise<_dudousxd_nestjs_agent_core.ThreadDetail | null>;
+    remove(req: Request, id: string): Promise<{
+        ok: boolean;
+    }>;
+    fork(req: Request, id: string, messageId: string): Promise<_dudousxd_nestjs_agent_core.ThreadSummary>;
+    /**
+     * Renames the thread and/or sets its default agent. `defaultAgent` is only present in the request
+     * body when the client actually sent the key (JSON has no `undefined`), so `'defaultAgent' in body`
+     * distinguishes "leave it alone" from "set it to null" (clear it) unambiguously.
+     */
+    update(req: Request, id: string, body: UpdateThreadBody): Promise<{
+        ok: boolean;
+    }>;
+    promote(req: Request, id: string): Promise<{
+        ok: boolean;
+    }>;
+    truncateFrom(req: Request, id: string, messageId: string): Promise<{
+        ok: boolean;
+    }>;
+}
+
+interface ApproveBody {
+    toolCallId: unknown;
+    /** Approve later calls of the same tool in the same thread without asking. */
+    remember?: unknown;
+    /** The surface the decision came through. Defaults to `'web'`. */
+    via?: unknown;
+}
+interface RejectBody {
+    toolCallId: unknown;
+    reason?: unknown;
+    via?: unknown;
+}
+interface AnswerBody {
+    toolCallId: unknown;
+    /**
+     * questionId → chosen option values. Omit a question (or the whole object) to take the pre-picked
+     * default the request was shown with — confirming is meant to be enough, so an empty body is a
+     * valid submission rather than an error.
+     */
+    answers?: unknown;
+    /** The surface the answer came through. Defaults to `'web'`. */
+    via?: unknown;
+}
+declare class ToolCallController {
+    private readonly agent;
+    private readonly actorResolver;
+    constructor(agent: AgentService, actorResolver: ActorResolver);
+    approve(req: Request, body: ApproveBody): Promise<{
+        ok: boolean;
+    }>;
+    reject(req: Request, body: RejectBody): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Settle a parked question set. Alongside `approve`/`reject` rather than under a surface of its
+     * own: an elicitation IS a parked tool call, gated by the same ownership check and delivered
+     * through the same signal.
+     */
+    answer(req: Request, body: AnswerBody): Promise<{
+        ok: boolean;
+    }>;
+    /** Decline to answer and let the agent proceed on the answers it pre-picked. */
+    skip(req: Request, body: {
+        toolCallId: unknown;
+        via?: unknown;
+    }): Promise<{
+        ok: boolean;
+    }>;
+}
+
+declare class QuotaController {
+    private readonly agent;
+    private readonly actorResolver;
+    constructor(agent: AgentService, actorResolver: ActorResolver);
+    /**
+     * The caller's budget across windows — `{ windows: [{ period, usedTokens, limitTokens?, usedUsd,
+     * limitUsd?, resetsAt? }], blocked?: { period, reason? } }` — from the bound `QuotaProvider`.
+     */
+    report(req: Request): Promise<_dudousxd_nestjs_agent_core.QuotaReport>;
+}
+
+/**
+ * Lists the registered `@Agent`s — and each one's personas — so a host can render an agent or
+ * persona picker instead of hardcoding one.
+ */
+declare class AgentsController {
+    private readonly agents;
+    private readonly depsFactory;
+    constructor(agents: AgentRegistry, depsFactory: AgentDepsFactory);
+    list(): AgentCatalogEntry[];
+}
+
+export { AGENT_CHAT_QUEUE, AGENT_METADATA, AGENT_SERVICE, AI_TOOL_METADATA, ATTACHMENT_PAGE_SIZE, type ActionProposalAdmittedListener, ActionProposalController, ActionProposalService, type ActionProposalSettledListener, ActionProposalWorkerService, type AgUiAdapterOptions, AgUiRunHandler, Agent, AgentApprovalPortAdapter, AgentDepsFactory, AgentDiscoveryService, AgentFunction, type AgentFunctionGovernance, AgentModule, AgentModuleAsyncOptions, AgentModuleOptions, type AgentOptions, AgentProtocolAdapter, AgentService, AgentSkillsOptions, AgentsController, AiTool, AiToolDiscoveryService, type AiToolOptions, type AnonymousActorOptions, AnonymousActorResolver, AttachmentsController, ChatController, ChatQueueService, ConfigController, type DeclaredSkill, type GovernedAgentFunctionOptions, HeaderActorResolver, InProcessTokenStreamSink, InlineAgentRunner, MemoriesController, MessagesController, ModelsController, type NestAiModelProvider, type NestAiModelProviderOptions, NestAiModelsBinding, QueueController, QuotaController, type RequestUserMapper, type ResolvedAiToolOptions, RunNotActiveException, SKILL_METADATA, SYSTEM_PROMPT_CONTRIBUTOR_METADATA, SYSTEM_PROMPT_METADATA, Skill, type SkillBody, SkillDiscoveryService, type SkillOptions, SkillsController, SystemPrompt, SystemPromptContributor, type ThreadPersonaReader, ThreadsController, ToolCallController, ToolsController, agUiAdapter, authorizationGate, declaredSkillProvider, defaultRequestUserMapper, nestAiModelProvider, readAgentMetadata, readAiToolMetadata, readSkillMetadata, requestUserActorResolver, resolveSkillsConfig, skillScope, threadPersona, toolNameFromClass };