@nylorun/runtime 0.26.0-beta → 0.27.0-beta

package/dist/api/components.js

@@ -5,7 +5,7 @@
  * global registry.
  */
 import { z } from "zod";
-import { EnvironmentManifestSchema, EnvironmentSecretSlotsSchema, DeleteEnvironmentManifestResponseSchema, EnvironmentManifestPlanSchema, EnvironmentManifestVersionsSchema, EnvironmentManifestViewSchema, ListEnvironmentManifestsResponseSchema, PutEnvironmentManifestRequestSchema, PutEnvironmentSecretValueRequestSchema, SaveEnvironmentManifestResponseSchema, SessionListItemSchema, ModelCallSchema, SessionPageSchema, SessionManifestViewSchema, HistoryPageSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, ModelCallExportPageSchema, EnvironmentPageSchema, ToolCallSchema, ToolCallsPageSchema, TurnTraceSchema, JwksSchema, SigningKeyListSchema, SigningKeyViewSchema, RotateSigningKeysRequestSchema, RevokeSigningKeyRequestSchema, MeResponseSchema, TenantStatusSchema, ResetTenantRequestSchema, ResetTenantResponseSchema, SeedTenantConfigRequestSchema, SeedTenantConfigResponseSchema, HostModelCatalogSchema, TenantSandboxViewSchema, ModelUsageTotalsSchema, ModelBudgetsSchema, PutModelBudgetsRequestSchema, ToolPolicySchema, PutToolPolicyRequestSchema, PutModelInputsRequestSchema, ModelInputsViewSchema, PutTenantEnvironmentsRequestSchema, ListProvidersResponseSchema, HostModelViewSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, PutEnvironmentSecretRequestSchema, EnvironmentSecretViewSchema, ListEnvironmentSecretsResponseSchema, McpPreviewRequestSchema, McpPreviewSchema, CredentialCoverageRequestSchema, CredentialCoverageSchema, DeletedResponseSchema, ListAgentsResponseSchema, ListPublicAgentsResponseSchema, ListSessionsResponseSchema, LiveEventSchema, PutAgentRequestSchema, PutAgentResponseSchema, PutSessionRequestSchema, SessionItemsResponseSchema, SessionViewSchema, StreamClosedFrameSchema, AcceptedResponseSchema, SandboxToolOutcomeSchema, PutEnvironmentRequestSchema, EnvironmentViewSchema, EnvironmentSnapshotSchema, RestoreEnvironmentRequestSchema, ForkEnvironmentRequestSchema, EnvironmentForkPlanSchema, ForkEnvironmentResponseSchema, EnvironmentRestoreSchema, EnvironmentVersionsSchema, ListEnvironmentsResponseSchema, DeleteEnvironmentResponseSchema, ListEnvironmentEventsResponseSchema, ArtifactViewSchema, ArtifactListItemSchema, ArtifactPageSchema, ArtifactVersionViewSchema, ListArtifactsResponseSchema, UploadArtifactResponseSchema, DefinitionFileViewSchema, DeleteArtifactResponseSchema, CreateArtifactLinkRequestSchema, ArtifactLinkSchema, PutTenantArtifactsRequestSchema, TenantArtifactsViewSchema, ArtifactTreeSchema, ArtifactDiffSchema, SessionCommandSchema, ListOperatorKeysResponseSchema, PutOperatorKeyResponseSchema, DeleteOperatorKeyResponseSchema, OperatorKeySchema, ProtocolRejectedResponseSchema, RejectedResponseSchema, EVENT_SCHEMAS, EVENT_TYPES, } from "@nylorun/core/contracts";
+import { EnvironmentManifestSchema, EnvironmentSecretSlotsSchema, DeleteEnvironmentManifestResponseSchema, EnvironmentManifestPlanSchema, EnvironmentManifestVersionsSchema, EnvironmentManifestViewSchema, ListEnvironmentManifestsResponseSchema, PutEnvironmentManifestRequestSchema, PutEnvironmentSecretValueRequestSchema, SaveEnvironmentManifestResponseSchema, SessionListItemSchema, ModelCallSchema, SessionPageSchema, SessionManifestViewSchema, HistoryPageSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, ModelCallExportPageSchema, EnvironmentPageSchema, ToolCallSchema, ToolCallsPageSchema, TurnTraceSchema, JwksSchema, SigningKeyListSchema, SigningKeyViewSchema, RotateSigningKeysRequestSchema, RevokeSigningKeyRequestSchema, MeResponseSchema, TenantStatusSchema, ResetTenantRequestSchema, ResetTenantResponseSchema, SeedTenantConfigRequestSchema, SeedTenantConfigResponseSchema, HostModelCatalogSchema, TenantSandboxViewSchema, ModelUsageTotalsSchema, ModelBudgetsSchema, PutModelBudgetsRequestSchema, ToolPolicySchema, PutToolPolicyRequestSchema, PutModelInputsRequestSchema, ModelInputsViewSchema, PutTenantEnvironmentsRequestSchema, ListProvidersResponseSchema, HostModelViewSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, PutEnvironmentSecretRequestSchema, EnvironmentSecretViewSchema, ListEnvironmentSecretsResponseSchema, McpPreviewRequestSchema, McpPreviewSchema, CredentialCoverageRequestSchema, CredentialCoverageSchema, DeletedResponseSchema, ListAgentsResponseSchema, ListPublicAgentsResponseSchema, ListSessionsResponseSchema, LiveEventSchema, PutAgentRequestSchema, PutAgentResponseSchema, PutSessionRequestSchema, SessionItemsResponseSchema, SessionViewSchema, StreamClosedFrameSchema, AcceptedResponseSchema, SandboxToolOutcomeSchema, PutEnvironmentRequestSchema, EnvironmentViewSchema, EnvironmentSnapshotSchema, RestoreEnvironmentRequestSchema, ForkEnvironmentRequestSchema, EnvironmentForkPlanSchema, ForkEnvironmentResponseSchema, EnvironmentRestoreSchema, EnvironmentVersionsSchema, ListEnvironmentsResponseSchema, DeleteEnvironmentResponseSchema, ListEnvironmentEventsResponseSchema, ArtifactViewSchema, ArtifactListItemSchema, ArtifactPageSchema, ArtifactVersionViewSchema, ListArtifactsResponseSchema, UploadArtifactResponseSchema, DefinitionFileViewSchema, DeleteArtifactResponseSchema, CreateArtifactLinkRequestSchema, ArtifactLinkSchema, PutTenantArtifactsRequestSchema, PutTenantSkillsRequestSchema, PutTenantLimitsRequestSchema, TenantLimitsViewSchema, TenantArtifactsViewSchema, TenantSkillsViewSchema, ArtifactTreeSchema, ArtifactDiffSchema, SessionCommandSchema, ListOperatorKeysResponseSchema, PutOperatorKeyResponseSchema, DeleteOperatorKeyResponseSchema, OperatorKeySchema, ProtocolRejectedResponseSchema, RejectedResponseSchema, EVENT_SCHEMAS, EVENT_TYPES, } from "@nylorun/core/contracts";
 function named(id, schema) {
     return schema.meta({ id });
 }
