@segmentstream-cloud/ontology 0.12.0 → 0.14.0

package/dist/service/config.js

@@ -9,6 +9,12 @@ export const ENVIRONMENT_VARIABLES = {
     workspaceId: "SEGMENTSTREAM_WORKSPACE_ID",
     organizationId: "SEGMENTSTREAM_ORGANIZATION_ID",
 };
+/**
+ * The workspace app credential (`ssw_…`), which Vercel injects into every service of a production
+ * deployment. The service forwards aggregates to SegmentStream with it; without it, aggregates are
+ * unavailable and everything else works.
+ */
+export const APP_CREDENTIAL_VARIABLE = "SEGMENTSTREAM_APP_CREDENTIAL";
 /**
  * The workspace's Neon Auth, which signs the app's users in. Provisioning sets both on workspaces
  * that have it; a service without them accepts SegmentStream app tokens and API keys only.
@@ -17,6 +23,17 @@ export const NEON_AUTH_ENVIRONMENT_VARIABLES = {
     baseUrl: "NEON_AUTH_BASE_URL",
     jwksUrl: "NEON_AUTH_JWKS_URL",
 };
+/**
+ * The deployment's own runtime callers, such as the app's agent: the issuer and the audience of the
+ * team's Vercel OIDC tokens, set together by the platform on deployments that have an agent. Without
+ * them a runtime token is an invalid token. Tokens must also name the project in Vercel's
+ * `VERCEL_PROJECT_ID`, as the agent runs in the same Vercel project as the ontology service.
+ */
+export const RUNTIME_IDENTITY_ENVIRONMENT_VARIABLES = {
+    issuer: "SEGMENTSTREAM_RUNTIME_OIDC_ISSUER",
+    audience: "SEGMENTSTREAM_RUNTIME_OIDC_AUDIENCE",
+    projectId: "VERCEL_PROJECT_ID",
+};
 /** The service cannot start: its configuration is incomplete or invalid. */
 export class OntologyServiceConfigError extends Schema.TaggedError()("OntologyServiceConfigError", { message: Schema.String }) {
 }
@@ -54,6 +71,35 @@ function neonAuthFromEnv(read) {
         jwksUrl: httpUrl(NEON_AUTH_ENVIRONMENT_VARIABLES.jwksUrl, read(NEON_AUTH_ENVIRONMENT_VARIABLES.jwksUrl)).href,
     };
 }
+/**
+ * The runtime issuer and audience, both or neither, and the project the tokens must name. A partial
+ * configuration is a broken deployment, so the service refuses to start rather than run without the
+ * agent's identity, or trust tokens of every project of the team.
+ */
+function runtimeIdentityFromEnv(read) {
+    const { issuer, audience, projectId } = RUNTIME_IDENTITY_ENVIRONMENT_VARIABLES;
+    const pair = [issuer, audience];
+    const missingPair = pair.filter((name) => read(name) === "");
+    if (missingPair.length === pair.length) {
+        return undefined;
+    }
+    if (missingPair.length > 0) {
+        throw new OntologyServiceConfigError({
+            message: `The ontology service cannot start: ${pair.join(" and ")} are set together; ` +
+                `${missingPair.join(", ")} is not set.`,
+        });
+    }
+    if (read(projectId) === "") {
+        throw new OntologyServiceConfigError({
+            message: `The ontology service cannot start: ${projectId} is not set, which runtime tokens must name.`,
+        });
+    }
+    return {
+        issuer: httpUrl(issuer, read(issuer)).href.replace(/\/+$/, ""),
+        audience: read(audience),
+        projectId: read(projectId),
+    };
+}
 function checkDatabaseUrl(name, value) {
     // The value is a credential: errors name the variable, never the value.
     if (!URL.canParse(value)) {
@@ -70,7 +116,8 @@ function checkDatabaseUrl(name, value) {
 /**
  * Reads the service's configuration from the environment. It fails closed: a missing or invalid
  * variable throws {@link OntologyServiceConfigError} naming every missing variable, and never the
- * value of the database URL. The Neon Auth variables are optional, but only as a pair.
+ * value of the database URL. The Neon Auth and runtime identity variables are optional, but only as
+ * pairs. The app credential is optional and kept redacted.
  */
 export function configFromEnv(environment = process.env) {
     const read = (name) => environment[name]?.trim() ?? "";
@@ -83,6 +130,7 @@ export function configFromEnv(environment = process.env) {
         });
     }
     const neonAuth = neonAuthFromEnv(read);
+    const runtimeIdentity = runtimeIdentityFromEnv(read);
     const localConnections = localConnectionsFromEnv(environment);
     let blobStorage;
     if (read("SEGMENTSTREAM_ONTOLOGY_STORAGE")) {
@@ -107,7 +155,11 @@ export function configFromEnv(environment = process.env) {
                 storageMaintenanceKey: Redacted.make(read("SEGMENTSTREAM_ONTOLOGY_STORAGE_MAINTENANCE_KEY")),
             }
             : {}),
+        ...(read(APP_CREDENTIAL_VARIABLE)
+            ? { appCredential: Redacted.make(read(APP_CREDENTIAL_VARIABLE)) }
+            : {}),
         ...(neonAuth === undefined ? {} : { neonAuth }),
+        ...(runtimeIdentity === undefined ? {} : { runtimeIdentity }),
         ...(localConnections === undefined ? {} : { localConnections }),
     };
 }

