@spine-event-engine/server 2.0.0-snapshot.22 → 2.0.0-snapshot.23

package/dist/context/bounded-context.js

@@ -16,17 +16,21 @@ import { access, realpath } from "node:fs/promises";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { clone, create, getOption, hasOption } from "@bufbuild/protobuf";
+import { freezeRegistry, isAiModel, registryOptions } from "@spine-event-engine/ai/spi/runtime";
 import { TypeUrls } from "@spine-event-engine/core";
 import { EventSchema, EventContextSchema, BoundedContextNameSchema, TenantIdSchema, } from "@spine-event-engine/proto";
 import { SPI_type, internal_all, internal_type } from "@spine-event-engine/proto";
 import { ColumnTypes, EventStore, InMemoryStorageFactory, RecordColumn, } from "@spine-event-engine/storage";
-import { TenantBoundary } from "@spine-event-engine/storage/provider";
+import { AgentExecutionStorageFactories, AgentHistoryStorageFactories, TenantBoundary, } from "@spine-event-engine/storage/provider";
 import { CommandBus, commandBusAccess } from "../bus/command-bus.js";
-import { EventBus, eventBusAccess, } from "../bus/event-bus.js";
+import { EventBus, eventBusAccess, isSystemEventSchema, } from "../bus/event-bus.js";
 import { DeliveryReadiness, } from "./local-inbox-handoff.js";
 import { LocalEntityInbox } from "./entity-inbox.js";
 import { LocalProjectionInbox } from "./projection-handoff.js";
 import { TenantIndexes } from "./tenant-index.js";
+import { EffectiveTenants } from "./effective-tenant.js";
+import { AgentScheduler } from "../agent/agent-scheduler.js";
+import { AgentExecutionCapacity } from "../agent/agent-execution-capacity.js";
 import { Repository, repositoryAccess, } from "../repository/repository.js";
 import { GeneratedRegistryDiscovery } from "../handler/generated-registry-discovery.js";
 import { HandlerRegistryIngestor, } from "../handler/generated-handler-registry.js";
@@ -81,6 +85,8 @@ const contextSubscriptionRuntimes = new WeakMap();
 const contextLoggers = new WeakMap();
 const contextSignalPublishers = new WeakMap();
 const contextEventBuses = new WeakMap();
+const contextRepositoryViews = new WeakMap();
+const issuedRepositoryViews = new WeakMap();
 const closingContexts = new WeakSet();
 const contextClosePhases = new WeakMap();
 const contextIntegrations = new WeakMap();