@@ -50,6 +50,10 @@ export const CreateArtifactLinkRequest = named("CreateArtifactLinkRequest", Crea
 export const ArtifactLink = named("ArtifactLink", ArtifactLinkSchema);
 export const PutTenantArtifactsRequest = named("PutTenantArtifactsRequest", PutTenantArtifactsRequestSchema);
 export const TenantArtifactsView = named("TenantArtifactsView", TenantArtifactsViewSchema);
+export const PutTenantSkillsRequest = named("PutTenantSkillsRequest", PutTenantSkillsRequestSchema);
+export const TenantSkillsView = named("TenantSkillsView", TenantSkillsViewSchema);
+export const PutTenantLimitsRequest = named("PutTenantLimitsRequest", PutTenantLimitsRequestSchema);
+export const TenantLimitsView = named("TenantLimitsView", TenantLimitsViewSchema);
 export const ArtifactTree = named("ArtifactTree", ArtifactTreeSchema);
 export const ArtifactDiff = named("ArtifactDiff", ArtifactDiffSchema);
 export const SessionCommand = named("SessionCommand", SessionCommandSchema);

package/dist/api/gate/keys.js

@@ -1,13 +1,16 @@
 import { bodyLimit } from "hono/body-limit";
 import { HttpError } from "../../tenant/http.js";
 import { VaultError } from "../../vault/error.js";
-import { KEYS_PATH, MAX_KEYS_BODY_BYTES } from "../../keys/contract.js";
+import { KEYS_PATH } from "../../keys/contract.js";
+import { hostTuning } from "../../tuning.js";
 import { KEYS_OPERATIONS } from "../../keys/keys.js";
 export function mountKeysRoutes(app, options) {
-    app.post(`${KEYS_PATH}/:operation`, options.authorized, bodyLimit({
-        maxSize: MAX_KEYS_BODY_BYTES,
+    app.post(`${KEYS_PATH}/:operation`, options.authorized, 
+    // The largest request body: a credential with its secret, or a token's claims (`keys.bodyBytes`).
+    (c, next) => bodyLimit({
+        maxSize: hostTuning().keys.bodyBytes,
         onError: (c) => c.json({ error: { code: "invalid_request", message: "The body is too large" } }, 400),
-    }), async (c) => {
+    })(c, next), async (c) => {
         const operation = c.req.param("operation");
         if (!KEYS_OPERATIONS.includes(operation))
             return c.json({ error: { code: "invalid_request", message: `Unknown keys operation ${operation}` } }, 404);

package/dist/api/gate/routes.d.ts

@@ -1,4 +1,5 @@
 import { Hono } from "hono";
+import type { RuntimeLimits } from "@nylorun/core/contracts";
 import type { ModelCallHandler } from "../../gates/handler.js";
 import { type InflightCalls } from "../../gates/inflight.js";
 import type { McpHandler } from "../../gates/mcp-handler.js";
@@ -25,8 +26,11 @@ export interface GatesAppOptions {
     readonly inflight: InflightCalls;
     /** Whether the gate's dependencies answer (Postgres). */
     readonly ready: () => Promise<boolean>;
-    /** Largest body read. Default `MAX_MODEL_CALL_BYTES`. */
-    readonly maxBodyBytes?: number;
+    /**
+     * The Tenant's Runtime limits, read from its database for each call (`modelCallBytes` bounds a
+     * model call's body, `toolAnswerBytes` a tool request's).
+     */
+    readonly limits: () => Promise<RuntimeLimits>;
     /** Remote MCP servers (F4.1). Without it the MCP routes answer 404. */
     readonly mcp?: McpHandler;
     /** HTTP tool calls (R2 M3). Without it the HTTP calls route answers 404. */

package/dist/api/gate/routes.js

@@ -22,10 +22,10 @@ import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { HTTPException } from "hono/http-exception";
 import { isTenantId } from "@nylorun/core/compatibility";
-import { MAX_MODEL_CALL_BYTES, MODEL_CALLS_PATH, ModelCallBodySchema, TENANT_HEADER, } from "../../gates/contract.js";
+import { MODEL_CALLS_PATH, ModelCallBodySchema, TENANT_HEADER, } from "../../gates/contract.js";
 import { InflightConflict, InflightStale } from "../../gates/inflight.js";
 import { mountKeysRoutes } from "./keys.js";
-import { HTTP_CALLS_PATH, HttpCallBodySchema, MAX_TOOL_BODY_BYTES, MCP_CLOSE_PATH, MCP_CONNECT_PATH, MCP_LIST_PATH, McpListBodySchema, McpServerBodySchema, TOOL_CALLS_PATH, ToolCallBodySchema, } from "../../gates/tool-contract.js";
+import { HTTP_CALLS_PATH, HttpCallBodySchema, MCP_CLOSE_PATH, MCP_CONNECT_PATH, MCP_LIST_PATH, McpListBodySchema, McpServerBodySchema, TOOL_CALLS_PATH, ToolCallBodySchema, } from "../../gates/tool-contract.js";
 import { looksLikeToken } from "../../tenant/jwt.js";
 import { adminKeyMatches } from "../../host/http.js";
 import { canonical } from "../../store/canonical.js";
@@ -37,7 +37,6 @@ const gateError = (code, message) => ({
 });
 export function createGatesApp(options) {
     const app = new Hono();
-    const maxSize = options.maxBodyBytes ?? MAX_MODEL_CALL_BYTES;
     const logger = options.logger ?? { info() { }, warn() { }, error() { } };
     // Hono's default, but logged through the logger: never the body, which may hold secrets.
     app.onError((error, c) => {
@@ -105,10 +104,18 @@ export function createGatesApp(options) {
         return claims?.tenantId ?? tenantId;
     };
     const badTenant = (c) => c.json(invalid(`The ${TENANT_HEADER} header must name a Tenant, the run token's when there is one`), 400);
-    const toolBodies = bodyLimit({
-        maxSize: MAX_TOOL_BODY_BYTES,
-        onError: (c) => c.json(invalid(`A request body may be at most ${MAX_TOOL_BODY_BYTES} bytes`), 400),
-    });
+    /**
+     * A body of at most the Tenant's limit `name`, read for this request: a larger one is `400`,
+     * naming the limit.
+     */
+    const limited = (name, what) => async (c, next) => {
+        const maxSize = (await options.limits())[name];
+        return bodyLimit({
+            maxSize,
+            onError: (c) => c.json(invalid(`${what} may be at most ${maxSize} bytes (the Runtime limit ${name})`), 400),
+        })(c, next);
+    };
+    const toolBodies = limited("toolAnswerBytes", "A request body");
     /** The parsed body, or the 400 to answer. */
     async function read(c, schema) {
         const tenantId = tenantOf(c);
@@ -322,10 +329,7 @@ export function createGatesApp(options) {
             return c.json(gateError("gate_forbidden", "The call is another session's"), 403);
         return c.body(null, 204);
     });
-    app.post(MODEL_CALLS_PATH, run({ live: true }), bodyLimit({
-        maxSize,
-        onError: (c) => c.json(invalid(`A model call body may be at most ${maxSize} bytes`), 400),
-    }), async (c) => {
+    app.post(MODEL_CALLS_PATH, run({ live: true }), limited("modelCallBytes", "A model call body"), async (c) => {
         // Optional: the gate serves its database's one Tenant, and refuses a call naming another.
         const tenantId = tenantOf(c);
         if (tenantId === false)

package/dist/api/http/body.d.ts

@@ -1,4 +1,16 @@
+import type { TenantContext } from "../../tenant/context.js";
+/** What a body is: a JSON request (`requestBodyBytes`), or a message that may carry files inline. */
+export type BodyKind = "json" | "inline";
+/** The most bytes the Tenant's route reads of a body of `kind`. */
+export declare function bodyLimit(tenant: TenantContext, kind?: BodyKind): Promise<number>;
 /** The body as text; past `maxBytes`, `413 Request too large`. */
-export declare function readText(request: Request, maxBytes?: number): Promise<string>;
-/** The body as JSON, before any schema. */
-export declare function readJson(request: Request, maxBytes?: number): Promise<unknown>;
+export declare function readText(request: Request, maxBytes: number): Promise<string>;
+/** The body of a Tenant route's request as JSON, before any schema. */
+export declare function readJson(c: {
+    readonly req: {
+        readonly raw: Request;
+    };
+    readonly env: {
+        readonly tenant: TenantContext;
+    };
+}, kind?: BodyKind): Promise<unknown>;

package/dist/api/http/body.js

@@ -1,12 +1,20 @@
 /**
  * Request bodies of Tenant routes, read as the router they replace read them
- * (`tenant/http.ts`): at most 1 MiB unless a route allows more (an endpoint that takes files
- * inline), UTF-8, and a missing or malformed JSON body is `400 Invalid JSON`.
+ * (`tenant/http.ts`): at most the Tenant's Runtime limit `requestBodyBytes`, or for an endpoint
+ * that takes files inline `inlineBodyBytes` of its limits (one file at `inlineFileBytes` in
+ * base64, and the rest), UTF-8, and a missing or malformed JSON body is `400 Invalid JSON`. The
+ * limits are read for each request.
  */
+import { inlineBodyBytes } from "@nylorun/core/contracts";
 import { fail } from "../../tenant/http.js";
-const MAX_BODY_BYTES = 1024 * 1024;
+import { readRuntimeLimits } from "../../tenant/runtime-limits.js";
+/** The most bytes the Tenant's route reads of a body of `kind`. */
+export async function bodyLimit(tenant, kind = "json") {
+    const limits = await tenant.store.tx((t) => readRuntimeLimits(t));
+    return kind === "inline" ? inlineBodyBytes(limits) : limits.requestBodyBytes;
+}
 /** The body as text; past `maxBytes`, `413 Request too large`. */
-export async function readText(request, maxBytes = MAX_BODY_BYTES) {
+export async function readText(request, maxBytes) {
     if (request.body === null)
         return "";
     const chunks = [];
@@ -25,9 +33,9 @@ export async function readText(request, maxBytes = MAX_BODY_BYTES) {
     }
     return Buffer.concat(chunks).toString("utf8");
 }
-/** The body as JSON, before any schema. */
-export async function readJson(request, maxBytes = MAX_BODY_BYTES) {
-    const text = await readText(request, maxBytes);
+/** The body of a Tenant route's request as JSON, before any schema. */
+export async function readJson(c, kind = "json") {
+    const text = await readText(c.req.raw, await bodyLimit(c.env.tenant, kind));
     try {
         return JSON.parse(text);
     }

package/dist/api/http/respond.js

@@ -4,6 +4,7 @@
  * (`routes.ts`) both answer through here, so a route answers the same wherever it runs.
  */
 import { SandboxRouteError } from "../../core/sandbox-routes.js";
+import { RecordEntryTooLargeError } from "../../record/index.js";
 import { HttpError, OpaqueAuthError } from "../../tenant/http.js";
 import { VaultError } from "../../vault/error.js";
 /** A JSON answer. CORS headers a browser needs are already on the Node response. */
@@ -24,13 +25,16 @@ export function rejectionOf(error) {
         return { status: error.status, body: error.body, headers: {} };
     const status = error instanceof HttpError ||
         error instanceof VaultError ||
-        error instanceof SandboxRouteError
+        error instanceof SandboxRouteError ||
+        error instanceof RecordEntryTooLargeError
         ? error.status
         : error?.name === "ZodError" ||
             error?.message === "Invalid cursor"
             ? 400
             : 500;
-    const rejection = error instanceof HttpError || error instanceof VaultError ? error.rejection : {};
+    const rejection = error instanceof HttpError || error instanceof VaultError || error instanceof RecordEntryTooLargeError
+        ? error.rejection
+        : {};
     return {
         status,
         body: {

package/dist/api/http/routes/access.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
-import { RevokeSigningKeyRequestSchema, RotateSigningKeysRequestSchema, TOKEN_TTL_MAX_SECONDS, } from "@nylorun/core/contracts";
+import { RevokeSigningKeyRequestSchema, RotateSigningKeysRequestSchema, } from "@nylorun/core/contracts";
 import { Jwks, RevokeSigningKeyRequest, RotateSigningKeysRequest, SigningKeyList, SigningKeyView, } from "../../components.js";
 import { publicJwk, signingKeyView } from "../../../tenant/signing-keys.js";
 import { readJson } from "../body.js";
 import { tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
+import { hostTuning } from "../../../tuning.js";
 /** The Management API's signing-key routes: a management key. */
 const MANAGEMENT = { credentials: ["management"], scopes: "never" };
 const json = (schema, description) => ({
@@ -74,10 +75,10 @@ function signingKeyRoutesAt(api, base, access) {
         },
     }, async (c) => {
         const ctx = c.env.tenant;
-        const request = RotateSigningKeysRequestSchema.parse(await readJson(c.req.raw));
+        const request = RotateSigningKeysRequestSchema.parse(await readJson(c));
         // The longest any token the Runtime signs lives (capability links, run tokens).
         const keys = await ctx.keys.rotateSigningKeys({
-            maxTtlSeconds: TOKEN_TTL_MAX_SECONDS,
+            maxTtlSeconds: hostTuning().keys.tokenTtlMaxSeconds,
             force: request.force === true,
         });
         ctx.config.logger.info("signing keys rotated", { force: request.force === true });
@@ -95,7 +96,7 @@ function signingKeyRoutesAt(api, base, access) {
         },
     }, async (c) => {
         const ctx = c.env.tenant;
-        RevokeSigningKeyRequestSchema.parse(await readJson(c.req.raw));
+        RevokeSigningKeyRequestSchema.parse(await readJson(c));
         const row = await ctx.store.tx((t) => ctx.signingKeys.revoke(t, c.req.param("kid")));
         ctx.config.logger.info("signing key revoked", { kid: row.id });
         return jsonResponse(200, signingKeyView(row));

package/dist/api/http/routes/artifacts.js

@@ -21,7 +21,7 @@ import { effectiveArtifactLimits, readArtifactsConfig, writeArtifactsConfig, } f
 import { contentKey, diffManifests, entryAt, readManifest } from "../../../artifacts/folders.js";
 import { mintArtifactLink, verifyArtifactLink } from "../../../artifacts/links.js";
 import { zipStream, zipTooLarge } from "../../../artifacts/zip.js";
-import { normalizeContentType } from "../../../artifacts/media-types.js";
+import { normalizeContentType } from "@nylorun/core/contracts";
 import { artifactContent, deleteArtifact, folderContent, getArtifact, listArtifacts, readableArtifact, uploadArtifact, versionOf, } from "../../../artifacts/service.js";
 import { accessOf } from "../../../tenant/auth.js";
 import { readAccess, readStoreOf } from "../../../reads/access.js";
@@ -29,7 +29,9 @@ import { fail } from "../../../tenant/http.js";
 import { readJson } from "../body.js";
 import { tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
-import { pageQuery, parseQuery } from "./reads.js";
+import { labelIssues } from "../../../tenant/limits.js";
+import { readRuntimeLimits } from "../../../tenant/runtime-limits.js";
+import { pageQuery, pageSize, parseQuery } from "./reads.js";
 /** Reading and writing artifacts: whoever may use sessions, a person only in their own. */
 const OWN = {
     credentials: ["application", "subject", "token"],
@@ -105,6 +107,15 @@ function labelsOf(values) {
         fail(400, parsed.error.issues[0]?.message ?? "Invalid labels");
     return labels;
 }
+/** `labels` to set on an artifact, within the Tenant's Runtime limits (read for the request). */
+async function settableLabels(ctx, labels) {
+    if (labels === undefined)
+        return undefined;
+    const issues = labelIssues(labels, await ctx.store.tx((t) => readRuntimeLimits(t)), "artifactLabels");
+    if (issues.length > 0)
+        fail(400, issues.join(" "));
+    return labels;
+}
 function versionNumber(value) {
     if (value === "latest")
         return undefined;
@@ -285,7 +296,7 @@ export function artifactRoutes(api) {
         const request = c.req.raw;
         const name = c.req.query("name");
         const sessionId = c.req.query("sessionId");
-        const labels = labelsOf(c.req.queries("label"));
+        const labels = await settableLabels(c.env.tenant, labelsOf(c.req.queries("label")));
         const contentType = declaredType(request);
         const uploaded = await uploadArtifact(c.env.tenant, {
             ...(name === undefined ? {} : { name }),
@@ -337,9 +348,10 @@ export function artifactRoutes(api) {
     }, async (c) => {
         const sessionId = c.req.query("sessionId");
         if (c.req.query("limit") !== undefined) {
-            const { limit, cursor, kind } = parseQuery(artifactPageQuery, c.req.query());
-            if (limit === undefined)
+            const { limit: asked, cursor, kind } = parseQuery(artifactPageQuery, c.req.query());
+            if (asked === undefined)
                 return fail(400, "Pagination requires limit");
+            const limit = await pageSize(c.env.tenant, asked);
             return jsonResponse(200, await readStoreOf(c.env.tenant).artifacts({ sessionId, kind, labels: labelsOf(c.req.queries("label")) ?? {} }, { limit, cursor }, readAccess(c.get("scope"))));
         }
         return jsonResponse(200, await listArtifacts(c.env.tenant, sessionId === undefined ? {} : { sessionId }, accessOf(c.get("scope"))));
@@ -457,7 +469,7 @@ export function artifactRoutes(api) {
         responses: { 200: json(ArtifactLink, "The link") },
     }, async (c) => {
         const ctx = c.env.tenant;
-        const request = CreateArtifactLinkRequestSchema.parse(await readJson(c.req.raw));
+        const request = CreateArtifactLinkRequestSchema.parse(await readJson(c));
         const id = c.req.param("artifactId");
         const { artifact, version } = await ctx.store.tx(async (t) => {
             const artifact = await readableArtifact(t, id, accessOf(c.get("scope")));
@@ -528,7 +540,7 @@ export function artifactRoutes(api) {
         responses: { 200: json(TenantArtifactsView, "The limits now in force") },
     }, async (c) => {
         const ctx = c.env.tenant;
-        const { requestId: _requestId, ...config } = PutTenantArtifactsRequestSchema.parse(await readJson(c.req.raw));
+        const { requestId: _requestId, ...config } = PutTenantArtifactsRequestSchema.parse(await readJson(c));
         await ctx.store.tx((t) => writeArtifactsConfig(t, config));
         return jsonResponse(200, await artifactsView(ctx));
     });

package/dist/api/http/routes/coverage.js

@@ -26,7 +26,7 @@ export function coverageRoutes(api) {
             404: json(Rejected, "No such agent, or no such Environment"),
         },
     }, async (c) => {
-        const request = CredentialCoverageRequestSchema.parse(await readJson(c.req.raw));
+        const request = CredentialCoverageRequestSchema.parse(await readJson(c));
         const tenant = c.env.tenant;
         const definition = (await tenant.store.tx((t) => t.get("definitions", request.agentId))) ?? fail(404, "Definition not found");
         return jsonResponse(200, await tenant.vault.coverage(definition.manifest, request));

package/dist/api/http/routes/environment-manifests.js

@@ -70,7 +70,7 @@ export function environmentManifestRoutes(api) {
         },
     }, async (c) => {
         const name = nameOf(c.req.param("name"));
-        const body = PutEnvironmentManifestRequestSchema.parse(await readJson(c.req.raw));
+        const body = PutEnvironmentManifestRequestSchema.parse(await readJson(c));
         const ifMatch = ifMatchOf(c.req.header("if-match"));
         const options = ifMatch === undefined ? {} : { ifMatch };
         return jsonResponse(200, c.req.query("dryRun") === "true"

package/dist/api/http/routes/environments.js

@@ -88,7 +88,7 @@ export function environmentRoutes(api) {
         },
     }, async (c) => {
         const id = idOf(c.req.param("environmentId"));
-        const body = PutEnvironmentRequestSchema.parse(await readJson(c.req.raw));
+        const body = PutEnvironmentRequestSchema.parse(await readJson(c));
         return jsonResponse(200, await putEnvironment(c.env.tenant, id, body, c.get("scope")));
     });
     tenantRoute(api, READ, {
@@ -105,7 +105,7 @@ export function environmentRoutes(api) {
         path: "/v1/environments/{environmentId}/events",
         tags: ["Environments"],
         summary: "Read an Environment's events",
-        description: "`environment.created`, `.attached`, `.detached`, `.deleted`, a pod's `.running`, `.suspended`, `.relaunched`, `.lost`, `.reset` and `.failed`, and `environment.egress` for every connection its sandbox opens through egress-gate, naming the turns that were running (D67), in order, numbered from 0, at most 1000 per call.",
+        description: "`environment.created`, `.attached`, `.detached`, `.deleted`, a pod's `.running`, `.suspended`, `.relaunched`, `.lost`, `.reset` and `.failed`, and `environment.egress` for every connection its sandbox opens through egress-gate, naming the turns that were running (D67), in order, numbered from 0, at most the Tenant's Runtime limit `environmentEventItems` (default 1000) per call: `from` reads on.",
         request: {
             params: environmentId,
             query: z.object({
@@ -213,7 +213,7 @@ export function environmentRoutes(api) {
             409: { description: "A turn or another copy holds the disk (`environment_busy`)" },
         },
     }, async (c) => {
-        const body = RestoreEnvironmentRequestSchema.parse(await readJson(c.req.raw));
+        const body = RestoreEnvironmentRequestSchema.parse(await readJson(c));
         return jsonResponse(200, await restoreEnvironment(c.env.tenant, idOf(c.req.param("environmentId")), c.get("scope"), body.version));
     });
     tenantRoute(api, WRITE, {
@@ -234,7 +234,7 @@ export function environmentRoutes(api) {
             409: { description: "The id exists, or a turn or another copy holds the source's disk (`environment_busy`)" },
         },
     }, async (c) => {
-        const body = ForkEnvironmentRequestSchema.parse(await readJson(c.req.raw));
+        const body = ForkEnvironmentRequestSchema.parse(await readJson(c));
         const answer = await forkEnvironment(c.env.tenant, idOf(c.req.param("environmentId")), body, c.get("scope"));
         return jsonResponse("dryRun" in answer ? 200 : 201, answer);
     });
@@ -295,7 +295,7 @@ export function environmentRoutes(api) {
         path: "/v1/environments/{environmentId}/secrets/{name}",
         tags: ["Environments"],
         summary: "Write an Environment's secret",
-        description: "Creates or replaces one credential of the Environment's vault: an `environment_secret` (the variable `name` reads the sentinel `nylorun-managed` in the sandbox, and egress-gate sets the value as a header on requests to `allowedHosts`), an `environment_variable` (a plain variable), or a `bearer` token or `headers` map for the MCP servers and HTTP tools at `url`. The same name and type re-seals the value and binding; another type replaces it. A rotated value is used from the next request. A second credential for a host or a URL is `409 credential_conflict`. When what the Environment runs declares secret slots (protocol 14, D64), send only the value (`{ value }`, or `{ headers }` for a `headers` slot): the type and binding come from the slot, and a name it does not declare is `409 secret_not_in_manifest`.",
+        description: "Creates or replaces one credential of the Environment's vault: an `environment_secret` (the variable `name` reads the sentinel `nylorun_managed` in the sandbox, and egress-gate sets the value as a header on requests to `allowedHosts`), an `environment_variable` (a plain variable), or a `bearer` token or `headers` map for the MCP servers and HTTP tools at `url`. The same name and type re-seals the value and binding; another type replaces it. A rotated value is used from the next request. A second credential for a host or a URL is `409 credential_conflict`. When what the Environment runs declares secret slots (protocol 14, D64), send only the value (`{ value }`, or `{ headers }` for a `headers` slot): the type and binding come from the slot, and a name it does not declare is `409 secret_not_in_manifest`.",
         request: {
             params: secretPath,
             body: {
@@ -312,7 +312,7 @@ export function environmentRoutes(api) {
         const scope = c.get("scope");
         assertReaches(scope, id);
         const name = c.req.param("name") ?? "";
-        const body = await secretRequestFor(c.env.tenant, id, name, await readJson(c.req.raw));
+        const body = await secretRequestFor(c.env.tenant, id, name, await readJson(c));
         return jsonResponse(200, await c.env.tenant.keys.putEnvironmentSecret(id, name, body, actorOf(scope)));
     });
     tenantRoute(api, WRITE, {

package/dist/api/http/routes/files.d.ts

@@ -1,7 +1,8 @@
 /**
  * Definition files (track R2 M4): `PUT /v1/files/sha256:{hex}` uploads one file a definition
  * names by its content hash (a skill's), `HEAD` says whether the Tenant holds it. Application
- * key only: definitions are the application's, not a person's.
+ * key only: definitions are the application's, not a person's. The Tenant's skill limit is
+ * `GET`/`PUT /v1/tenant/skills`, a Management API route.
  */
 import type { OpenAPIHono } from "@hono/zod-openapi";
 import type { TenantEnv } from "../app.js";

package/dist/api/http/routes/files.js

@@ -1,13 +1,17 @@
 import { z } from "zod";
-import { DEFINITION_FILE_MAX_BYTES } from "@nylorun/core/contracts";
-import { DefinitionFileView } from "../../components.js";
-import { normalizeContentType } from "../../../artifacts/media-types.js";
+import { PutTenantSkillsRequestSchema } from "@nylorun/core/contracts";
+import { DefinitionFileView, PutTenantSkillsRequest, TenantSkillsView } from "../../components.js";
+import { readJson } from "../body.js";
+import { normalizeContentType } from "@nylorun/core/contracts";
 import { hasDefinitionFile, putDefinitionFile } from "../../../tenant/definition-files.js";
+import { effectiveSkillLimits, readSkillsConfig, writeSkillsConfig } from "../../../tenant/limits.js";
 import { fail } from "../../../tenant/http.js";
 import { tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
 const APPLICATION = { credentials: ["application"], scopes: "never" };
 const UPLOAD = { ...APPLICATION, bytes: true };
+/** The Tenant's skill limit: a Management API route (`/v1/tenant/skills`). */
+const SETTINGS = { credentials: ["management"], scopes: "never" };
 const file = z.object({
     file: z.string().meta({ description: "`sha256:` and the SHA-256 of the file's bytes, 64 lowercase hex digits" }),
 });
@@ -36,7 +40,7 @@ export function fileRoutes(api) {
         path: "/v1/files/{file}",
         tags: ["Definition files"],
         summary: "Upload a definition file",
-        description: `Stores the body, at most ${DEFINITION_FILE_MAX_BYTES} bytes, at the SHA-256 the path names; a body with another hash stores nothing (\`400\`). A file the Tenant holds already is kept as it is (\`200\`).`,
+        description: "Streams the body, at most the Tenant's skill limit (`/v1/tenant/skills`, default 2 GiB: one file may be as large as a whole skill), to the SHA-256 the path names; a body with another hash stores nothing (`400`). A file the Tenant holds already is kept as it is (`200`).",
         request: {
             params: file,
             body: {
@@ -48,7 +52,7 @@ export function fileRoutes(api) {
         responses: {
             200: view("The Tenant held the file already"),
             201: view("The file, stored"),
-            413: { description: `Larger than ${DEFINITION_FILE_MAX_BYTES} bytes (\`limit_exceeded\`)` },
+            413: { description: "Larger than the Tenant's skill limit (`limit_exceeded`)" },
         },
     }, async (c) => {
         const request = c.req.raw;
@@ -74,4 +78,26 @@ export function fileRoutes(api) {
             return fail(404, "The Runtime does not hold this file");
         return new Response(null, { status: 200 });
     });
+    tenantRoute(api, SETTINGS, {
+        method: "get",
+        path: "/v1/tenant/skills",
+        tags: ["Tenant"],
+        summary: "Get the Tenant's skill limit",
+        responses: { 200: { description: "The limit in force", content: { "application/json": { schema: TenantSkillsView } } } },
+    }, async (c) => jsonResponse(200, { limits: effectiveSkillLimits(await c.env.tenant.store.tx((t) => readSkillsConfig(t))) }));
+    tenantRoute(api, SETTINGS, {
+        method: "put",
+        path: "/v1/tenant/skills",
+        tags: ["Tenant"],
+        summary: "Set the Tenant's skill limit",
+        description: "The most bytes one skill's files may hold together, for every agent the Tenant stores and every Environment, whose manifest may set a lower one (`limits.skills`). Unset, the limit takes the default (2 GiB). Agents already stored keep their skills; a session opens only while its agent's skills fit.",
+        request: {
+            body: { required: true, content: { "application/json": { schema: PutTenantSkillsRequest } } },
+        },
+        responses: { 200: { description: "The limit now in force", content: { "application/json": { schema: TenantSkillsView } } } },
+    }, async (c) => {
+        const { requestId: _requestId, ...config } = PutTenantSkillsRequestSchema.parse(await readJson(c));
+        await c.env.tenant.store.tx((t) => writeSkillsConfig(t, config));
+        return jsonResponse(200, { limits: effectiveSkillLimits(config) });
+    });
 }

package/dist/api/http/routes/mcp.js

@@ -26,7 +26,7 @@ export function mcpRoutes(api) {
             502: json(Rejected, "The server could not be listed (`mcp_preview_failed`): `details.failure` is the code a tool call would have failed with, such as `mcp.unreachable` for an address the Host refuses"),
         },
     }, async (c) => {
-        const request = McpPreviewRequestSchema.parse(await readJson(c.req.raw));
+        const request = McpPreviewRequestSchema.parse(await readJson(c));
         return jsonResponse(200, await c.env.tenant.keys.previewMcp(request));
     });
 }

package/dist/api/http/routes/reads.d.ts

@@ -6,6 +6,15 @@ export declare const pageQuery: z.ZodObject<{
     limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     cursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * The size of a page: `asked`, or, when the query names none, `fallback`, each within the Tenant's
+ * Runtime limit `name` (read for each request): a page asked larger holds that many, and its
+ * cursor reads on.
+ */
+export declare function pageSize(ctx: TenantEnv["Bindings"]["tenant"], asked: number | undefined, options?: {
+    fallback?: number;
+    name?: "pageItems" | "exportPageItems";
+}): Promise<number>;
 export declare const sessionPageQuery: z.ZodObject<{
     limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     cursor: z.ZodOptional<z.ZodString>;
@@ -72,6 +81,19 @@ export declare function environmentPage(ctx: TenantEnv["Bindings"]["tenant"], sc
                 path: string;
                 files: Record<string, string>;
             })[] | undefined;
+            limits?: {
+                artifacts?: {
+                    fileBytes?: number | undefined;
+                    totalBytes?: number | undefined;
+                } | undefined;
+                skills?: {
+                    totalBytes?: number | undefined;
+                } | undefined;
+                disk?: {
+                    versionBytes?: number | undefined;
+                    versionEntries?: number | undefined;
+                } | undefined;
+            } | undefined;
             secrets?: Record<string, {
                 required?: boolean | undefined;
                 description?: string | undefined;
@@ -108,6 +130,19 @@ export declare function environmentPage(ctx: TenantEnv["Bindings"]["tenant"], sc
         manifestName?: string | undefined;
         manifestVersion?: number | undefined;
         manifestHash?: string | undefined;
+        limits: {
+            artifacts: {
+                fileBytes: number;
+                totalBytes: number;
+            };
+            skills: {
+                totalBytes: number;
+            };
+            disk: {
+                versionBytes: number;
+                versionEntries: number;
+            };
+        };
         forkedFrom?: {
             environment: string;
             disk: number | null;