package/dist/service/errors.d.ts

@@ -30,6 +30,38 @@ declare const SignInCheckLimited_base: Schema.Class<SignInCheckLimited, Schema.T
 /** A client asked `POST /api/ontology/sign-in/check` too often; it may ask again after this. */
 export declare class SignInCheckLimited extends SignInCheckLimited_base {
 }
+declare const InvalidAggregateQuery_base: Schema.Class<InvalidAggregateQuery, Schema.TaggedStruct<"InvalidAggregateQuery", {
+    readonly reason: Schema.String;
+}>, Cause.YieldableError>;
+/** An aggregate request the ontology cannot answer; the reason is written for the caller. */
+export declare class InvalidAggregateQuery extends InvalidAggregateQuery_base {
+}
+declare const ReadDenied_base: Schema.Class<ReadDenied, Schema.TaggedStruct<"ReadDenied", {
+    readonly permissions: Schema.$Array<Schema.String>;
+}>, Cause.YieldableError>;
+/** The caller lacks `<entity>:read` on entities an aggregate reads: every such permission. */
+export declare class ReadDenied extends ReadDenied_base {
+}
+declare const AggregateUnavailable_base: Schema.Class<AggregateUnavailable, Schema.TaggedStruct<"AggregateUnavailable", {}>, Cause.YieldableError>;
+/** The deployment has no workspace app credential: previews and local development. */
+export declare class AggregateUnavailable extends AggregateUnavailable_base {
+}
+declare const AggregateLimited_base: Schema.Class<AggregateLimited, Schema.TaggedStruct<"AggregateLimited", {
+    readonly retryAfterSeconds: Schema.Number;
+}>, Cause.YieldableError>;
+/** A principal ran more aggregates than its window allows; it may run more after this. */
+export declare class AggregateLimited extends AggregateLimited_base {
+}
+declare const AggregateUpstreamUnavailable_base: Schema.Class<AggregateUpstreamUnavailable, Schema.TaggedStruct<"AggregateUpstreamUnavailable", {
+    readonly reason: Schema.Literals<readonly ["unreachable", "timeout", "invalid_response", "credential_rejected", "upstream_misconfigured"]>;
+    readonly status: Schema.optionalKey<Schema.Number>;
+}>, Cause.YieldableError>;
+/**
+ * SegmentStream did not answer an aggregate usably, or its answer faults the deployment rather than
+ * the caller. The operator log keeps the details; the caller learns only the reason.
+ */
+export declare class AggregateUpstreamUnavailable extends AggregateUpstreamUnavailable_base {
+}
 export interface ErrorBody {
     readonly error: string;
     readonly detail: string;
@@ -60,6 +92,12 @@ export declare function notInvited(requestId: string): ErrorResponse;
  * The cookie rides along with any request to the app's domain, so only its origin can vouch for it.
  */
 export declare function crossOriginSession(requestId: string): ErrorResponse;
+/** The caller is authenticated but may not do this; the detail says why. */
+export declare function forbidden(requestId: string, detail: string): ErrorResponse;
+/** A client asked too often; it may ask again after `retryAfterSeconds`. */
+export declare function rateLimited(requestId: string, detail: string, retryAfterSeconds: number): ErrorResponse;
+/** The resource does not exist, or not for this caller; the detail says what to do. */
+export declare function notFound(requestId: string, detail: string): ErrorResponse;
 export declare function unavailable(requestId: string): ErrorResponse;
 export declare function internalError(requestId: string): ErrorResponse;
 export declare function routeNotFound(requestId: string): ErrorResponse;

package/dist/service/errors.js

@@ -20,6 +20,50 @@ export class InvalidRequestBody extends Schema.TaggedError()("InvalidRequestBody
 /** A client asked `POST /api/ontology/sign-in/check` too often; it may ask again after this. */
 export class SignInCheckLimited extends Schema.TaggedError()("SignInCheckLimited", { retryAfterSeconds: Schema.Number }) {
 }
+/** An aggregate request the ontology cannot answer; the reason is written for the caller. */
+export class InvalidAggregateQuery extends Schema.TaggedError()("InvalidAggregateQuery", { reason: Schema.String }) {
+}
+/** The caller lacks `<entity>:read` on entities an aggregate reads: every such permission. */
+export class ReadDenied extends Schema.TaggedError()("ReadDenied", {
+    permissions: Schema.Array(Schema.String),
+}) {
+}
+/** The deployment has no workspace app credential: previews and local development. */
+export class AggregateUnavailable extends Schema.TaggedError()("AggregateUnavailable", {}) {
+}
+/** A principal ran more aggregates than its window allows; it may run more after this. */
+export class AggregateLimited extends Schema.TaggedError()("AggregateLimited", {
+    retryAfterSeconds: Schema.Number,
+}) {
+}
+/**
+ * SegmentStream did not answer an aggregate usably, or its answer faults the deployment rather than
+ * the caller. The operator log keeps the details; the caller learns only the reason.
+ */
+export class AggregateUpstreamUnavailable extends Schema.TaggedError()("AggregateUpstreamUnavailable", {
+    reason: Schema.Literals([
+        "unreachable",
+        "timeout",
+        "invalid_response",
+        "credential_rejected",
+        "upstream_misconfigured",
+    ]),
+    status: Schema.optionalKey(Schema.Number),
+}) {
+}
+const UPSTREAM_DETAILS = {
+    unreachable: "SegmentStream could not be reached. Try again shortly.",
+    timeout: "SegmentStream did not answer in time. Try again shortly.",
+    invalid_response: "SegmentStream answered with an unexpected response.",
+    credential_rejected: "SegmentStream refused the deployment's credential.",
+    upstream_misconfigured: "SegmentStream does not serve aggregates for this deployment.",
+};
+/** `a`, `a and b`, `a, b and c`. */
+function listed(values) {
+    return values.length <= 1
+        ? values.join("")
+        : `${values.slice(0, -1).join(", ")} and ${values.at(-1)}`;
+}
 export function toServerResponse(response) {
     return HttpServerResponse.jsonUnsafe(errorBodyForWire(response.body), {
         status: response.status,
@@ -85,6 +129,22 @@ export function crossOriginSession(requestId) {
         },
     };
 }
+/** The caller is authenticated but may not do this; the detail says why. */
+export function forbidden(requestId, detail) {
+    return { status: 403, body: { error: "forbidden", detail, requestId } };
+}
+/** A client asked too often; it may ask again after `retryAfterSeconds`. */
+export function rateLimited(requestId, detail, retryAfterSeconds) {
+    return {
+        status: 429,
+        body: { error: "rate_limited", detail, requestId },
+        headers: { "retry-after": String(retryAfterSeconds) },
+    };
+}
+/** The resource does not exist, or not for this caller; the detail says what to do. */
+export function notFound(requestId, detail) {
+    return { status: 404, body: { error: "not_found", detail, requestId } };
+}
 export function unavailable(requestId) {
     return {
         status: 503,
@@ -279,6 +339,64 @@ export function expectedFailure(error, requestId) {
             },
         };
     }
+    if (Predicate.isTagged(error, "ReadDenied")) {
+        const { permissions } = error;
+        return {
+            status: 403,
+            body: {
+                error: "forbidden",
+                detail: `${listed(permissions)} ${permissions.length === 1 ? "is" : "are"} required.`,
+                requestId,
+                permissions,
+            },
+        };
+    }
+    if (Predicate.isTagged(error, "AggregateLimited")) {
+        const { retryAfterSeconds } = error;
+        return {
+            status: 429,
+            body: {
+                error: "rate_limited",
+                detail: `Too many aggregates. Wait ${retryAfterSeconds} seconds, then try again.`,
+                requestId,
+                retryable: true,
+            },
+            headers: { "retry-after": String(retryAfterSeconds) },
+        };
+    }
+    if (Predicate.isTagged(error, "InvalidAggregateQuery")) {
+        return {
+            status: 400,
+            body: {
+                error: "invalid_aggregate_query",
+                detail: error.reason,
+                requestId,
+            },
+        };
+    }
+    if (Predicate.isTagged(error, "AggregateUnavailable")) {
+        return {
+            status: 503,
+            body: {
+                error: "aggregate_unavailable",
+                detail: "Aggregates are available in production deployments.",
+                requestId,
+                retryable: false,
+            },
+        };
+    }
+    if (Predicate.isTagged(error, "AggregateUpstreamUnavailable")) {
+        const { reason } = error;
+        return {
+            status: 502,
+            body: {
+                error: "aggregate_upstream_unavailable",
+                detail: UPSTREAM_DETAILS[reason],
+                requestId,
+                retryable: reason === "unreachable" || reason === "timeout",
+            },
+        };
+    }
     if (Predicate.isTagged(error, "ConnectionError")) {
         return connectionFailure(error, requestId);
     }

package/dist/service/handlers.d.ts

@@ -1,5 +1,6 @@
 import { Layer } from "effect";
 import { type HttpApiGroup } from "effect/unstable/httpapi";
+import type { Aggregates } from "./aggregate.js";
 import { type BuiltApi } from "./api.js";
 import type { AfterCommitHook } from "./config.js";
 import type { ReplicationKick } from "./replication.js";
@@ -12,4 +13,4 @@ import { OntologyBackend } from "./runtime-contract.js";
  */
 export declare const SIGN_IN_CHECK_LIMIT: RateLimit;
 /** The handlers of every group of the API; they require {@link OntologyBackend}. */
-export declare function handlersLayer(built: BuiltApi, hooks: ReadonlyMap<string, AfterCommitHook>, connections: ConnectionTransportFactory, replicate: ReplicationKick): Layer.Layer<HttpApiGroup.Service<"ontology", string>, never, OntologyBackend>;
+export declare function handlersLayer(built: BuiltApi, hooks: ReadonlyMap<string, AfterCommitHook>, connections: ConnectionTransportFactory, replicate: ReplicationKick, aggregates: Aggregates): Layer.Layer<HttpApiGroup.Service<"ontology", string>, never, OntologyBackend>;

package/dist/service/handlers.js

@@ -3,11 +3,12 @@ import { Effect, Layer, Schema } from "effect";
 import { HttpApiBuilder, OpenApi } from "effect/unstable/httpapi";
 import { STORAGE_GROUP } from "../storage/api.js";
 import { Conflict } from "../errors.js";
+import { isValueMatched } from "../manifest.js";
 import { EMAIL_PATTERN } from "../property.js";
-import { renderCatalog } from "../render.js";
-import { SERVICE_GROUP } from "./api.js";
+import { SERVICE_GROUP, hasMeasures } from "./api.js";
 import { CurrentPrincipal } from "./authentication.js";
 import { catalogFor, graphOf } from "./catalog.js";
+import { describeCatalog } from "../render.js";
 import { InvalidRequestBody, SignInCheckLimited, schemaIssues } from "./errors.js";
 import { identityToken, makeOperations, requireRead, toQuery, } from "./operations.js";
 import { clientAddress, fixedWindowLimiter, } from "./rate-limit.js";
@@ -24,34 +25,43 @@ function isJsonMediaType(contentType) {
     const mediaType = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
     return mediaType === "application/json" || mediaType.endsWith("+json");
 }
-/** Reads `{ input, options? }`. The input itself is validated by `runAction`. */
-function readEnvelope(request) {
+/** Reads a JSON body: `application/json` or a `+json` type, or no content type at all. */
+function readJson(request) {
     return Effect.gen(function* () {
         if (!isJsonMediaType(request.headers["content-type"])) {
             return yield* new InvalidRequestBody({ reason: "unsupported_media_type", issues: [] });
         }
         const text = yield* Effect.orDie(request.text);
-        let body;
         try {
-            body = JSON.parse(text);
+            return JSON.parse(text);
         }
         catch {
             return yield* new InvalidRequestBody({ reason: "invalid_json", issues: [] });
         }
-        return yield* Schema.decodeUnknownEffect(ActionEnvelope)(body, { errors: "all" }).pipe(Effect.mapError((error) => new InvalidRequestBody({ reason: "invalid_request", issues: schemaIssues(error.issue) })));
     });
 }
-function entityHandlers(built, planned, operationsOf) {
+/** Reads `{ input, options? }`. The input itself is validated by `runAction`. */
+function readEnvelope(request) {
+    return readJson(request).pipe(Effect.flatMap((body) => Schema.decodeUnknownEffect(ActionEnvelope)(body, { errors: "all" }).pipe(Effect.mapError((error) => new InvalidRequestBody({
+        reason: "invalid_request",
+        issues: schemaIssues(error.issue),
+    })))));
+}
+function entityHandlers(built, planned, operationsOf, aggregates) {
+    // Registered beside the record routes; `aggregate` is a static segment, record ids are UUIDs.
+    const withAggregate = (handlers) => hasMeasures(planned)
+        ? handlers.handleRaw("aggregate", aggregateHandler(aggregates.entity(planned.name)))
+        : handlers;
     return dynamicGroup(built.api, planned.name, (handlers) => Effect.gen(function* () {
         if (planned.resolved.entity.definition.source !== undefined) {
-            return handlers.handleRaw("sourceCollection", () => requireRead([planned.name]).pipe(Effect.andThen(() => HttpServerResponse.json({
+            return withAggregate(handlers).handleRaw("sourceCollection", () => requireRead([planned.name]).pipe(Effect.andThen(() => HttpServerResponse.json({
                 error: "not_found",
                 detail: `${planned.name} uses a warehouse source; query it through the workspace API.`,
             }, { status: 404 }))));
         }
         const backend = yield* OntologyBackend;
         const operations = operationsOf(backend);
-        let registered = handlers
+        let registered = withAggregate(handlers)
             .handle("find", (request) => operations.find(planned, toQuery(request.query)))
             .handle("query", (request) => operations.find(planned, toQuery(request.payload)))
             .handle("get", (request) => operations.get(planned, request.params.id))
@@ -108,7 +118,21 @@ function checkSignIn(backend, limiter) {
         return yield* backend.checkSignIn(email);
     });
 }
-function serviceHandlers(built, operationsOf) {
+/**
+ * `POST /api/ontology/aggregate` and `POST /api/ontology/<entity>/aggregate`: the facade's answer is
+ * SegmentStream's, so its status and JSON body pass through as they came, with its `Retry-After` on
+ * a 429 or a 503.
+ */
+function aggregateHandler(aggregate) {
+    return ({ request }) => readJson(request).pipe(Effect.flatMap(aggregate), Effect.map((answer) => HttpServerResponse.text(answer.text, {
+        status: answer.status,
+        contentType: "application/json",
+        ...(answer.retryAfter === undefined
+            ? {}
+            : { headers: { "retry-after": answer.retryAfter } }),
+    })));
+}
+function serviceHandlers(built, operationsOf, aggregate) {
     const { manifest } = built.plan.ontology;
     const graph = graphOf(manifest);
     const signInLimiter = fixedWindowLimiter(SIGN_IN_CHECK_LIMIT);
@@ -130,29 +154,43 @@ function serviceHandlers(built, operationsOf) {
             .handle("openapi", () => Effect.sync(() => {
             if (openApi === undefined) {
                 openApi = OpenApi.fromApi(built.api);
-                for (const entity of manifest.entities.filter((entity) => entity.source !== undefined)) {
-                    const document = Schema.toJsonSchemaDocument(built.schemas.get(entity.name).record);
-                    openApi.components.schemas ??= {};
-                    openApi.components.schemas[entity.name] = {
-                        ...(document.definitions[`${entity.name
-                            .split("_")
-                            .map((part) => part[0].toUpperCase() + part.slice(1))
-                            .join("")}Record`] ?? document.schema),
-                        "x-ontology-source": entity.source,
-                        "x-ontology-measures": entity.measures,
-                        "x-ontology-relationships": entity.relationships,
-                    };
+                openApi.components.schemas ??= {};
+                for (const entity of manifest.entities) {
+                    const recordName = `${entity.name
+                        .split("_")
+                        .map((part) => part[0].toUpperCase() + part.slice(1))
+                        .join("")}Record`;
+                    if (entity.source !== undefined) {
+                        const document = Schema.toJsonSchemaDocument(built.schemas.get(entity.name).record);
+                        openApi.components.schemas[entity.name] = {
+                            ...(document.definitions[recordName] ?? document.schema),
+                            "x-ontology-source": entity.source,
+                            "x-ontology-measures": entity.measures,
+                            "x-ontology-relationships": entity.relationships,
+                        };
+                        continue;
+                    }
+                    // A value-matched relationship has no key field or route; only this names it.
+                    const matched = entity.relationships.filter(isValueMatched);
+                    const record = openApi.components.schemas[recordName];
+                    if (matched.length > 0 && record !== undefined) {
+                        openApi.components.schemas[recordName] = {
+                            ...record,
+                            "x-ontology-relationships": matched,
+                        };
+                    }
                 }
             }
             return openApi;
         }))
-            .handle("describe", (request) => Effect.map(permissionsFor(request.query.as), (permissions) => renderCatalog(manifest, permissions === undefined ? {} : { as: permissions })))
+            .handle("describe", (request) => Effect.map(permissionsFor(request.query.as), (permissions) => describeCatalog(manifest, permissions)))
             .handle("status", () => Effect.map(backend.appliedHash, (appliedHash) => ({
             hash: manifest.hash,
             appliedHash: appliedHash ?? null,
             upToDate: appliedHash === manifest.hash,
         })))
-            .handle("signInCheck", checkSignIn(backend, signInLimiter));
+            .handle("signInCheck", checkSignIn(backend, signInLimiter))
+            .handleRaw("aggregate", aggregateHandler(aggregate));
     }));
 }
 function storageHandlers(built) {
@@ -178,14 +216,14 @@ function storageHandlers(built) {
     }));
 }
 /** The handlers of every group of the API; they require {@link OntologyBackend}. */
-export function handlersLayer(built, hooks, connections, replicate) {
+export function handlersLayer(built, hooks, connections, replicate, aggregates) {
     const operationsOf = (backend) => makeOperations(backend, built.plan, hooks, connections, replicate);
     const layers = [
-        serviceHandlers(built, operationsOf),
+        serviceHandlers(built, operationsOf, aggregates.model),
         ...(built.plan.ontology.manifest.entities.some((entity) => entity.properties.some((property) => property.type === "blob"))
             ? [storageHandlers(built)]
             : []),
-        ...built.plan.entities.map((planned) => entityHandlers(built, planned, operationsOf)),
+        ...built.plan.entities.map((planned) => entityHandlers(built, planned, operationsOf, aggregates)),
     ];
     const [first, ...rest] = layers;
     return Layer.mergeAll(first, ...rest);

package/dist/service/mcp/server.d.ts

@@ -1,5 +1,6 @@
 import { Layer } from "effect";
 import { HttpRouter } from "effect/unstable/http";
+import type { Aggregates } from "../aggregate.js";
 import type { BuiltApi } from "../api.js";
 import { type TokenVerifier } from "../authentication.js";
 import type { AfterCommitHook } from "../config.js";
@@ -7,6 +8,7 @@ import type { ConnectionTransportFactory } from "../connections.js";
 import { RequestId } from "../errors.js";
 import type { ReplicationKick } from "../replication.js";
 import { OntologyBackend } from "../runtime-contract.js";
+import { type RuntimeTokenVerifier } from "../runtime-identity.js";
 /** The URL path of the ontology's MCP server, outside `/api/ontology`: one per app. */
 export declare const MCP_PATH = "/mcp";
 /** The MCP revisions the server speaks, newest first. */
@@ -17,6 +19,10 @@ export interface McpServerOptions {
     readonly connections: ConnectionTransportFactory;
     readonly replicate: ReplicationKick;
     readonly verifyToken: TokenVerifier;
+    /** The deployment's runtime tokens, acting as a member; `undefined` while that is disabled. */
+    readonly verifyRuntime?: RuntimeTokenVerifier | undefined;
+    /** The facade the aggregate routes run; the aggregate tool runs its model-level aggregate. */
+    readonly aggregates: Aggregates;
 }
 /**
  * The ontology's MCP server at `POST /mcp`: Streamable HTTP without sessions, so any instance can