create-windy 0.5.1 → 0.6.0

package/template/apps/server/src/agent/run-facade.ts

@@ -1,4 +1,3 @@
-import { randomUUIDv7 } from "bun";
 import type { ModuleManifest } from "@southwind-ai/modules";
 import {
   resolveProviderEgress,
@@ -9,7 +8,7 @@ import type {
   ModuleAiJsonValue,
 } from "@southwind-ai/server-sdk";
 import { evaluateAccessGuards } from "../access-guards.js";
-import { auditActor, type RequestGuardContext } from "../guards.js";
+import type { RequestGuardContext } from "../guards.js";
 import type { InitializedModuleHosts } from "../module-host.js";
 import { toModuleActor } from "../module-host.js";
 import type { createServerRuntime } from "../runtime.js";
@@ -22,7 +21,6 @@ import {
 import type {
   AgentRuntimePort,
   AgentRuntimeStartResponse,
-  AgentRuntimeStatusResponse,
 } from "./run-contracts.js";
 import { AgentRuntimeError } from "./run-contracts.js";
 import {
@@ -30,7 +28,19 @@ import {
   projectProviderInput,
   ProviderInputGovernanceError,
 } from "./provider-input-governance.js";
-import { rotateVisionArtifacts, validateOutputSchema } from "./vision-input.js";
+import {
+  rotateVisionArtifacts,
+  validateOutputSchema,
+  validateVisionArtifacts,
+} from "./vision-input.js";
+import { requireVisionOperationReadiness } from "./vision-readiness.js";
+import { auditAgentRun } from "./run-audit.js";
+import {
+  reserveScreenshotForRun,
+  type ScreenshotRunBinding,
+} from "./screenshot-run-binding.js";
+import type { ScreenshotIntakeRuntimeV2 } from "./screenshot-intake-v2.js";
+import { attachAgentRun } from "./run-attach.js";
 import {
   assertInputSize,
   digest,
@@ -40,10 +50,7 @@ import {
 import { AgentRunFacadeError, inaccessibleRun } from "./run-errors.js";
 import { scopedRuntimeIdempotencyKey } from "./idempotency-key.js";
 import { verifyCommittedRunInput } from "./run-input-verification.js";
-import {
-  assertSelectedDebugOperation,
-  debugActorAuditMetadata,
-} from "./run-debug-authorization.js";
+import { assertSelectedDebugOperation } from "./run-debug-authorization.js";
 import {
   buildRegisteredOperations,
   type RegisteredOperation,
@@ -54,6 +61,7 @@ type ServerRuntime = ReturnType<typeof createServerRuntime>;
 
 export class AgentRunFacade {
   readonly #operations: Map<string, RegisteredOperation>;
+  readonly #modules: readonly ModuleManifest[];
   constructor(
     modules: readonly ModuleManifest[],
     hosts: InitializedModuleHosts,
@@ -61,7 +69,9 @@ export class AgentRunFacade {
     private readonly remote: AgentRuntimePort,
     private readonly authorizations: AgentRunAuthorizationStore,
     private readonly artifacts?: AiArtifactRuntime,
+    private readonly screenshots?: ScreenshotIntakeRuntimeV2,
   ) {
+    this.#modules = modules;
     this.#operations = buildRegisteredOperations(modules, hosts);
   }
   async start(
@@ -71,6 +81,7 @@ export class AgentRunFacade {
     context: RequestGuardContext,
     artifacts: readonly ModuleAiArtifactRef[] = [],
     signal: AbortSignal = AbortSignal.timeout(10_000),
+    screenshotIntakeToken?: string,
   ): Promise<AgentRuntimeStartResponse> {
     assertSelectedDebugOperation(
       this.runtime,
@@ -161,6 +172,8 @@ export class AgentRunFacade {
       operationKey,
     }).slice(0, 32);
     let authorization: AgentExecutionAuthorization | undefined;
+    let screenshot: ScreenshotRunBinding | undefined;
+    let created: AgentRuntimeStartResponse | undefined;
     try {
       authorization = await this.authorizations.issue({
         operationKey,
@@ -175,14 +188,35 @@ export class AgentRunFacade {
         },
         context,
       });
-      const created = await this.remote.start(
+      const readinessPin = await requireVisionOperationReadiness({
+        definition: operation.definition,
+        moduleName: operation.moduleName,
+        modules: this.#modules,
+        context,
+        signal,
+        runtime: this.runtime,
+        remote: this.remote,
+      });
+      screenshot = await reserveScreenshotForRun(
+        this.screenshots,
+        screenshotIntakeToken,
+        operationKey,
+        readinessPin,
+        context,
+        signal,
+      );
+      const runtimeArtifacts = screenshot
+        ? [...rotatedArtifacts, screenshot.artifact]
+        : rotatedArtifacts;
+      validateVisionArtifacts(runtimeArtifacts, operation.definition);
+      created = await this.remote.start(
         {
           kind: "agent",
           operationKey,
           input: governedInput,
           inputModalities: operation.definition.inputModalities ?? ["text"],
           requiredCapabilities: operation.definition.requiredCapabilities,
-          artifacts: rotatedArtifacts,
+          artifacts: runtimeArtifacts,
           instructions: plan.instructions,
           userPrompt: plan.userPrompt,
           outputSchemaKey: operation.definition.outputSchemaKey,
@@ -197,6 +231,7 @@ export class AgentRunFacade {
             envelopeFields: [],
           },
           toolNetworkPolicy: resolveToolNetworkPolicy(operation.definition),
+          ...(readinessPin === undefined ? {} : { readinessPin }),
           executionGrant: authorization.token,
           release,
           traceId,
@@ -215,44 +250,25 @@ export class AgentRunFacade {
         ),
       );
       await this.authorizations.bind(authorization, created.runId);
-      this.runtime.auditSink.recordEvent({
-        id: randomUUIDv7(),
-        action: operation.definition.auditAction,
-        outcome: "success",
-        actor: auditActor(context),
-        target: {
-          type: "agent-run",
-          id: created.runId,
-          label: operationKey,
-        },
-        requestId: context.requestId,
-        metadata: {
-          ...debugActorAuditMetadata(context.actor),
-          artifactCount: rotatedArtifacts.length,
-          artifactBytes: rotatedArtifacts.reduce(
-            (total, artifact) => total + artifact.byteSize,
-            0,
-          ),
-          artifactSha256: rotatedArtifacts.map(({ sha256 }) => sha256),
-          requiredCapabilities: operation.definition.requiredCapabilities,
-          inputModalities: operation.definition.inputModalities ?? ["text"],
-          outputSchemaKey: operation.definition.outputSchemaKey,
-          releaseId: release.releaseId,
-          operationVersion: release.operationVersion,
-          workflowVersion: release.workflowVersion,
-          promptVersion: release.promptVersion,
-          routeVersion: release.routeVersion,
-          toolSchemaVersion: release.toolSchemaVersion,
-          traceId,
-        },
-        occurredAt: new Date().toISOString(),
+      await screenshot?.bind(created.runId);
+      auditAgentRun({
+        runtime: this.runtime,
+        context,
+        definition: operation.definition,
+        operationKey,
+        runId: created.runId,
+        release,
+        artifacts: runtimeArtifacts,
+        traceId,
       });
       return {
         ...created,
         eventsUrl: publicRunPath(created.runId, "events", operationKey),
       };
     } catch (error) {
+      if (created && screenshot) await this.remote.cancel(created.runId);
       if (authorization) await this.authorizations.discard(authorization);
+      if (screenshot) await screenshot.cancel();
       if (error instanceof AgentRuntimeError) {
         throw new AgentRunFacadeError(
           error.code,
@@ -319,32 +335,14 @@ export class AgentRunFacade {
     context: RequestGuardContext,
     signal?: AbortSignal,
   ) {
-    await this.authorizeRun(operationKey, runId, context);
-    let status: AgentRuntimeStatusResponse;
-    try {
-      status = await this.remote.status(runId, signal);
-    } catch (error) {
-      if (error instanceof AgentRuntimeError) {
-        if (error.code === "RUN_CONFLICT") throw inaccessibleRun();
-        throw new AgentRunFacadeError(
-          error.code,
-          error.message,
-          runtimeErrorStatus(error.code),
-        );
-      }
-      throw error;
-    }
-    if (status.runId !== runId) throw inaccessibleRun();
-    if (cursor > status.lastSequence) {
-      throw new AgentRunFacadeError(
-        "INVALID_INPUT",
-        "事件游标超出 Agent Run 当前序列",
-        400,
-      );
-    }
-    return {
-      ...status,
-      eventsUrl: publicRunPath(runId, "events", operationKey),
-    };
+    return attachAgentRun({
+      operationKey,
+      runId,
+      cursor,
+      context,
+      signal,
+      remote: this.remote,
+      authorize: () => this.authorizeRun(operationKey, runId, context),
+    });
   }
 }

package/template/apps/server/src/agent/run-route-input.ts

@@ -35,11 +35,18 @@ export function parseStartRequest(body: unknown): {
   operationKey: string;
   input: ModuleAiJsonValue;
   artifacts: readonly ModuleAiArtifactRef[];
+  screenshotIntakeToken?: string;
 } {
   if (
     !isRecord(body) ||
     Object.keys(body).some(
-      (key) => !["operationKey", "input", "artifacts"].includes(key),
+      (key) =>
+        ![
+          "operationKey",
+          "input",
+          "artifacts",
+          "screenshotIntakeToken",
+        ].includes(key),
     )
   ) {
     throw new AgentRunFacadeError("INVALID_INPUT", "请求格式无效", 400);
@@ -50,9 +57,27 @@ export function parseStartRequest(body: unknown): {
     operationKey,
     input: body.input,
     artifacts: parseArtifacts(body.artifacts),
+    ...(body.screenshotIntakeToken === undefined
+      ? {}
+      : {
+          screenshotIntakeToken: parseScreenshotToken(
+            body.screenshotIntakeToken,
+          ),
+        }),
   };
 }
 
+function parseScreenshotToken(value: unknown): string {
+  if (typeof value !== "string" || !/^[0-9a-f-]{36}$/i.test(value)) {
+    throw new AgentRunFacadeError(
+      "INVALID_INPUT",
+      "Screenshot Intake Token 无效",
+      400,
+    );
+  }
+  return value;
+}
+
 export function parseToolRequest(body: unknown) {
   const allowed = [
     "executionGrant",

package/template/apps/server/src/agent/run-routes.ts

@@ -51,6 +51,7 @@ export function registerAgentRunRoutes(
         context.guardContext,
         request.artifacts,
         context.request.signal,
+        request.screenshotIntakeToken,
       );
     } catch (error) {
       return facadeError(error);

package/template/apps/server/src/agent/runtime-bootstrap-report.test.ts

@@ -5,7 +5,7 @@ import { buildScopeContext } from "../data-access/context.js";
 import { createServerRuntime } from "../runtime.js";
 import { createSystemRepositories } from "../system/seed.js";
 import { FakeRouteApp } from "../system/route-test-app.js";
-import { registerAiRuntimeReporting } from "./runtime-bootstrap.js";
+import { registerAiRuntimeReporting } from "./runtime-reporting-bootstrap.js";
 import { registerUnavailableAiRoutes } from "./unavailable-routes.js";
 
 const originalFetch = globalThis.fetch;

package/template/apps/server/src/agent/runtime-bootstrap.ts

@@ -1,11 +1,5 @@
 import type { PlatformConfig } from "@southwind-ai/config";
 import type { ModuleManifest } from "@southwind-ai/modules";
-import type { FeatureFlagDefinition } from "@southwind-ai/shared";
-import { SystemAiRuntimeActorDirectory } from "../ai-runtime-report/actor-directory.js";
-import { RemoteAiRuntimeReportPort } from "../ai-runtime-report/remote-port.js";
-import { registerAiRuntimeReportRoutes } from "../ai-runtime-report/routes.js";
-import { AiRuntimeReportService } from "../ai-runtime-report/service.js";
-import { departmentDescendantResolver } from "../data-access/department-tree.js";
 import type { InitializedModuleHosts } from "../module-host.js";
 import type { createServerRuntime } from "../runtime.js";
 import type { RouteApp } from "../system/routes.js";
@@ -21,12 +15,22 @@ import {
   unavailableDocumentRuntime,
 } from "../document/remote-runtime.js";
 import { registerDocumentRunRoutes } from "../document/routes.js";
+import { createDocumentOutputRuntime } from "../document/output-artifact-composition.js";
+import { installDocumentOutputRuntimeRoutes } from "../document/output-artifact-route-composition.js";
+import { createModuleAiOperationReadinessPort } from "../ai-runtime-readiness/operation-port.js";
+import { AiRuntimeReadinessTrustStoreV1 } from "../ai-runtime-readiness/trust-store.js";
 import { EmbeddingFacade } from "../embedding/facade.js";
+import { EmbeddingRunAuthorizations } from "../embedding/run-authorization.js";
+import { InMemoryEmbeddingRunBindingRepository } from "../embedding/run-binding-repository.js";
+import { DrizzleEmbeddingRunBindingRepository } from "../embedding/drizzle-run-binding-repository.js";
 import {
   RemoteEmbeddingRuntime,
   unavailableEmbeddingRuntime,
 } from "../embedding/remote-runtime.js";
-import { registerEmbeddingRoutes } from "../embedding/routes.js";
+import {
+  registerEmbeddingRoutes,
+  registerEmbeddingRunArtifactRoutes,
+} from "../embedding/routes.js";
 import { SpeechRunFacade } from "../speech/facade.js";
 import {
   RemoteSpeechRuntime,
@@ -60,6 +64,13 @@ import { registerUnavailableAiRoutes } from "./unavailable-routes.js";
 import { DebugSessionFacadeV1 } from "./debug-session-facade.js";
 import { DebugSessionIdCodecV1 } from "./debug-session-id.js";
 import { registerDebugSessionRoutesV1 } from "./debug-session-routes.js";
+import { createAiRuntimeReadinessSources } from "./runtime-readiness-sources.js";
+import { registerAiRuntimeReporting } from "./runtime-reporting-bootstrap.js";
+import { registerScreenshotIntakeRoutes } from "./screenshot-intake-routes.js";
+import { createScreenshotIntakeRuntimeV2 } from "./screenshot-intake-bootstrap.js";
+import type { ScreenshotPageRegistryV2 } from "./persistent-screenshot-intake-producer.js";
+import { requiredEnvironment } from "./required-environment.js";
+export { registerAiRuntimeReporting } from "./runtime-reporting-bootstrap.js";
 
 export function registerAgentPlatformRuntime(input: {
   app: RouteApp;
@@ -72,6 +83,7 @@ export function registerAgentPlatformRuntime(input: {
   workflow: WorkflowService;
   db?: NodePgDatabase;
   backgroundAi: DeferredAgentBackgroundOperationPortFactory;
+  screenshotPageRegistry?: ScreenshotPageRegistryV2;
 }) {
   const features = input.modules.flatMap(({ features }) => features);
   const resolveAgentActor = async (actorId: string) =>
@@ -110,6 +122,8 @@ export function registerAgentPlatformRuntime(input: {
       toolHandlers,
       aiArtifacts: undefined,
       aiOperations: undefined,
+      aiReadiness: undefined,
+      disposeAgentRuntime: undefined,
     };
   }
   const aiRouteApp = createManifestAuthorizedRouteApp(
@@ -148,6 +162,14 @@ export function registerAgentPlatformRuntime(input: {
     internalToken,
     toolHostUrl: process.env.AGENT_TOOL_HOST_URL || "http://server:9747",
   });
+  const screenshotIntake = createScreenshotIntakeRuntimeV2({
+    modules: input.modules,
+    runtime: input.runtime,
+    artifacts: aiArtifacts,
+    storage: input.storage,
+    db: input.db,
+    registry: input.screenshotPageRegistry,
+  });
   registerAiRuntimeReporting({
     app: aiRouteApp,
     features,
@@ -169,21 +191,55 @@ export function registerAgentPlatformRuntime(input: {
         internalToken,
       })
     : unavailableDocumentRuntime;
-  const documentFacade = new DocumentRunFacade(
+  const speechRemote = process.env.SPEECH_SERVER_URL?.trim()
+    ? new RemoteSpeechRuntime({
+        baseUrl: process.env.SPEECH_SERVER_URL,
+        internalToken,
+      })
+    : unavailableSpeechRuntime;
+  const embeddingRemote = process.env.EMBEDDING_SERVER_URL?.trim()
+    ? new RemoteEmbeddingRuntime({
+        baseUrl: process.env.EMBEDDING_SERVER_URL,
+        internalToken,
+      })
+    : unavailableEmbeddingRuntime;
+  const readinessSources = createAiRuntimeReadinessSources({
+    agent: remote,
+    document: documentRemote,
+    speech: speechRemote,
+    embedding: embeddingRemote,
+  });
+  const readinessTrustStore = new AiRuntimeReadinessTrustStoreV1();
+  const aiReadiness = createModuleAiOperationReadinessPort({
+    modules: input.modules,
+    sources: readinessSources,
+    trustStore: readinessTrustStore,
+    runtime: input.runtime,
+  });
+  const outputRuntime = createDocumentOutputRuntime({
+    modules: input.modules,
+    readiness: aiReadiness,
+    runtime: input.runtime,
+    storage: input.storage,
+    resolveActor: resolveAgentActor,
+    db: input.db,
+  });
+  const documentFacadeWithOutput = new DocumentRunFacade(
     input.modules,
     input.hosts,
     input.runtime,
     documentRemote,
     aiArtifacts,
     grants,
+    outputRuntime?.host,
+    aiReadiness,
+  );
+  installDocumentOutputRuntimeRoutes(outputRuntime, aiRouteApp, internalToken);
+  registerDocumentRunRoutes(
+    aiRouteApp,
+    documentFacadeWithOutput,
+    documentRemote,
   );
-  registerDocumentRunRoutes(aiRouteApp, documentFacade, documentRemote);
-  const speechRemote = process.env.SPEECH_SERVER_URL?.trim()
-    ? new RemoteSpeechRuntime({
-        baseUrl: process.env.SPEECH_SERVER_URL,
-        internalToken,
-      })
-    : unavailableSpeechRuntime;
   const speechFacade = new SpeechRunFacade(
     input.modules,
     input.hosts,
@@ -191,22 +247,29 @@ export function registerAgentPlatformRuntime(input: {
     speechRemote,
     aiArtifacts,
     grants,
+    aiReadiness,
+    outputRuntime?.speechHost,
   );
   registerSpeechRunRoutes(aiRouteApp, speechFacade, speechRemote);
-  const embeddingRemote = process.env.EMBEDDING_SERVER_URL?.trim()
-    ? new RemoteEmbeddingRuntime({
-        baseUrl: process.env.EMBEDDING_SERVER_URL,
-        internalToken,
-      })
-    : unavailableEmbeddingRuntime;
   const embeddingFacade = new EmbeddingFacade(
     input.modules,
     input.hosts,
     input.runtime,
     embeddingRemote,
     aiArtifacts,
+    new EmbeddingRunAuthorizations(
+      input.db
+        ? new DrizzleEmbeddingRunBindingRepository(input.db)
+        : new InMemoryEmbeddingRunBindingRepository(),
+      internalToken,
+    ),
   );
   registerEmbeddingRoutes(aiRouteApp, embeddingFacade);
+  registerEmbeddingRunArtifactRoutes(
+    aiRouteApp,
+    embeddingFacade,
+    internalToken,
+  );
   const agentFacade = new AgentRunFacade(
     input.modules,
     input.hosts,
@@ -214,7 +277,9 @@ export function registerAgentPlatformRuntime(input: {
     remote,
     runAuthorizations,
     aiArtifacts,
+    screenshotIntake,
   );
+  registerScreenshotIntakeRoutes(aiRouteApp, screenshotIntake);
   registerAgentRunRoutes(
     aiRouteApp,
     agentFacade,
@@ -246,48 +311,33 @@ export function registerAgentPlatformRuntime(input: {
     createModuleAiOperationPort(moduleName, guardContext, signal, {
       agentFacade,
       agentRemote: remote,
-      documentFacade,
+      documentFacade: documentFacadeWithOutput,
       documentRemote,
       speechFacade,
       speechRemote,
       embeddingFacade,
     });
-  return { toolHandlers, aiArtifacts, aiOperations };
-}
-
-export function registerAiRuntimeReporting(input: {
-  app: RouteApp;
-  features: FeatureFlagDefinition[];
-  runtime: ReturnType<typeof createServerRuntime>;
-  systemRepositories: SystemRepositories;
-  agentServerUrl: string;
-  internalToken: string;
-}): void {
-  registerAiRuntimeReportRoutes(
-    input.app,
-    new AiRuntimeReportService(
-      new RemoteAiRuntimeReportPort({
-        baseUrl: input.agentServerUrl,
-        internalToken: input.internalToken,
-      }),
-      new SystemAiRuntimeActorDirectory(
-        input.systemRepositories,
-        input.internalToken,
-      ),
-      {
-        descendants: departmentDescendantResolver(
-          input.systemRepositories.departments,
-        ),
-      },
-      input.runtime,
-    ),
-    input.runtime,
-    input.features,
-  );
-}
-
-function requiredEnvironment(key: string): string {
-  const value = process.env[key]?.trim();
-  if (!value) throw new Error(`启用 AI Runtime 时缺少 ${key}`);
-  return value;
+  const aiReadinessForModule = (
+    moduleName: string,
+    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
+    signal: AbortSignal,
+  ) =>
+    createModuleAiOperationReadinessPort({
+      moduleName,
+      guardContext,
+      signal,
+      modules: input.modules,
+      sources: readinessSources,
+      trustStore: readinessTrustStore,
+      runtime: input.runtime,
+    });
+  return {
+    toolHandlers,
+    aiArtifacts,
+    aiOperations,
+    aiReadiness: aiReadinessForModule,
+    disposeAgentRuntime: screenshotIntake
+      ? () => screenshotIntake.dispose()
+      : undefined,
+  };
 }

package/template/apps/server/src/agent/runtime-readiness-sources.test.ts

@@ -0,0 +1,27 @@
+import { expect, test } from "bun:test";
+import { createAiRuntimeReadinessSources } from "./runtime-readiness-sources.js";
+
+test("Agent Composition 为 module readiness 同时装配 Speech source", async () => {
+  const calls: string[] = [];
+  const source = (name: string) => ({
+    async health() {
+      calls.push(name);
+      return Response.json({ name });
+    },
+  });
+  const sources = createAiRuntimeReadinessSources({
+    agent: source("agent"),
+    document: source("document"),
+    speech: source("speech"),
+    embedding: source("embedding"),
+  });
+
+  expect(sources.map(({ kind }) => kind)).toEqual([
+    "agent",
+    "document",
+    "speech",
+    "embedding",
+  ]);
+  await Promise.all(sources.map(({ health }) => health()));
+  expect(calls.sort()).toEqual(["agent", "document", "embedding", "speech"]);
+});

package/template/apps/server/src/agent/runtime-readiness-sources.ts

@@ -0,0 +1,31 @@
+import type { AiRuntimeReadinessSourceV1 } from "../ai-runtime-readiness/operation-port.js";
+
+interface HealthPort {
+  health(signal?: AbortSignal): Promise<Response>;
+}
+
+export function createAiRuntimeReadinessSources(input: {
+  agent: HealthPort;
+  document: HealthPort;
+  speech: HealthPort;
+  embedding: HealthPort;
+}): readonly AiRuntimeReadinessSourceV1[] {
+  return [
+    {
+      kind: "agent",
+      health: (signal) => input.agent.health(signal),
+    },
+    {
+      kind: "document",
+      health: (signal) => input.document.health(signal),
+    },
+    {
+      kind: "speech",
+      health: (signal) => input.speech.health(signal),
+    },
+    {
+      kind: "embedding",
+      health: (signal) => input.embedding.health(signal),
+    },
+  ];
+}

package/template/apps/server/src/agent/runtime-reporting-bootstrap.ts

@@ -0,0 +1,40 @@
+import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+import { SystemAiRuntimeActorDirectory } from "../ai-runtime-report/actor-directory.js";
+import { RemoteAiRuntimeReportPort } from "../ai-runtime-report/remote-port.js";
+import { registerAiRuntimeReportRoutes } from "../ai-runtime-report/routes.js";
+import { AiRuntimeReportService } from "../ai-runtime-report/service.js";
+import { departmentDescendantResolver } from "../data-access/department-tree.js";
+import type { createServerRuntime } from "../runtime.js";
+import type { RouteApp } from "../system/routes.js";
+import type { SystemRepositories } from "../system/seed.js";
+
+export function registerAiRuntimeReporting(input: {
+  app: RouteApp;
+  features: FeatureFlagDefinition[];
+  runtime: ReturnType<typeof createServerRuntime>;
+  systemRepositories: SystemRepositories;
+  agentServerUrl: string;
+  internalToken: string;
+}): void {
+  registerAiRuntimeReportRoutes(
+    input.app,
+    new AiRuntimeReportService(
+      new RemoteAiRuntimeReportPort({
+        baseUrl: input.agentServerUrl,
+        internalToken: input.internalToken,
+      }),
+      new SystemAiRuntimeActorDirectory(
+        input.systemRepositories,
+        input.internalToken,
+      ),
+      {
+        descendants: departmentDescendantResolver(
+          input.systemRepositories.departments,
+        ),
+      },
+      input.runtime,
+    ),
+    input.runtime,
+    input.features,
+  );
+}