@dudousxd/nestjs-agent-dashboard 0.5.0 → 0.7.0

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { ActorSpendRow, AgentGovernanceQueries, ActorDirectory, AgentPricingStore, GovernanceRange, ModelSpendRow, UsageTrendPoint, ThreadSpendRow, RunMetrics, RunAgentBreakdownRow, RunErrorBreakdownRow, RunTrendPoint, RecentRunRow, ToolCallActivityRow, ThreadActivityRow, CurrentModelPrice, ModelPriceInput } from '@dudousxd/nestjs-agent-core';
+import { ActorSpendRow, AgentGovernanceQueries, ActorDirectory, AgentPricingStore, AgentApprovalPort, GovernanceRange, ModelSpendRow, UsageTrendPoint, ThreadSpendRow, RunMetrics, RunAgentBreakdownRow, RunErrorBreakdownRow, RunTrendPoint, RecentRunRow, ToolCallActivityRow, PendingApprovalRow, ToolStatRow, ThreadActivityRow, CurrentModelPrice, ActorResolver, ModelPriceInput } from '@dudousxd/nestjs-agent-core';
 export { ActorDirectory } from '@dudousxd/nestjs-agent-core';
 import { Observable } from 'rxjs';
 import { DynamicModule, Type, CanActivate, StreamableFile } from '@nestjs/common';