@@ -106,9 +112,12 @@ export class BoundedContext {
     #registeredRepositories = [];
     #repositoryViews = new Set();
     #storageFactory;
+    #ai;
     #stand;
     #systemStand;
     #subscriptionRuntime;
+    #agentScheduler;
+    #agentErrors = [];
     #closed;
     /**
      * Registers the framework-only construction hook for this module.
@@ -132,6 +141,7 @@ export class BoundedContext {
         this.#systemStand = input.systemStand;
         this.#subscriptionRuntime = input.subscriptionRuntime;
         this.#storageFactory = input.storageFactory;
+        this.#ai = input.ai;
         this.#deliveryStrategy = ContextParts.snapshotDeliveryStrategy(input.deliveryStrategy);
         this.#commandEndpoint = Object.freeze({
             acceptedCommandTypes: () => this.#commandBus.acceptedCommandTypes(),
@@ -146,8 +156,56 @@ export class BoundedContext {
         this.#projectionInbox = delivery.projectionInbox;
         this.#installReferences(input, delivery);
         this.#registerAndStart(input.repositories, delivery.tenantIndex);
+        this.#startAgentScheduler(delivery.tenantIndex);
         Object.freeze(this);
     }
+    /**
+     * Starts bounded indexed discovery for registered Agent repositories.
+     */
+    #startAgentScheduler(tenantIndex) {
+        if (this.#ai === undefined)
+            return;
+        const repositories = [...this.#repositoryViews].filter((entry) => entry.entityFamily === "agent");
+        if (repositories.length === 0)
+            return;
+        this.#agentScheduler = new AgentScheduler({
+            repositories: repositories.length,
+            page: (after, signal) => tenantIndex.page({
+                count: 16,
+                signal,
+                ...(after === undefined ? {} : { after }),
+            }),
+            scope: (id, index) => {
+                const repository = repositories[index];
+                if (repository === undefined)
+                    throw new Error("Agent repository scope is unavailable.");
+                return this.#agentScope(repository, tenantIndex.tenantMode === "single-tenant" ? undefined : id);
+            },
+        }, AgentExecutionCapacity.for(this.#ai), (error) => {
+            if (this.#agentErrors.length < 32)
+                this.#agentErrors.push(error);
+        });
+        this.#agentScheduler.start();
+    }
+    /**
+     * Builds one scan scope from an accepted handoff or a catalog sweep.
+     *
+     * @param repository Registered Agent repository.
+     * @param tenantId Accepted tenant, absent only in a single-tenant Bounded Context.
+     * @returns The matching indexed provider scan scope.
+     */
+    #agentScope(repository, tenantId) {
+        const effective = EffectiveTenants.current(this.#snapshot.tenantMode === "multitenant", tenantId);
+        return {
+            id: JSON.stringify([
+                this.#snapshot.name.value,
+                String(TenantBoundary.from(effective).key),
+                repository.stateFullTypeName,
+            ]),
+            pending: (after, count) => repositoryAccess.pendingAcceptedAgents(repository, tenantId, after, count),
+            run: (key, signal) => repositoryAccess.runAcceptedAgent(repository, tenantId, key, signal),
+        };
+    }
     /**
      * Creates tenant-aware Inboxes and their shared readiness signal.
      *
@@ -174,6 +232,7 @@ export class BoundedContext {
      */
     #installReferences(input, delivery) {
         contextEventBuses.set(this, [this.#eventBus, this.#systemEventBus]);
+        contextRepositoryViews.set(this, this.#repositoryViews);
         eventSubscribers.set(this, (typeUrl, subscriber) => eventBusAccess.subscribe(this.#eventBus, typeUrl, subscriber));
         systemEventPosters.set(this, (event) => this.#publisher.publishSystemEvent(event));
         contextSystemPairings.set(this, ContextParts.createSystemPairing(this.#snapshot, input.systemSpec));
@@ -236,10 +295,27 @@ export class BoundedContext {
         }
     }
     #prepareRepositories(repositories) {
+        const registration = this.#repositoryRegistration();
+        const preparedRepositories = [];
+        try {
+            for (const repository of repositories) {
+                preparedRepositories.push(ContextParts.prepareRepositoryForContext(repository, registration));
+            }
+        }
+        catch (error) {
+            this.#failRegistration(error, preparedRepositories);
+        }
+        return preparedRepositories;
+    }
+    /**
+     * Builds callbacks shared by every repository prepared for this Bounded Context.
+     */
+    #repositoryRegistration() {
         const registration = {
             name: ContextParts.cloneName(this.#snapshot.name),
             storageContext: ContextParts.createStorageMode(this.#snapshot.spec),
             storageFactory: this.#storageFactory,
+            ...(this.#ai === undefined ? {} : { ai: this.#ai }),
             stand: this.#stand,
             entityInbox: this.#entityInbox,
             projectionInbox: this.#projectionInbox,
@@ -250,17 +326,19 @@ export class BoundedContext {
             registerSystemEventSchema: (schema) => {
                 eventBusAccess.registerSchemas(this.#systemEventBus, [schema]);
             },
+            prepareSavedEvent: (event) => eventBusAccess.prepareSaved(this.#eventBus, event),
+            prepareSavedCommand: (command) => commandBusAccess.prepareSaved(this.#commandBus, command),
+            publishSavedEvent: (event, plan) => eventBusAccess.postSavedFollowUp(this.#eventBus, event, plan),
+            publishSavedCommand: (command, plan) => commandBusAccess.postSavedFollowUp(this.#commandBus, command, plan),
+            publishAgentSystemEvent: (event) => eventBusAccess.postFollowUp(this.#systemEventBus, event),
+            recordAcceptedSaved: (signal) => {
+                this.#publisher.recordAcceptedSaved(signal);
+            },
+            wakeAcceptedAgent: (repository, tenantId) => {
+                this.#agentScheduler?.wake(this.#agentScope(repository, tenantId));
+            },
         };
-        const preparedRepositories = [];
-        try {
-            for (const repository of repositories) {
-                preparedRepositories.push(ContextParts.prepareRepositoryForContext(repository, registration));
-            }
-        }
-        catch (error) {
-            this.#failRegistration(error, preparedRepositories);
-        }
-        return preparedRepositories;
+        return registration;
     }
     #failRegistration(error, preparedRepositories) {
         const closeErrors = ContextParts.closePreparedRepositories(preparedRepositories);
@@ -357,7 +435,33 @@ export class BoundedContext {
      * @returns Returns immutable repository views.
      */
     registeredRepositories() {
-        return this.#registeredRepositories.map((snapshot) => ContextParts.createRepositoryView(snapshot));
+        const originals = [...this.#repositoryViews];
+        return this.#registeredRepositories.map((snapshot, index) => {
+            const repository = originals[index];
+            if (repository === undefined)
+                throw new Error("Registered repository view disappeared.");
+            const view = ContextParts.createRepositoryView(snapshot);
+            issuedRepositoryViews.set(view, { context: this, repository });
+            return view;
+        });
+    }
+    /**
+     * Returns the repository already registered for an exact Entity constructor.
+     * This trusted server-side lookup does not load Entity state or open storage.
+     *
+     * @typeParam EntityType Concrete Entity constructor registered in this Bounded Context.
+     * @param entityType Exact Entity class supplied to this Bounded Context's builder.
+     * @returns The existing typed repository for that Entity class.
+     * @throws When the constructor is absent or the Bounded Context is closing.
+     */
+    getRepository(entityType) {
+        if (closingContexts.has(this))
+            throw new Error("Bounded Context is closing.");
+        for (const repository of this.#repositoryViews) {
+            if (repository.entityType === entityType)
+                return repository;
+        }
+        throw new Error("Entity constructor is not registered in this Bounded Context.");
     }
     /**
      * Clears and locally replays every registered Projection from already-stored events.
@@ -435,6 +539,7 @@ export class BoundedContext {
      */
     #beginClose() {
         closingContexts.add(this);
+        this.#agentScheduler?.stop();
         this.#publisher.beginClose();
         commandBusAccess.beginClose(this.#commandBus);
         eventBusAccess.beginClose(this.#eventBus);
@@ -459,6 +564,7 @@ export class BoundedContext {
      */
     async #closeOnce() {
         const errors = [];
+        await ContextParts.closeContextPart(() => this.#agentScheduler?.close(), errors);
         await ContextParts.closeContextPart(() => this.#drainWork(), errors);
         this.#publisher.finishClose();
         await ContextParts.closeContextPart(() => commandBusAccess.finishClose(this.#commandBus), errors);
@@ -498,6 +604,22 @@ export class BoundedContext {
  * Exposes framework-only operations for built contexts and their builders.
  */
 export const boundedContextAccess = Object.freeze({
+    /**
+     * Resolves a view only within the Bounded Context that issued it.
+     *
+     * @param context Built Bounded Context that registered the repository.
+     * @param view Candidate original or issued view.
+     * @returns Registered repository, or undefined for a foreign view.
+     */
+    resolveRepository(context, view) {
+        const originals = contextRepositoryViews.get(context);
+        if (originals?.has(view))
+            return view;
+        const issued = issuedRepositoryViews.get(view);
+        return issued?.context === context && originals?.has(issued.repository)
+            ? issued.repository
+            : undefined;
+    },
     beginClose(context) {
         const phase = contextClosePhases.get(context);
         if (phase === undefined)
@@ -543,12 +665,12 @@ export const boundedContextAccess = Object.freeze({
             value !== null &&
             builderBuilds.has(value));
     },
-    build(builder, defaultStorageFactory) {
+    build(builder, defaultStorageFactory, defaultAi) {
         const build = builderBuilds.get(builder);
         if (build === undefined) {
             throw new TypeError("Builder access requires a BoundedContextBuilder instance.");
         }
-        return build(defaultStorageFactory);
+        return build(defaultStorageFactory, defaultAi);
     },
     subscribeToEvent(context, typeUrl, subscriber) {
         const subscribe = eventSubscribers.get(context);
@@ -627,6 +749,7 @@ export class BoundedContextBuilder {
     #generatedRepositoryOptions = new Map();
     #deliveryStrategy = UniformAcrossAllShards.singleShard();
     #storageFactory;
+    #aiRegistry;
     #subscriptionRegistry;
     #persistSystemEvents = false;
     #generatedRegistryRoot;
@@ -645,7 +768,7 @@ export class BoundedContextBuilder {
     constructor(specSnapshot, token) {
         ContextParts.requireFrameworkConstructionToken(token, "BoundedContextBuilder instances are framework-owned.");
         this.#specSnapshot = ContextParts.cloneSpecSnapshot(specSnapshot);
-        builderBuilds.set(this, (defaultStorageFactory) => this.#buildAsyncWith(defaultStorageFactory));
+        builderBuilds.set(this, (defaultStorageFactory, defaultAi) => this.#buildAsyncWith(defaultStorageFactory, defaultAi));
         Object.freeze(this);
     }
     /**
@@ -722,6 +845,7 @@ export class BoundedContextBuilder {
      *   A standalone commander requires generated receiver metadata and therefore
      *   this builder's `buildAsync()` path. It installs its Command and Event sides
      *   exactly once.
+     *
      * @returns This builder for further configuration.
      */
     addCommandDispatcher(dispatcher) {
@@ -747,6 +871,7 @@ export class BoundedContextBuilder {
      *
      * @param dispatcher Raw event dispatcher, or a standalone reactor/subscriber.
      *   Standalone receivers require generated receiver metadata and `buildAsync()`.
+     *
      * @returns This builder for further configuration.
      */
     addEventDispatcher(dispatcher) {
@@ -791,6 +916,16 @@ export class BoundedContextBuilder {
         this.#storageFactory = storageFactory;
         return this;
     }
+    /**
+     * Sets the application AI registry before this Bounded Context is built.
+     *
+     * @param registry Factory-created deployment registry.
+     * @returns This builder.
+     */
+    withAi(registry) {
+        this.#aiRegistry = registry;
+        return this;
+    }
     /**
      * Persists internal system events in the paired System Context storage.
      *
@@ -846,7 +981,7 @@ export class BoundedContextBuilder {
             throw new Error("Standalone generated handlers require buildAsync().");
         }
         ContextParts.rejectSyncEntityAssembly(this.#entityTypes);
-        return this.#buildWith([...this.#repositories], this.#storageFactory ?? new InMemoryStorageFactory());
+        return this.#buildWith([...this.#repositories], this.#storageFactory ?? new InMemoryStorageFactory(), [], this.#aiRegistry);
     }
     /**
      * Builds a context after loading generated metadata for added entity classes
@@ -861,10 +996,10 @@ export class BoundedContextBuilder {
     async buildAsync() {
         return this.#buildAsyncWith();
     }
-    async #buildAsyncWith(defaultStorageFactory) {
+    async #buildAsyncWith(defaultStorageFactory, defaultAi) {
         const generated = await this.#loadGeneratedArtifacts([...this.#entityTypes]);
         const repositories = [...this.#repositories, ...generated.repositories];
-        const context = this.#buildWith(repositories, this.#storageFactory ?? defaultStorageFactory ?? new InMemoryStorageFactory(), generated.standalone);
+        const context = this.#buildWith(repositories, this.#storageFactory ?? defaultStorageFactory ?? new InMemoryStorageFactory(), generated.standalone, this.#aiRegistry ?? defaultAi);
         try {
             await ContextParts.integrationReady(context);
         }
@@ -879,19 +1014,22 @@ export class BoundedContextBuilder {
         }
         return context;
     }
-    #buildWith(repositories, storageFactory, standalone = []) {
+    #buildWith(repositories, storageFactory, standalone = [], ai) {
         const resources = this.#subscriptionRegistry === undefined ? {} : { registry: this.#subscriptionRegistry };
         this.#subscriptionRegistry = undefined;
         const registeredRepositories = [...repositories];
         try {
-            return this.#assembleContext(registeredRepositories, storageFactory, standalone, resources);
+            return this.#assembleContext(registeredRepositories, storageFactory, standalone, resources, ai);
         }
         catch (error) {
             return this.#failBuild(resources, error);
         }
     }
-    #assembleContext(repositories, storageFactory, standalone, resources) {
+    #assembleContext(repositories, storageFactory, standalone, resources, ai) {
         ContextParts.preflightRepositories(repositories);
+        this.#preflightAgents(repositories, storageFactory, ai);
+        if (ai !== undefined)
+            freezeRegistry(ai);
         const dispatchers = this.#buildDispatchers(repositories);
         const buses = this.#buildBuses(repositories, storageFactory, dispatchers, resources);
         const standaloneEvent = this.#installStandalone(standalone, buses);
@@ -902,13 +1040,61 @@ export class BoundedContextBuilder {
             ...ContextParts.standaloneProducedEventSchemas(standalone),
         ]);
         const running = this.#buildRuntime(storageFactory, buses, resources);
-        const context = this.#createContext(repositories, storageFactory, buses, running);
+        const context = this.#createContext(repositories, storageFactory, buses, running, ai);
         ContextParts.attachIntegration(context, buses.eventBus, buses.systemSpec, ContextParts.externalEventSchemas([
             ...dispatchers.domain,
             ...(standaloneEvent === undefined ? [] : [standaloneEvent]),
         ]));
         return context;
     }
+    /**
+     * Rejects missing Agent prerequisites before repository intake is installed.
+     *
+     * @param repositories Repositories selected for this Bounded Context.
+     * @param storageFactory Provider supplying mandatory Agent records.
+     * @param ai Effective Bounded Context or server registry.
+     */
+    #preflightAgents(repositories, storageFactory, ai) {
+        const agents = repositories.filter((repository) => repository.entityFamily === "agent");
+        if (agents.length === 0)
+            return;
+        if (ai === undefined)
+            throw new TypeError("Agent registration requires an AI registry.");
+        registryOptions(ai);
+        if (!this.#persistSystemEvents)
+            throw new TypeError("Agent registration requires persisted System Events.");
+        if (!AgentHistoryStorageFactories.supports(storageFactory))
+            throw new TypeError("Agent registration requires indexed history storage.");
+        if (!AgentExecutionStorageFactories.supports(storageFactory))
+            throw new TypeError("Agent registration requires durable execution storage.");
+        this.#checkAgentOutputBindings(agents);
+        for (const repository of agents) {
+            const config = repositoryAccess.agentConfiguration(repository);
+            if (config.codeRevision === undefined || config.codeRevision.trim() === "")
+                throw new TypeError("Agent registration requires a code revision.");
+            if (config.ai === undefined)
+                throw new TypeError("Agent registration requires repository capabilities.");
+            if (config.ai.models.some((model) => !isAiModel(model)))
+                throw new TypeError("Agent repository capabilities must be factory-created models.");
+        }
+    }
+    /**
+     * Rejects Agent outcomes whose raw matching dispatcher cannot bind a saved plan.
+     */
+    #checkAgentOutputBindings(agents) {
+        const rawEvents = new Set([...this.#eventDispatchers].flatMap((dispatcher) => dispatcher.messageSchemas().map((schema) => TypeUrls.derive(schema))));
+        const rawCommands = new Set([...this.#commandDispatchers].flatMap((dispatcher) => dispatcher.messageSchemas().map((schema) => TypeUrls.derive(schema))));
+        for (const repository of agents) {
+            if (repositoryAccess
+                .producedEventSchemas(repository)
+                .some((schema) => rawEvents.has(TypeUrls.derive(schema))))
+                throw new TypeError("Agent Event output requires a durable dispatcher binding.");
+            if (repositoryAccess
+                .producedCommandSchemas(repository)
+                .some((schema) => rawCommands.has(TypeUrls.derive(schema))))
+                throw new TypeError("Agent Command output requires a durable dispatcher binding.");
+        }
+    }
     #buildDispatchers(repositories) {
         const event = [
             ...ContextParts.repositoryEventDispatchers(repositories),
@@ -998,8 +1184,8 @@ export class BoundedContextBuilder {
         resources.runtime = runtime;
         return { stand, registry, runtime };
     }
-    #createContext(repositories, storageFactory, buses, running) {
-        return ContextParts.createBoundedContext(this.#specSnapshot, buses.commandBus, buses.eventBus, buses.systemEventBus, buses.publisher, running.stand, buses.systemStand, running.runtime, buses.systemSpec, storageFactory, repositories, this.#deliveryStrategy);
+    #createContext(repositories, storageFactory, buses, running, ai) {
+        return ContextParts.createBoundedContext(this.#specSnapshot, storageFactory, repositories, this.#deliveryStrategy, buses, running, ai);
     }
     #failBuild(resources, error) {
         const cleanupErrors = [];
@@ -1271,37 +1457,33 @@ const ContextParts = Object.freeze({
      * Creates a bounded context from assembled runtime components.
      *
      * @param specSnapshot Context configuration.
-     * @param commandBus Command dispatch bus.
-     * @param eventBus Domain event bus.
-     * @param systemEventBus System event bus.
-     * @param publisher Signal publisher.
-     * @param stand Domain read-side Stand.
-     * @param systemStand System read-side Stand.
-     * @param runtime Subscription runtime.
-     * @param systemSpec Paired System specification.
      * @param storageFactory Storage provider.
      * @param repositories Registered repository views.
      * @param deliveryStrategy Delivery sharding strategy.
+     * @param buses Prepared domain and System buses.
+     * @param running Prepared Stand and subscription runtime.
+     * @param ai Effective AI registry when Agent repositories are present.
      * @returns Constructed bounded context.
      */
-    createBoundedContext(specSnapshot, commandBus, eventBus, systemEventBus, publisher, stand, systemStand, runtime, systemSpec, storageFactory, repositories, deliveryStrategy) {
+    createBoundedContext(specSnapshot, storageFactory, repositories, deliveryStrategy, buses, running, ai) {
         return constructBoundedContext({
             snapshot: {
                 name: specSnapshot.name,
                 tenantMode: ContextParts.toTenantMode(specSnapshot.multitenant),
                 spec: specSnapshot,
             },
-            commandBus,
-            eventBus,
-            systemEventBus,
-            publisher,
-            stand,
-            systemStand,
-            subscriptionRuntime: runtime,
-            systemSpec,
+            commandBus: buses.commandBus,
+            eventBus: buses.eventBus,
+            systemEventBus: buses.systemEventBus,
+            publisher: buses.publisher,
+            stand: running.stand,
+            systemStand: buses.systemStand,
+            subscriptionRuntime: running.runtime,
+            systemSpec: buses.systemSpec,
             storageFactory,
             repositories,
             deliveryStrategy,
+            ...(ai === undefined ? {} : { ai }),
             token: frameworkConstructionToken,
         });
     },
@@ -2070,7 +2252,7 @@ const ContextParts = Object.freeze({
      */
     isSystemEventDispatcher(dispatcher) {
         const schemas = [...dispatcher.messageSchemas()];
-        const systemSchemas = schemas.filter((schema) => schema.typeName.startsWith("spine.system."));
+        const systemSchemas = schemas.filter(isSystemEventSchema);
         if (systemSchemas.length > 0 && systemSchemas.length !== schemas.length) {
             throw new Error("An EventDispatcher cannot mix domain and system event schemas.");
         }
@@ -2272,17 +2454,7 @@ const ContextParts = Object.freeze({
         ContextParts.requireRepositoryInstance(repository, "BoundedContext repository registration");
         const snapshot = ContextParts.repositorySnapshot(repository);
         ContextParts.rejectRegisteredRepository(repository);
-        repositoryAccess.bindRuntime(repository, {
-            context: registration.storageContext,
-            storageFactory: registration.storageFactory,
-            stand: registration.stand,
-            signalMetadata: new SignalMetadata(),
-            entityInbox: registration.entityInbox,
-            projectionInbox: registration.projectionInbox,
-            publisher: registration.publisher,
-            registerEventSchema: registration.registerEventSchema,
-            registerSystemEventSchema: registration.registerSystemEventSchema,
-        });
+        ContextParts.bindRepositoryRuntime(repository, registration);
         const entityInboxTarget = repositoryAccess.entityInboxTarget(repository);
         const projectionInboxTarget = repositoryAccess.projectionInboxTarget(repository);
         return {
@@ -2298,6 +2470,33 @@ const ContextParts = Object.freeze({
             },
         };
     },
+    /**
+     * Binds Bounded Context services to a prepared repository before target registration.
+     *
+     * @param repository Prepared repository receiving runtime services.
+     * @param registration Bounded Context services and schemas.
+     */
+    bindRepositoryRuntime(repository, registration) {
+        repositoryAccess.bindRuntime(repository, {
+            context: registration.storageContext,
+            storageFactory: registration.storageFactory,
+            ...(registration.ai === undefined ? {} : { ai: registration.ai }),
+            stand: registration.stand,
+            signalMetadata: new SignalMetadata(),
+            entityInbox: registration.entityInbox,
+            projectionInbox: registration.projectionInbox,
+            publisher: registration.publisher,
+            registerEventSchema: registration.registerEventSchema,
+            registerSystemEventSchema: registration.registerSystemEventSchema,
+            prepareSavedEvent: registration.prepareSavedEvent,
+            prepareSavedCommand: registration.prepareSavedCommand,
+            publishSavedEvent: registration.publishSavedEvent,
+            publishSavedCommand: registration.publishSavedCommand,
+            publishAgentSystemEvent: registration.publishAgentSystemEvent,
+            recordAcceptedSaved: registration.recordAcceptedSaved,
+            wakeAcceptedAgent: registration.wakeAcceptedAgent,
+        });
+    },
     /**
      * Captures repository metadata needed for context registration.
      *