@@ -49,7 +49,8 @@ declare class DashboardService {
     private readonly queries;
     private readonly actorDirectory?;
     private readonly pricingStore?;
-    constructor(queries: AgentGovernanceQueries, actorDirectory?: ActorDirectory | undefined, pricingStore?: AgentPricingStore | undefined);
+    private readonly approvalPort?;
+    constructor(queries: AgentGovernanceQueries, actorDirectory?: ActorDirectory | undefined, pricingStore?: AgentPricingStore | undefined, approvalPort?: AgentApprovalPort | undefined);
     /** Spend/usage overview for a day range: by-model + by-actor spend and the daily trend, in parallel. */
     spend(range: GovernanceRange): Promise<SpendOverview>;
     /** Top threads by cost for a day range (default 10, highest cost first). */
@@ -60,6 +61,19 @@ declare class DashboardService {
     recentRuns(limit: number): Promise<RecentRunRow[]>;
     /** Most recent tool calls (status/type/thread) for the Runs & tools activity feed. */
     recentToolCalls(limit: number): Promise<ToolCallActivityRow[]>;
+    /** Tool calls sitting `pending_approval`, oldest first, for the cross-thread approvals inbox. */
+    pendingApprovals(limit: number): Promise<PendingApprovalRow[]>;
+    /** Per-tool call/failure/rejection/latency rollup for a day range, for the Tools section. */
+    toolStats(range: GovernanceRange): Promise<ToolStatRow[]>;
+    /**
+     * Decide a pending HITL tool call from the console. Routes through the OPTIONAL
+     * {@link AGENT_APPROVAL_PORT} — bound by `@dudousxd/nestjs-agent` to the SAME signal path chat
+     * approvals use — so a 501 here (checked BEFORE body validation, same ordering as
+     * {@link upsertPrice}) means "no approval port bound", not "your body was invalid". `executedByRef`
+     * is an OPAQUE decider ref the caller resolved from the live request (see
+     * `AgentDashboardOptions.approvalActorRef`); omitted when the host didn't configure one.
+     */
+    decideApproval(toolCallId: string, body: unknown, executedByRef: string | undefined): Promise<void>;
     /** Most recent threads with rolled-up message/token counts. */
     recentThreads(limit: number): Promise<ThreadActivityRowWithLabel[]>;
     /**
@@ -92,7 +106,9 @@ declare class DashboardService {
  */
 declare class AgentApiController {
     private readonly dashboard;
-    constructor(dashboard: DashboardService);
+    private readonly approvalActorRef;
+    private readonly actorResolver?;
+    constructor(dashboard: DashboardService, approvalActorRef: ((req: unknown) => string | undefined) | undefined, actorResolver?: ActorResolver | undefined);
     /** `{ byModel, byActor, trend }` for a day range (defaults to the last 30 days). */
     spend(from?: string, to?: string): Promise<SpendOverview>;
     /** Top threads by cost (default 10, max 200) for a day range (defaults to the last 30 days). */
@@ -103,6 +119,24 @@ declare class AgentApiController {
     runs(limit?: string): Promise<RecentRunRow[]>;
     /** Most recent tool calls (default 50, max 200) for the activity feed. */
     toolCalls(limit?: string): Promise<ToolCallActivityRow[]>;
+    /** Tool calls sitting `pending_approval` (default 50, max 200), oldest first — the approvals inbox. */
+    approvals(limit?: string): Promise<PendingApprovalRow[]>;
+    /**
+     * Decide a pending HITL tool call. Body `{ approved: boolean; reason?: string }`. 501s (via
+     * `DashboardService.decideApproval`) when no `AGENT_APPROVAL_PORT` is bound. `executedByRef`
+     * comes from {@link deciderRef} run against the live request.
+     */
+    decideApproval(toolCallId: string, body: unknown, req: unknown): Promise<void>;
+    /**
+     * WHO decided, as an opaque ref: an explicit `approvalActorRef` override wins outright (no
+     * resolver fallback, even when it returns `undefined`); otherwise the AgentModule-configured
+     * actor resolver — the same identity seam chat requests use. A resolver that throws is an
+     * unauthenticated/unreadable request, not an error to surface: the decision itself was already
+     * authorized by the dashboard's guards, so the ref is simply omitted.
+     */
+    private deciderRef;
+    /** Per-tool call/failure/rejection/latency rollup for a day range (defaults to the last 30 days). */
+    tools(from?: string, to?: string): Promise<ToolStatRow[]>;
     /** Most recent threads (default 50, max 200) with rolled-up counts. */
     threads(limit?: string): Promise<ThreadActivityRowWithLabel[]>;
     /**
@@ -153,7 +187,13 @@ interface AgentDashboardMountPathsOptions {
  */
 declare function agentDashboardMountPaths(options?: AgentDashboardMountPathsOptions): string[];
 
-interface AgentDashboardOptions {
+/**
+ * `TReq` mirrors core's `ActorResolver<TReq>` convention: the transport request type
+ * {@link AgentDashboardOptions.approvalActorRef} receives. Defaults to `unknown` so untyped usage
+ * compiles unchanged; a host may narrow it (e.g. `forRoot<Request>({ approvalActorRef: ... })`)
+ * instead of writing its own `unknown`-narrowing type guard.
+ */
+interface AgentDashboardOptions<TReq = unknown> {
     /**
      * Where the SPA (UI) is served. Default `/ai-gateway`. This is a page route — keep it out of an
      * `/api` prefix so it reads as a UI, not an endpoint.
@@ -182,6 +222,18 @@ interface AgentDashboardOptions {
      * host's own auth module, e.g. `imports: [AuthModule]` alongside `guards: [JwtAuthGuard]`.
      */
     imports?: DynamicModule['imports'];
+    /**
+     * OVERRIDE for WHO is deciding a HITL approval — invoked on the incoming
+     * `POST <api>/approvals/:toolCallId` request to stamp `AgentApprovalPort`'s `opts.executedByRef`.
+     *
+     * DEFAULT (option omitted): the AgentModule-configured actor resolver (`AGENT_ACTOR_RESOLVER`) is
+     * consulted — the same identity seam chat requests use — and its actor id becomes the decider ref
+     * (a throwing resolver, i.e. an unauthenticated request, just omits the ref). Set this only when
+     * console auth differs from chat auth (e.g. the console sits behind a separate SSO whose principal
+     * the chat resolver can't read); returning `undefined` leaves `executedByRef` unset — the explicit
+     * override wins outright, with no resolver fallback.
+     */
+    approvalActorRef?: (req: TReq) => string | undefined;
 }
 /**
  * Holds the JSON API + SSE controller and its read service, mounted on its own path by `forRoot`.
@@ -192,9 +244,10 @@ interface AgentDashboardOptions {
  * the right `imports` to `forRoot`.
  */
 declare class AgentApiModule {
-    static register(options: {
+    static register<TReq = unknown>(options: {
         imports?: DynamicModule['imports'];
         guards?: Type<CanActivate>[];
+        approvalActorRef?: (req: TReq) => string | undefined;
     }): DynamicModule;
 }
 /**
@@ -205,11 +258,31 @@ declare class AgentApiModule {
  * (global), which must provide `AGENT_GOVERNANCE_QUERIES` (bound by a store adapter). Front the
  * routes with the first-class `guards` option (plus `imports` for the guards' own dependencies) —
  * see {@link AgentDashboardOptions.guards}.
+ *
+ * Inertia hosts: the console is a full-page app, not an Inertia page. An in-app `<Link>` visit to
+ * `basePath` (an XHR carrying `X-Inertia`) is bounced with the protocol's own external-redirect
+ * mechanism — `409 Conflict` + `X-Inertia-Location: <the visited URL>` — so the Inertia client
+ * performs a full `window.location` load and the console renders normally. In-app links to the
+ * console therefore just work; no host-side special-casing needed.
  */
 declare class AgentDashboardModule {
-    static forRoot(options?: AgentDashboardOptions): DynamicModule;
+    static forRoot<TReq = unknown>(options?: AgentDashboardOptions<TReq>): DynamicModule;
 }
 
+/**
+ * The slice of the express request the Inertia bounce below reads — structural, so the package
+ * needs no express dependency (the API controller similarly takes `@Req() req: unknown`).
+ */
+interface UiPageRequest {
+    headers: Record<string, string | string[] | undefined>;
+    /** Path + query as received (express `originalUrl`) — what the full-page visit must reload. */
+    originalUrl: string;
+}
+/** The slice of the express response the Inertia bounce writes (passthrough mode — Nest still sends). */
+interface UiPageResponse {
+    status(code: number): unknown;
+    setHeader(name: string, value: string): unknown;
+}
 /**
  * Serves the bundled AI-gateway console SPA at the configured base (+ hashed assets at
  * `<base>/assets`). The path comes from `RouterModule` (set by
@@ -220,7 +293,7 @@ declare class AgentUiController {
     private readonly apiBasePath;
     private readonly dir;
     constructor(basePath: string, apiBasePath: string);
-    index(): string;
+    index(req: UiPageRequest, res: UiPageResponse): string;
     asset(file: string): StreamableFile;
 }
 
@@ -260,9 +333,33 @@ declare const AGENT_ACTOR_DIRECTORY: unique symbol;
  * tab/endpoints 501 with a clear message when nothing is bound.
  */
 declare const AGENT_PRICING_STORE: unique symbol;
+/**
+ * Console-side HITL decisions (`AgentApprovalPort`), owned by `@dudousxd/nestjs-agent-core`.
+ * Re-declared here BY VALUE for the same reason as {@link AGENT_GOVERNANCE_QUERIES} above. Optional:
+ * bound by `@dudousxd/nestjs-agent` (which adapts it to the same signal path chat approvals use) —
+ * absent, `POST <api>/approvals/:toolCallId` 501s and the approvals inbox renders read-only.
+ */
+declare const AGENT_APPROVAL_PORT: unique symbol;
+/**
+ * The app's request-identity seam (`ActorResolver`), owned by `@dudousxd/nestjs-agent-core` and
+ * bound + exported by the (global) `AgentModule` from the host's `actorResolver` option. Re-declared
+ * here BY VALUE for the same reason as {@link AGENT_GOVERNANCE_QUERIES} above. Optional: the default
+ * decider attribution for `POST <api>/approvals/:toolCallId` — absent (or throwing, i.e.
+ * unauthenticated), `executedByRef` is simply omitted.
+ */
+declare const AGENT_ACTOR_RESOLVER: unique symbol;
 /** DI token carrying the UI mount base (e.g. `/ai-gateway`). */
 declare const DASHBOARD_BASE_PATH: unique symbol;
 /** DI token carrying the JSON API base the SPA fetches from (e.g. `/ai-gateway/api`). */
 declare const DASHBOARD_API_PATH: unique symbol;
+/**
+ * DI token carrying the host-provided {@link AgentDashboardOptions.approvalActorRef} extractor (or
+ * `undefined` when the host didn't set one — the controller then falls back to
+ * {@link AGENT_ACTOR_RESOLVER} for decider attribution). Threaded to `AgentApiModule` (where the API
+ * controller actually lives) same as the pattern above — `useValue` even when `undefined`, so
+ * injecting it needs no `@Optional()` (mirrors `AGENT_QUOTA_STORE`'s factory in
+ * `@dudousxd/nestjs-agent`).
+ */
+declare const DASHBOARD_APPROVAL_ACTOR_REF: unique symbol;
 
-export { AGENT_ACTOR_DIRECTORY, AGENT_GOVERNANCE_QUERIES, AGENT_PRICING_STORE, type ActorSpendRowWithLabel, AgentApiController, AgentApiModule, AgentDashboardModule, type AgentDashboardMountPathsOptions, type AgentDashboardOptions, AgentUiController, DASHBOARD_API_PATH, DASHBOARD_BASE_PATH, DashboardService, type LiveAgentEvent, type ReliabilityOverview, type SpendOverview, type ThreadActivityRowWithLabel, type ThreadSpendRowWithLabel, type WithActorLabel, agentDashboardMountPaths, parsePriceInput };
+export { AGENT_ACTOR_DIRECTORY, AGENT_ACTOR_RESOLVER, AGENT_APPROVAL_PORT, AGENT_GOVERNANCE_QUERIES, AGENT_PRICING_STORE, type ActorSpendRowWithLabel, AgentApiController, AgentApiModule, AgentDashboardModule, type AgentDashboardMountPathsOptions, type AgentDashboardOptions, AgentUiController, DASHBOARD_API_PATH, DASHBOARD_APPROVAL_ACTOR_REF, DASHBOARD_BASE_PATH, DashboardService, type LiveAgentEvent, type ReliabilityOverview, type SpendOverview, type ThreadActivityRowWithLabel, type ThreadSpendRowWithLabel, type WithActorLabel, agentDashboardMountPaths, parsePriceInput };

package/dist/server/index.js

@@ -2,7 +2,7 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/server/agent-api.controller.ts
-import { Body, Controller, Get, Post, Query, Sse } from "@nestjs/common";
+import { Body, Controller, Get, HttpCode, Inject as Inject2, Optional as Optional2, Param, Post, Query, Req, Sse } from "@nestjs/common";
 
 // src/server/dashboard.service.ts
 import { subscribe, unsubscribe } from "node:diagnostics_channel";
@@ -10,27 +10,49 @@ import { channelName } from "@dudousxd/nestjs-diagnostics";
 import { Inject, Injectable, NotImplementedException, Optional } from "@nestjs/common";
 import { Observable as Observable2 } from "rxjs";
 
-// src/server/parse-price-input.ts
+// src/server/parse-approval-decision.ts
 import { BadRequestException } from "@nestjs/common";
-function parsePriceInput(body) {
+function parseApprovalDecision(body) {
   if (typeof body !== "object" || body === null) {
     throw new BadRequestException("Expected a JSON object body.");
   }
+  const { approved, reason } = body;
+  if (typeof approved !== "boolean") {
+    throw new BadRequestException('"approved" must be a boolean.');
+  }
+  if (reason !== void 0 && typeof reason !== "string") {
+    throw new BadRequestException('"reason" must be a string when present.');
+  }
+  return {
+    approved,
+    ...reason !== void 0 ? {
+      reason
+    } : {}
+  };
+}
+__name(parseApprovalDecision, "parseApprovalDecision");
+
+// src/server/parse-price-input.ts
+import { BadRequestException as BadRequestException2 } from "@nestjs/common";
+function parsePriceInput(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new BadRequestException2("Expected a JSON object body.");
+  }
   const { modelId, inputPricePer1m, outputPricePer1m, cacheWritePricePer1m, cacheReadPricePer1m } = body;
   if (typeof modelId !== "string" || modelId.trim().length === 0) {
-    throw new BadRequestException('"modelId" must be a non-empty string.');
+    throw new BadRequestException2('"modelId" must be a non-empty string.');
   }
   if (!isFiniteNonNegative(inputPricePer1m)) {
-    throw new BadRequestException('"inputPricePer1m" must be a non-negative number.');
+    throw new BadRequestException2('"inputPricePer1m" must be a non-negative number.');
   }
   if (!isFiniteNonNegative(outputPricePer1m)) {
-    throw new BadRequestException('"outputPricePer1m" must be a non-negative number.');
+    throw new BadRequestException2('"outputPricePer1m" must be a non-negative number.');
   }
   if (cacheWritePricePer1m !== void 0 && !isFiniteNonNegative(cacheWritePricePer1m)) {
-    throw new BadRequestException('"cacheWritePricePer1m" must be a non-negative number when present.');
+    throw new BadRequestException2('"cacheWritePricePer1m" must be a non-negative number when present.');
   }
   if (cacheReadPricePer1m !== void 0 && !isFiniteNonNegative(cacheReadPricePer1m)) {
-    throw new BadRequestException('"cacheReadPricePer1m" must be a non-negative number when present.');
+    throw new BadRequestException2('"cacheReadPricePer1m" must be a non-negative number when present.');
   }
   return {
     modelId,
@@ -54,8 +76,11 @@ __name(isFiniteNonNegative, "isFiniteNonNegative");
 var AGENT_GOVERNANCE_QUERIES = Symbol.for("@dudousxd/nestjs-agent:governance-queries");
 var AGENT_ACTOR_DIRECTORY = Symbol.for("@dudousxd/nestjs-agent:actor-directory");
 var AGENT_PRICING_STORE = Symbol.for("@dudousxd/nestjs-agent:pricing-store");
+var AGENT_APPROVAL_PORT = Symbol.for("@dudousxd/nestjs-agent:approval-port");
+var AGENT_ACTOR_RESOLVER = Symbol.for("@dudousxd/nestjs-agent:actor-resolver");
 var DASHBOARD_BASE_PATH = Symbol.for("@dudousxd/nestjs-agent-dashboard:base-path");
 var DASHBOARD_API_PATH = Symbol.for("@dudousxd/nestjs-agent-dashboard:api-path");
+var DASHBOARD_APPROVAL_ACTOR_REF = Symbol.for("@dudousxd/nestjs-agent-dashboard:approval-actor-ref");
 
 // src/server/dashboard.service.ts
 function _ts_decorate(decorators, target, key, desc) {
@@ -76,6 +101,7 @@ function _ts_param(paramIndex, decorator) {
 }
 __name(_ts_param, "_ts_param");
 var PRICING_STORE_UNBOUND_MESSAGE = "Pricing CRUD is unavailable: no AGENT_PRICING_STORE is bound. Bind a pricing store (e.g. MikroOrmPricingStore from @dudousxd/nestjs-agent-store-mikro-orm) to enable it.";
+var APPROVAL_PORT_UNBOUND_MESSAGE = "Approve/reject is unavailable: no AGENT_APPROVAL_PORT is bound. Import AgentModule from @dudousxd/nestjs-agent alongside this dashboard to enable it \u2014 the approvals inbox stays read-only until then.";
 var AGENT_EVENTS = [
   "run.started",
   "message",
@@ -95,10 +121,12 @@ var DashboardService = class {
   queries;
   actorDirectory;
   pricingStore;
-  constructor(queries, actorDirectory, pricingStore) {
+  approvalPort;
+  constructor(queries, actorDirectory, pricingStore, approvalPort) {
     this.queries = queries;
     this.actorDirectory = actorDirectory;
     this.pricingStore = pricingStore;
+    this.approvalPort = approvalPort;
   }
   /** Spend/usage overview for a day range: by-model + by-actor spend and the daily trend, in parallel. */
   async spend(range) {
@@ -142,6 +170,41 @@ var DashboardService = class {
   recentToolCalls(limit) {
     return this.queries.recentToolCalls(limit);
   }
+  /** Tool calls sitting `pending_approval`, oldest first, for the cross-thread approvals inbox. */
+  pendingApprovals(limit) {
+    return this.queries.pendingApprovals(limit);
+  }
+  /** Per-tool call/failure/rejection/latency rollup for a day range, for the Tools section. */
+  toolStats(range) {
+    return this.queries.toolStats(range);
+  }
+  /**
+  * Decide a pending HITL tool call from the console. Routes through the OPTIONAL
+  * {@link AGENT_APPROVAL_PORT} — bound by `@dudousxd/nestjs-agent` to the SAME signal path chat
+  * approvals use — so a 501 here (checked BEFORE body validation, same ordering as
+  * {@link upsertPrice}) means "no approval port bound", not "your body was invalid". `executedByRef`
+  * is an OPAQUE decider ref the caller resolved from the live request (see
+  * `AgentDashboardOptions.approvalActorRef`); omitted when the host didn't configure one.
+  */
+  async decideApproval(toolCallId, body, executedByRef) {
+    if (this.approvalPort === void 0) {
+      throw new NotImplementedException(APPROVAL_PORT_UNBOUND_MESSAGE);
+    }
+    const decision = parseApprovalDecision(body);
+    const opts = executedByRef !== void 0 ? {
+      executedByRef
+    } : {};
+    if (decision.approved) {
+      await this.approvalPort.approve(toolCallId, opts);
+      return;
+    }
+    await this.approvalPort.reject(toolCallId, {
+      ...opts,
+      ...decision.reason !== void 0 ? {
+        reason: decision.reason
+      } : {}
+    });
+  }
   /** Most recent threads with rolled-up message/token counts. */
   async recentThreads(limit) {
     const rows = await this.queries.recentThreads(limit);
@@ -227,11 +290,14 @@ DashboardService = _ts_decorate([
   _ts_param(1, Inject(AGENT_ACTOR_DIRECTORY)),
   _ts_param(2, Optional()),
   _ts_param(2, Inject(AGENT_PRICING_STORE)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(AGENT_APPROVAL_PORT)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof AgentGovernanceQueries === "undefined" ? Object : AgentGovernanceQueries,
     typeof ActorDirectory === "undefined" ? Object : ActorDirectory,
-    typeof AgentPricingStore === "undefined" ? Object : AgentPricingStore
+    typeof AgentPricingStore === "undefined" ? Object : AgentPricingStore,
+    typeof AgentApprovalPort === "undefined" ? Object : AgentApprovalPort
   ])
 ], DashboardService);
 
@@ -281,8 +347,12 @@ var AgentApiController = class {
     __name(this, "AgentApiController");
   }
   dashboard;
-  constructor(dashboard) {
+  approvalActorRef;
+  actorResolver;
+  constructor(dashboard, approvalActorRef, actorResolver) {
     this.dashboard = dashboard;
+    this.approvalActorRef = approvalActorRef;
+    this.actorResolver = actorResolver;
   }
   /** `{ byModel, byActor, trend }` for a day range (defaults to the last 30 days). */
   spend(from, to) {
@@ -304,6 +374,42 @@ var AgentApiController = class {
   toolCalls(limit) {
     return this.dashboard.recentToolCalls(parseLimit(limit, 50));
   }
+  /** Tool calls sitting `pending_approval` (default 50, max 200), oldest first — the approvals inbox. */
+  approvals(limit) {
+    return this.dashboard.pendingApprovals(parseLimit(limit, 50));
+  }
+  /**
+  * Decide a pending HITL tool call. Body `{ approved: boolean; reason?: string }`. 501s (via
+  * `DashboardService.decideApproval`) when no `AGENT_APPROVAL_PORT` is bound. `executedByRef`
+  * comes from {@link deciderRef} run against the live request.
+  */
+  async decideApproval(toolCallId, body, req) {
+    await this.dashboard.decideApproval(toolCallId, body, await this.deciderRef(req));
+  }
+  /**
+  * WHO decided, as an opaque ref: an explicit `approvalActorRef` override wins outright (no
+  * resolver fallback, even when it returns `undefined`); otherwise the AgentModule-configured
+  * actor resolver — the same identity seam chat requests use. A resolver that throws is an
+  * unauthenticated/unreadable request, not an error to surface: the decision itself was already
+  * authorized by the dashboard's guards, so the ref is simply omitted.
+  */
+  async deciderRef(req) {
+    if (this.approvalActorRef !== void 0) {
+      return this.approvalActorRef(req);
+    }
+    if (this.actorResolver === void 0) {
+      return void 0;
+    }
+    try {
+      return (await this.actorResolver.resolve(req)).id;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Per-tool call/failure/rejection/latency rollup for a day range (defaults to the last 30 days). */
+  tools(from, to) {
+    return this.dashboard.toolStats(resolveRange(from, to));
+  }
   /** Most recent threads (default 50, max 200) with rolled-up counts. */
   threads(limit) {
     return this.dashboard.recentThreads(parseLimit(limit, 50));
@@ -381,6 +487,40 @@ _ts_decorate2([
   ]),
   _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
 ], AgentApiController.prototype, "toolCalls", null);
+_ts_decorate2([
+  Get("approvals"),
+  _ts_param2(0, Query("limit")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], AgentApiController.prototype, "approvals", null);
+_ts_decorate2([
+  Post("approvals/:toolCallId"),
+  HttpCode(204),
+  _ts_param2(0, Param("toolCallId")),
+  _ts_param2(1, Body()),
+  _ts_param2(2, Req()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    Object,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], AgentApiController.prototype, "decideApproval", null);
+_ts_decorate2([
+  Get("tools"),
+  _ts_param2(0, Query("from")),
+  _ts_param2(1, Query("to")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], AgentApiController.prototype, "tools", null);
 _ts_decorate2([
   Get("threads"),
   _ts_param2(0, Query("limit")),
@@ -413,9 +553,14 @@ _ts_decorate2([
 ], AgentApiController.prototype, "stream", null);
 AgentApiController = _ts_decorate2([
   Controller(),
+  _ts_param2(1, Inject2(DASHBOARD_APPROVAL_ACTOR_REF)),
+  _ts_param2(2, Optional2()),
+  _ts_param2(2, Inject2(AGENT_ACTOR_RESOLVER)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof DashboardService === "undefined" ? Object : DashboardService
+    typeof DashboardService === "undefined" ? Object : DashboardService,
+    Object,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], AgentApiController);
 
@@ -453,7 +598,7 @@ import { RouterModule } from "@nestjs/core";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, extname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Controller as Controller2, Get as Get2, Header, Inject as Inject2, NotFoundException, Param, StreamableFile } from "@nestjs/common";
+import { Controller as Controller2, Get as Get2, Header, Inject as Inject3, NotFoundException, Param as Param2, Req as Req2, Res, StreamableFile } from "@nestjs/common";
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -498,7 +643,12 @@ var AgentUiController = class {
   }
   // index.html references hash-named bundles, so it MUST NOT be cached (stale bundle = the classic
   // "stuck loading after a deploy"). The hashed assets below are immutable.
-  index() {
+  index(req, res) {
+    if (req.headers["x-inertia"] !== void 0) {
+      res.status(409);
+      res.setHeader("X-Inertia-Location", req.originalUrl);
+      return "";
+    }
     const indexPath = join(this.dir, "index.html");
     if (!existsSync(indexPath)) {
       throw new NotFoundException("Dashboard is not built. Run the package build.");
@@ -525,14 +675,21 @@ _ts_decorate3([
   Get2(),
   Header("Content-Type", "text/html; charset=utf-8"),
   Header("Cache-Control", "no-store, must-revalidate"),
+  _ts_param3(0, Req2()),
+  _ts_param3(1, Res({
+    passthrough: true
+  })),
   _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:paramtypes", [
+    typeof UiPageRequest === "undefined" ? Object : UiPageRequest,
+    typeof UiPageResponse === "undefined" ? Object : UiPageResponse
+  ]),
   _ts_metadata3("design:returntype", String)
 ], AgentUiController.prototype, "index", null);
 _ts_decorate3([
   Get2("assets/:file"),
   Header("Cache-Control", "public, max-age=31536000, immutable"),
-  _ts_param3(0, Param("file")),
+  _ts_param3(0, Param2("file")),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
     String
@@ -541,8 +698,8 @@ _ts_decorate3([
 ], AgentUiController.prototype, "asset", null);
 AgentUiController = _ts_decorate3([
   Controller2(),
-  _ts_param3(0, Inject2(DASHBOARD_BASE_PATH)),
-  _ts_param3(1, Inject2(DASHBOARD_API_PATH)),
+  _ts_param3(0, Inject3(DASHBOARD_BASE_PATH)),
+  _ts_param3(1, Inject3(DASHBOARD_API_PATH)),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
     String,
@@ -584,7 +741,13 @@ var AgentApiModule = class _AgentApiModule {
       ],
       providers: [
         DashboardService,
-        ...options.guards ?? []
+        ...options.guards ?? [],
+        // `useValue` even when `options.approvalActorRef` is `undefined` — AgentApiController
+        // injects this WITHOUT `@Optional()` (same pattern as `AGENT_QUOTA_STORE`'s factory).
+        {
+          provide: DASHBOARD_APPROVAL_ACTOR_REF,
+          useValue: options.approvalActorRef
+        }
       ],
       exports: [
         DashboardService
@@ -616,6 +779,9 @@ var AgentDashboardModule = class _AgentDashboardModule {
           } : {},
           ...options.guards ? {
             guards: options.guards
+          } : {},
+          ...options.approvalActorRef ? {
+            approvalActorRef: options.approvalActorRef
           } : {}
         }),
         RouterModule.register([
@@ -656,6 +822,8 @@ AgentDashboardModule = _ts_decorate4([
 ], AgentDashboardModule);
 export {
   AGENT_ACTOR_DIRECTORY,
+  AGENT_ACTOR_RESOLVER,
+  AGENT_APPROVAL_PORT,
   AGENT_GOVERNANCE_QUERIES,
   AGENT_PRICING_STORE,
   AgentApiController,
@@ -663,6 +831,7 @@ export {
   AgentDashboardModule,
   AgentUiController,
   DASHBOARD_API_PATH,
+  DASHBOARD_APPROVAL_ACTOR_REF,
   DASHBOARD_BASE_PATH,
   DashboardService,
   agentDashboardMountPaths,