@nylorun/runtime 0.26.0-beta → 0.27.0-beta

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

@@ -5,13 +5,37 @@ import { turnTrace } from "../../../traces/read.js";
 import { readAccess, readStoreOf } from "../../../reads/access.js";
 import { requireApplication, requirePrincipal } from "../../../tenant/auth.js";
 import { fail } from "../../../tenant/http.js";
+import { readRuntimeLimits } from "../../../tenant/runtime-limits.js";
 import { environmentGrantsOf } from "../../../tenant/environments.js";
 import { tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
+/** A page's `limit`, held to the Tenant's Runtime limit `pageItems` (`pageSize`). */
+const limitParam = (fallback) => z.coerce
+    .number()
+    .int()
+    .min(1)
+    .optional()
+    .meta({
+    description: `A page holds at most the Tenant's Runtime limit \`pageItems\` (default 200); a larger limit gets that many${fallback === undefined ? "" : `. Default ${fallback}, or that limit when it is lower`}`,
+});
 export const pageQuery = z.object({
-    limit: z.coerce.number().int().min(1).max(200).optional(),
+    limit: limitParam(),
     cursor: z.string().optional(),
 });
+/** The size of a page of a session's calls when the query names none (within `pageItems`). */
+const CALLS_PAGE_DEFAULT = 50;
+/** The size of a page of the model call export when the query names none (within `exportPageItems`). */
+const EXPORT_PAGE_DEFAULT = 200;
+/**
+ * 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 async function pageSize(ctx, asked, options = {}) {
+    const name = options.name ?? "pageItems";
+    const limit = (await ctx.store.tx((t) => readRuntimeLimits(t)))[name];
+    return Math.min(asked ?? options.fallback ?? limit, limit);
+}
 export const sessionPageQuery = pageQuery
     .extend({
     agentId: z.string().optional(),
@@ -30,13 +54,13 @@ export async function sessionPage(ctx, scope, query) {
         return fail(400, "Pagination requires limit");
     if (filters.ownerUserId !== undefined)
         requireApplication(scope);
-    return readStoreOf(ctx).sessions(filters, { limit, cursor }, readAccess(scope));
+    return readStoreOf(ctx).sessions(filters, { limit: await pageSize(ctx, limit), cursor }, readAccess(scope));
 }
 export async function environmentPage(ctx, scope, query, labels) {
     const { limit, cursor } = parseQuery(pageQuery.extend({ label: z.string().optional() }).strict(), query);
     if (limit === undefined)
         return fail(400, "Pagination requires limit");
-    return readStoreOf(ctx).environments(labels, { limit, cursor }, readAccess(scope), environmentGrantsOf(scope));
+    return readStoreOf(ctx).environments(labels, { limit: await pageSize(ctx, limit), cursor }, readAccess(scope), environmentGrantsOf(scope));
 }
 export function readRoutes(api) {
     const sessionId = z.object({ sessionId: z.string() });
@@ -57,15 +81,14 @@ export function readRoutes(api) {
         requirePrincipal(c.get("scope"));
         return jsonResponse(200, await readStoreOf(c.env.tenant).manifest(c.req.param("sessionId"), readAccess(c.get("scope"))));
     });
+    const callsQuery = turnQuery
+        .extend({
+        limit: limitParam(CALLS_PAGE_DEFAULT),
+        cursor: z.string().optional(),
+    })
+        .strict();
     for (const kind of ["usage", "calls/model"]) {
-        const query = kind === "usage"
-            ? turnQuery
-            : turnQuery
-                .extend({
-                limit: z.coerce.number().int().min(1).max(200).default(50),
-                cursor: z.string().optional(),
-            })
-                .strict();
+        const query = kind === "usage" ? turnQuery : callsQuery;
         // Spend is the application's to show: no subject scope reaches it (`tenant:settings`,
         // which used to, is retired in protocol 8).
         tenantRoute(api, { credentials: ["application"], scopes: "never" }, {
@@ -93,18 +116,14 @@ export function readRoutes(api) {
                 const q = parseQuery(turnQuery, c.req.query());
                 return jsonResponse(200, await store.usage(id, q.turnId, access));
             }
-            const q = parseQuery(turnQuery
-                .extend({
-                limit: z.coerce.number().int().min(1).max(200).default(50),
-                cursor: z.string().optional(),
-            })
-                .strict(), c.req.query());
-            return jsonResponse(200, await store.modelCalls(id, q.turnId, q, access));
+            const q = parseQuery(callsQuery, c.req.query());
+            const limit = await pageSize(c.env.tenant, q.limit, { fallback: CALLS_PAGE_DEFAULT });
+            return jsonResponse(200, await store.modelCalls(id, q.turnId, { ...q, limit }, access));
         });
     }
     const toolCallsQuery = turnQuery
         .extend({
-        limit: z.coerce.number().int().min(1).max(200).default(50),
+        limit: limitParam(CALLS_PAGE_DEFAULT),
         cursor: z.string().optional(),
     })
         .strict();
@@ -125,7 +144,8 @@ export function readRoutes(api) {
     }, async (c) => {
         requirePrincipal(c.get("scope"));
         const q = parseQuery(toolCallsQuery, c.req.query());
-        return jsonResponse(200, await readStoreOf(c.env.tenant).toolCalls(c.req.param("sessionId"), q.turnId, q, readAccess(c.get("scope"))));
+        const limit = await pageSize(c.env.tenant, q.limit, { fallback: CALLS_PAGE_DEFAULT });
+        return jsonResponse(200, await readStoreOf(c.env.tenant).toolCalls(c.req.param("sessionId"), q.turnId, { ...q, limit }, readAccess(c.get("scope"))));
     });
     // A turn's spans (R7.5): the same mapping the trace projector posts, from the turn's log rows,
     // with the installation's content opt-ins. Spans carry cost: the application's, as /calls are.
@@ -153,7 +173,14 @@ export function readRoutes(api) {
     const exportQuery = z
         .object({
         after: z.string().optional(),
-        limit: z.coerce.number().int().min(1).max(1000).default(200),
+        limit: z.coerce
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .meta({
+            description: `A page holds at most the Tenant's Runtime limit \`exportPageItems\` (default 1000); a larger limit gets that many. Default ${EXPORT_PAGE_DEFAULT}, or that limit when it is lower`,
+        }),
     })
         .strict();
     // The whole Tenant's ledger is the Management API's (protocol 8): a management key, as itself.
@@ -171,6 +198,7 @@ export function readRoutes(api) {
         },
     }, async (c) => {
         const q = parseQuery(exportQuery, c.req.query());
-        return jsonResponse(200, await readStoreOf(c.env.tenant).exportModel(q.after, q.limit));
+        const limit = await pageSize(c.env.tenant, q.limit, { fallback: EXPORT_PAGE_DEFAULT, name: "exportPageItems" });
+        return jsonResponse(200, await readStoreOf(c.env.tenant).exportModel(q.after, limit));
     });
 }

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

@@ -13,7 +13,7 @@ import { readHistory, requestCursor, streamHolderOf, streamSessionEvents } from
 import { listAgentsPublic, listDefinitions, listSessions, putDefinition, putSession, sessionView, } from "../../../tenant/sessions.js";
 import { readJson } from "../body.js";
 import { TraceHeaders, tenantRoute } from "../define.js";
-import { pageQuery, sessionPage, sessionPageQuery, parseQuery } from "./reads.js";
+import { pageQuery, pageSize, sessionPage, sessionPageQuery, parseQuery } from "./reads.js";
 import { jsonResponse } from "../respond.js";
 const OWN_SESSIONS = {
     credentials: ["application", "subject", "token"],
@@ -57,14 +57,11 @@ export function sessionRoutes(api) {
         responses: {
             200: json(AcceptedResponse, "The command, accepted"),
             409: { description: "A turn is running, or the session does not wait on this" },
-            422: {
-                description: "A message names a file the Tenant's model does not read (`attachment_unsupported`; `details.parts` lists each with its reason). No turn starts.",
-            },
         },
     }, async (c) => {
         // A `traceparent` joins the turn to the caller's trace (R7.4); a malformed one is ignored.
         const trace = traceContextOf(c.req.raw.headers);
-        return jsonResponse(200, await command(c.env.tenant, c.req.param("sessionId"), SessionCommandSchema.parse(await readJson(c.req.raw)), c.get("scope"), trace ? { trace } : {}));
+        return jsonResponse(200, await command(c.env.tenant, c.req.param("sessionId"), SessionCommandSchema.parse(await readJson(c)), c.get("scope"), trace ? { trace } : {}));
     });
     tenantRoute(api, {
         credentials: ["application", "subject", "token"],
@@ -98,9 +95,12 @@ export function sessionRoutes(api) {
             }),
             body: body(PutAgentRequest),
         },
-        responses: { 200: json(PutAgentResponse, "The definition, stored (or checked, with dryRun)") },
+        responses: {
+            200: json(PutAgentResponse, "The definition, stored (or checked, with dryRun)"),
+            413: { description: "A skill's files hold more than the Tenant's skill limit together (`limit_exceeded`)" },
+        },
     }, async (c) => {
-        return jsonResponse(200, await putDefinition(c.env.tenant, c.req.param("agentId"), PutAgentRequestSchema.parse(await readJson(c.req.raw)), { dryRun: c.req.query("dryRun") === "true" }));
+        return jsonResponse(200, await putDefinition(c.env.tenant, c.req.param("agentId"), PutAgentRequestSchema.parse(await readJson(c)), { dryRun: c.req.query("dryRun") === "true" }));
     });
     tenantRoute(api, OWN_SESSIONS, {
         method: "get",
@@ -130,7 +130,7 @@ export function sessionRoutes(api) {
     }, async (c) => {
         const scope = c.get("scope");
         const ctx = c.env.tenant;
-        const request = PutSessionRequestSchema.parse(await readJson(c.req.raw));
+        const request = PutSessionRequestSchema.parse(await readJson(c));
         // Agent code may trust `info`: only an app server sets it.
         if (scope.kind === "token" && request.info !== undefined)
             fail(403, "A token caller cannot set session info", { code: "scope_required" });
@@ -172,7 +172,8 @@ export function sessionRoutes(api) {
         const ctx = c.env.tenant;
         const id = c.req.param("sessionId");
         const cursor = await sessionBelow(ctx, c.env.incoming, id, accessOf(scope));
-        const { limit } = parseQuery(pageQuery.pick({ limit: true }), { limit: c.req.query("limit") });
+        const { limit: asked } = parseQuery(pageQuery.pick({ limit: true }), { limit: c.req.query("limit") });
+        const limit = asked === undefined ? undefined : await pageSize(ctx, asked);
         return jsonResponse(200, await readHistory(ctx, id, cursor, c.req.query("agent"), limit));
     });
     tenantRoute(api, OWN_SESSIONS, {
@@ -222,7 +223,7 @@ export function sessionRoutes(api) {
         await sessionBelow(ctx, c.env.incoming, id, accessOf(scope));
         requireApplication(scope);
         try {
-            return jsonResponse(200, await handleSessionSandboxTool(sandboxRouteDeps(ctx), id, c.req.param("tool"), await readJson(c.req.raw), c.req.raw.signal));
+            return jsonResponse(200, await handleSessionSandboxTool(sandboxRouteDeps(ctx), id, c.req.param("tool"), await readJson(c), c.req.raw.signal));
         }
         catch (error) {
             if (error instanceof SandboxRouteError)

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

@@ -1,7 +1,7 @@
 /**
  * The Tenant's own settings (`/v1/tenant/**`): its status, reset, a first configuration, the
- * model it calls, what its model calls cost and may cost (budgets), and the sandboxes its
- * sessions get.
+ * model it calls, what its model calls cost and may cost (budgets), the sandboxes its
+ * sessions get, and its Runtime limits.
  *
  * A reset that deletes sessions moves the Tenant to a new basin generation, so a session
  * created again starts in an empty basin; the old basin is deleted after a grace period.

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

@@ -1,8 +1,9 @@
 import { z } from "zod";
-import { ModelUsageQuerySchema, PutModelBudgetsRequestSchema, PutToolPolicyRequestSchema, PutModelInputsRequestSchema, PutHostModelRequestSchema, PutTenantEnvironmentsRequestSchema, ResetTenantRequestSchema, SeedTenantConfigRequestSchema, SelectHostModelRequestSchema, } from "@nylorun/core/contracts";
-import { HostModelCatalog, HostModelView, ListProvidersResponse, ModelBudgets, ModelInputsView, ModelUsageTotals, PutModelBudgetsRequest, PutToolPolicyRequest, PutModelInputsRequest, ToolPolicy, PutHostModelRequest, PutTenantEnvironmentsRequest, ResetTenantRequest, ResetTenantResponse, SeedTenantConfigRequest, SeedTenantConfigResponse, SelectHostModelRequest, TenantSandboxView, TenantStatus, } from "../../components.js";
+import { ModelUsageQuerySchema, PutModelBudgetsRequestSchema, PutToolPolicyRequestSchema, PutModelInputsRequestSchema, PutHostModelRequestSchema, PutTenantEnvironmentsRequestSchema, PutTenantLimitsRequestSchema, RUNTIME_LIMIT_CEILINGS, RUNTIME_LIMIT_DEFAULTS, ResetTenantRequestSchema, runtimeLimitIssues, runtimeLimitsOf, SeedTenantConfigRequestSchema, SelectHostModelRequestSchema, } from "@nylorun/core/contracts";
+import { HostModelCatalog, HostModelView, ListProvidersResponse, ModelBudgets, ModelInputsView, ModelUsageTotals, PutModelBudgetsRequest, PutToolPolicyRequest, PutModelInputsRequest, ToolPolicy, PutHostModelRequest, PutTenantEnvironmentsRequest, PutTenantLimitsRequest, ResetTenantRequest, ResetTenantResponse, SeedTenantConfigRequest, SeedTenantConfigResponse, SelectHostModelRequest, TenantLimitsView, TenantSandboxView, TenantStatus, } from "../../components.js";
+import { readRuntimeLimits, writeLimitsConfig } from "../../../tenant/runtime-limits.js";
 import { periodStart } from "../../../gates/meter.js";
-import { readToolPolicy, TOOL_POLICY_SETTING } from "../../../gates/policy.js";
+import { readToolPolicy, TOOL_POLICY_SETTING, ToolPolicyUnreadable } from "../../../gates/policy.js";
 import { addableInputs, capabilitiesOf, inputsError } from "../../../model/capabilities.js";
 import { catalogModel, hostModelCatalog } from "../../../model/catalog.js";
 import { sandboxConfigErrors } from "../../../sandbox/resolve.js";
@@ -18,8 +19,14 @@ import { readJson } from "../body.js";
 import { pathSegments, tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
 import { rearmPodTimers } from "../../../tenant/environments.js";
+import { hostTuning } from "../../../tuning.js";
+import { budgetIssues, toolPolicyIssues } from "../../../tenant/limits.js";
 /** Every Management API route (`/v1/tenant/*`): a management key, acting as itself (protocol 8). */
 const MANAGEMENT = { credentials: ["management"], scopes: "never" };
+/** Each Runtime limit's default and ceiling, for the limits routes' descriptions. */
+const LIMITS_TABLE = `Defaults and ceilings: ${Object.entries(RUNTIME_LIMIT_CEILINGS)
+    .map(([name, ceiling]) => `\`${name}\` ${RUNTIME_LIMIT_DEFAULTS[name]} ${ceiling.unit}, at most ${ceiling.value} (${ceiling.why})`)
+    .join("; ")}.`;
 const json = (schema, description) => ({
     description,
     content: { "application/json": { schema } },
@@ -94,7 +101,7 @@ export function tenantRoutes(api) {
             vault,
             sandbox: ctx.sandbox,
             closing: ctx.closing || ctx.closed,
-            modelConfigured: !ctx.useVaultModel ||
+            modelConfigured: ctx.scriptedModel ||
                 (await ctx.store.tx((t) => usesFixtureModel(t))) ||
                 (await vault.getHostModel()).configured,
             ...(ctx.stuckInvocations ? { stuckInvocations: ctx.stuckInvocations } : {}),
@@ -112,8 +119,8 @@ export function tenantRoutes(api) {
         responses: { 200: json(ResetTenantResponse, "Reset") },
     }, async (c) => {
         const ctx = c.env.tenant;
-        const request = ResetTenantRequestSchema.parse(await readJson(c.req.raw));
-        await drain(ctx, request.activeWork, 30_000);
+        const request = ResetTenantRequestSchema.parse(await readJson(c));
+        await drain(ctx, request.activeWork, hostTuning().tenant.drainTimeoutMs);
         // A sessions reset moves the Tenant to a new basin generation, so a session created
         // again with the same id, during or after the reset, starts in an empty basin at 0.
         const sessionsReset = request.scope !== "environments";
@@ -143,7 +150,7 @@ export function tenantRoutes(api) {
         responses: { 200: json(SeedTenantConfigResponse, "What was set, and what was kept") },
     }, async (c) => {
         const ctx = c.env.tenant;
-        const request = SeedTenantConfigRequestSchema.parse(await readJson(c.req.raw));
+        const request = SeedTenantConfigRequestSchema.parse(await readJson(c));
         return jsonResponse(200, await seedTenantConfig({ store: ctx.store, vault: ctx.vault, keys: ctx.keys }, request));
     });
     tenantRoute(api, MANAGEMENT, {
@@ -162,11 +169,11 @@ export function tenantRoutes(api) {
         path: "/v1/tenant/models/inputs",
         tags: ["Tenant"],
         summary: "Set what a catalog model reads",
-        description: "Replaces the inputs the operator added to one catalog model (Tenant setting `model.inputs`): only those in its `addableInputs`, which its provider API carries. Its catalog's own inputs always stay; an empty list removes the additions. A message naming a file the Tenant's model does not read is refused with `422 attachment_unsupported`. A custom endpoint sets `settings.inputs` on `PUT /v1/tenant/model` instead.",
+        description: "Replaces the inputs the operator added to one catalog model (Tenant setting `model.inputs`): only those in its `addableInputs`, which its provider API carries. Its catalog's own inputs always stay; an empty list removes the additions. The agent's harness learns them in `turn.start.model` and decides how each file reaches the model. A custom endpoint sets `settings.inputs` on `PUT /v1/tenant/model` instead.",
         request: { body: body(PutModelInputsRequest) },
         responses: { 200: json(ModelInputsView, "What the model reads now") },
     }, async (c) => {
-        const { provider, model, inputs } = PutModelInputsRequestSchema.parse(await readJson(c.req.raw));
+        const { provider, model, inputs } = PutModelInputsRequestSchema.parse(await readJson(c));
         if (provider === "custom")
             fail(400, "A custom endpoint's inputs are its settings: set settings.inputs on PUT /v1/tenant/model.");
         const found = catalogModel(provider, model);
@@ -183,6 +190,33 @@ export function tenantRoutes(api) {
             inputs: capabilitiesOf(found, added).inputs,
         });
     });
+    tenantRoute(api, MANAGEMENT, {
+        method: "get",
+        path: "/v1/tenant/limits",
+        tags: ["Tenant"],
+        summary: "Get the Tenant's Runtime limits",
+        description: `The sizes, counts and deadlines the Runtime holds what crosses it to: the Tenant's (Tenant setting \`limits.config\`), with the default for each it leaves out. Harnesses get the ones they must respect in \`turn.start.limits\` (record entry, model call, model file, tool answer, custom harness state, Harness API chunk, folder entries). ${LIMITS_TABLE}`,
+        responses: { 200: json(TenantLimitsView, "The limits in force") },
+    }, async (c) => jsonResponse(200, { limits: await c.env.tenant.store.tx((t) => readRuntimeLimits(t)) }));
+    tenantRoute(api, MANAGEMENT, {
+        method: "put",
+        path: "/v1/tenant/limits",
+        tags: ["Tenant"],
+        summary: "Set the Tenant's Runtime limits",
+        description: `Replaces the Tenant's Runtime limits: a limit left out takes its default. A limit above its ceiling, which a dependency sets, is \`400\` naming the ceiling, and nothing is written. Each is read where it is checked, so a new value holds for the next request, write, call or segment. ${LIMITS_TABLE}`,
+        request: { body: body(PutTenantLimitsRequest) },
+        responses: {
+            200: json(TenantLimitsView, "The limits now in force"),
+            400: { description: "A limit above its ceiling" },
+        },
+    }, async (c) => {
+        const { requestId: _requestId, ...config } = PutTenantLimitsRequestSchema.parse(await readJson(c));
+        const issues = runtimeLimitIssues(config.limits);
+        if (issues.length > 0)
+            fail(400, issues.join(" "));
+        await c.env.tenant.store.tx((t) => writeLimitsConfig(t, config));
+        return jsonResponse(200, { limits: runtimeLimitsOf(config.limits) });
+    });
     tenantRoute(api, MANAGEMENT, {
         method: "get",
         path: "/v1/tenant/sandbox",
@@ -200,7 +234,7 @@ export function tenantRoutes(api) {
         responses: { 200: json(TenantSandboxView, "The configuration now in force") },
     }, async (c) => {
         const ctx = c.env.tenant;
-        const { requestId: _requestId, ...config } = PutTenantEnvironmentsRequestSchema.parse(await readJson(c.req.raw));
+        const { requestId: _requestId, ...config } = PutTenantEnvironmentsRequestSchema.parse(await readJson(c));
         const errors = sandboxConfigErrors(effectiveSandboxConfig(config));
         if (errors.length > 0)
             fail(400, errors.join(" "));
@@ -257,9 +291,12 @@ export function tenantRoutes(api) {
         request: { body: body(PutModelBudgetsRequest) },
         responses: { 200: json(ModelBudgets, "The budgets now in force") },
     }, async (c) => {
-        const { budgets } = PutModelBudgetsRequestSchema.parse(await readJson(c.req.raw));
+        const { budgets } = PutModelBudgetsRequestSchema.parse(await readJson(c));
         const updatedAt = new Date().toISOString();
         const rows = await c.env.tenant.store.tx(async (t) => {
+            const issues = budgetIssues(budgets, await readRuntimeLimits(t));
+            if (issues.length > 0)
+                fail(400, issues.join(" "));
             await t.putModelBudgets(budgets.map((budget) => budgetRow(budget, updatedAt)));
             return t.listModelBudgets();
         });
@@ -271,7 +308,18 @@ export function tenantRoutes(api) {
         tags: ["Tenant"],
         summary: "Get the Tenant's tool policy",
         responses: { 200: json(ToolPolicy, "The rules the Tool Gate applies to every MCP and HTTP tool call") },
-    }, async (c) => jsonResponse(200, await c.env.tenant.store.tx((t) => readToolPolicy(t))));
+    }, async (c) => {
+        try {
+            return jsonResponse(200, await c.env.tenant.store.tx((t) => readToolPolicy(t)));
+        }
+        catch (error) {
+            // A stored rule this Runtime refuses (an MCP tool named `server__tool`, protocol 15):
+            // every call is denied until the policy is set again.
+            if (error instanceof ToolPolicyUnreadable)
+                return fail(409, error.message, { code: "request_rejected" });
+            throw error;
+        }
+    });
     tenantRoute(api, MANAGEMENT, {
         method: "put",
         path: "/v1/tenant/tool-policy",
@@ -281,9 +329,14 @@ export function tenantRoutes(api) {
         request: { body: body(PutToolPolicyRequest) },
         responses: { 200: json(ToolPolicy, "The policy now in force") },
     }, async (c) => {
-        const { rules } = PutToolPolicyRequestSchema.parse(await readJson(c.req.raw));
+        const { rules } = PutToolPolicyRequestSchema.parse(await readJson(c));
         const policy = { rules, updatedAt: new Date().toISOString() };
-        await c.env.tenant.store.tx((t) => t.putSetting(TOOL_POLICY_SETTING, JSON.stringify(policy)));
+        await c.env.tenant.store.tx(async (t) => {
+            const issues = toolPolicyIssues(rules, await readRuntimeLimits(t));
+            if (issues.length > 0)
+                fail(400, issues.join(" "));
+            await t.putSetting(TOOL_POLICY_SETTING, JSON.stringify(policy));
+        });
         return jsonResponse(200, policy);
     });
     tenantRoute(api, MANAGEMENT, {
@@ -309,7 +362,7 @@ export function tenantRoutes(api) {
         responses: { 200: json(HostModelView, "The model now in force") },
     }, async (c) => {
         const ctx = c.env.tenant;
-        return jsonResponse(200, await ctx.keys.putHostModel(PutHostModelRequestSchema.parse(await readJson(c.req.raw))));
+        return jsonResponse(200, await ctx.keys.putHostModel(PutHostModelRequestSchema.parse(await readJson(c))));
     });
     tenantRoute(api, MANAGEMENT, {
         method: "put",
@@ -320,6 +373,6 @@ export function tenantRoutes(api) {
         responses: { 200: json(HostModelView, "The model now in force") },
     }, async (c) => {
         const ctx = c.env.tenant;
-        return jsonResponse(200, await ctx.keys.selectHostModel(SelectHostModelRequestSchema.parse(await readJson(c.req.raw))));
+        return jsonResponse(200, await ctx.keys.selectHostModel(SelectHostModelRequestSchema.parse(await readJson(c))));
     });
 }

package/dist/api/inbound-files.d.ts

@@ -11,13 +11,6 @@
 import type { MessagePart } from "@nylorun/core/contracts";
 import { type ArtifactAccess } from "../artifacts/service.js";
 import type { TenantContext } from "../tenant/context.js";
-/** The largest file a message may carry inline, decoded. */
-export declare const INLINE_FILE_MAX_BYTES: number;
-/**
- * The request body of an endpoint that takes inline files: one file at the cap, base64-encoded
- * (a third larger), and the rest of the request.
- */
-export declare const INLINE_BODY_MAX_BYTES: number;
 /** A file sent inline: its name, declared media type and base64 bytes. */
 export interface InlineFile {
     readonly name: string;
@@ -40,8 +33,9 @@ export declare function refuseUrl(): never;
 /** A name for a file its client did not name: its place in the message and its type's extension. */
 export declare function inlineFileName(mediaType: string, index: number): string;
 /**
- * Stores `file` as a new artifact of `sessionId`, within the inline cap and the Tenant's
- * artifact limits: `400` for bad base64 or a bad media type, `413 limit_exceeded` past a limit.
+ * Stores `file` as a new artifact of `sessionId`, within the Tenant's Runtime limit
+ * `inlineFileBytes` (read for the file) and its artifact limits: `400` for bad base64 or a bad
+ * media type, `413 limit_exceeded` past a limit.
  */
 export declare function storeInlineFile(ctx: TenantContext, sessionId: string, file: InlineFile, access: ArtifactAccess): Promise<{
     artifactId: string;

package/dist/api/inbound-files.js

@@ -1,15 +1,8 @@
-import { MAX_MESSAGE_PARTS } from "@nylorun/core/contracts";
 import { commandKey } from "../core/flow-host.js";
-import { extensionFor, normalizeContentType } from "../artifacts/media-types.js";
+import { extensionFor, normalizeContentType } from "@nylorun/core/contracts";
 import { deleteArtifact, uploadArtifact } from "../artifacts/service.js";
 import { fail } from "../tenant/http.js";
-/** The largest file a message may carry inline, decoded. */
-export const INLINE_FILE_MAX_BYTES = 20 * 1024 * 1024;
-/**
- * The request body of an endpoint that takes inline files: one file at the cap, base64-encoded
- * (a third larger), and the rest of the request.
- */
-export const INLINE_BODY_MAX_BYTES = 28 * 1024 * 1024;
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 const BASE64 = /^[A-Za-z0-9+/_-]*={0,2}$/;
 /** The 400 for a file sent by URL. */
 export function refuseUrl() {
@@ -23,26 +16,26 @@ export function inlineFileName(mediaType, index) {
     return `file-${index + 1}${extension ? `.${extension}` : ""}`;
 }
 /**
- * Stores `file` as a new artifact of `sessionId`, within the inline cap and the Tenant's
- * artifact limits: `400` for bad base64 or a bad media type, `413 limit_exceeded` past a limit.
+ * Stores `file` as a new artifact of `sessionId`, within the Tenant's Runtime limit
+ * `inlineFileBytes` (read for the file) and its artifact limits: `400` for bad base64 or a bad
+ * media type, `413 limit_exceeded` past a limit.
  */
 export async function storeInlineFile(ctx, sessionId, file, access) {
     const data = file.data.replace(/\s+/gu, "");
     if (!BASE64.test(data) || data.length % 4 === 1)
         fail(400, `File "${file.name}" is not valid base64`, { code: "invalid_request" });
-    // Three bytes per four characters, before decoding a byte.
-    if (Math.floor((data.length * 3) / 4) > INLINE_FILE_MAX_BYTES + 2)
-        fail(413, `A file sent inline may hold at most ${INLINE_FILE_MAX_BYTES} bytes`, {
-            code: "limit_exceeded",
-            details: { limitBytes: INLINE_FILE_MAX_BYTES },
-        });
+    const { inlineFileBytes } = await ctx.store.tx((t) => readRuntimeLimits(t));
+    const tooLarge = () => fail(413, `A file sent inline may hold at most ${inlineFileBytes} bytes (the Runtime limit inlineFileBytes)`, {
+        code: "limit_exceeded",
+        details: { limitBytes: inlineFileBytes },
+    });
+    // Three bytes per four characters, before decoding a byte; padding may take up to two.
+    if (Math.floor((data.length * 3) / 4) > inlineFileBytes + 2)
+        tooLarge();
     // Node's base64 decoder reads both alphabets.
     const bytes = Buffer.from(data, "base64");
-    if (bytes.byteLength > INLINE_FILE_MAX_BYTES)
-        fail(413, `A file sent inline may hold at most ${INLINE_FILE_MAX_BYTES} bytes`, {
-            code: "limit_exceeded",
-            details: { limitBytes: INLINE_FILE_MAX_BYTES },
-        });
+    if (bytes.byteLength > inlineFileBytes)
+        tooLarge();
     if (bytes.byteLength === 0)
         fail(400, `File "${file.name}" is empty`, { code: "invalid_request" });
     const contentType = normalizeContentType(file.mediaType) ??
@@ -73,8 +66,9 @@ export async function priorParts(ctx, sessionId, idempotencyKey) {
  */
 export async function messageParts(ctx, sessionId, idempotencyKey, inbound, access) {
     const parts = inbound.filter((part) => part.type !== "text" || part.text !== "");
-    if (parts.length > MAX_MESSAGE_PARTS)
-        fail(400, `A message may carry at most ${MAX_MESSAGE_PARTS} parts`, { code: "invalid_request" });
+    const { messageParts: most } = await ctx.store.tx((t) => readRuntimeLimits(t));
+    if (parts.length > most)
+        fail(400, `A message may carry at most ${most} parts (the Runtime limit messageParts)`, { code: "invalid_request" });
     const prior = parts.some((part) => part.type === "inline")
         ? (await priorParts(ctx, sessionId, idempotencyKey))?.filter((part) => part.type === "file")
         : undefined;

package/dist/api/openapi.js

@@ -118,7 +118,7 @@ const RUNTIME_TAGS = [
     {
         name: "Definition files",
         group: "Agents",
-        description: "The files a definition names by the SHA-256 of their bytes (each skill's folder): upload each once before putting the definition, which is refused while it names one the Runtime does not hold (`definition_files_missing`). `saveAgent` in `@nylorun/agents` does both.",
+        description: "The files a definition names by the SHA-256 of their bytes (each skill's folder): upload each once before putting the definition, which is refused while it names one the Runtime does not hold (`definition_files_missing`) or a skill whose files hold more than the Tenant's skill limit together (`limit_exceeded`; `/v1/tenant/skills`, default 2 GiB). No file and no count of files has a limit of its own. `saveAgent` in `@nylorun/agents` does both.",
         operations: ["PUT /v1/files/{file}", "HEAD /v1/files/{file}"],
     },
     {
@@ -285,12 +285,16 @@ const MANAGEMENT_TAGS = [
     },
     {
         name: "Settings",
-        description: "The Tenant's sandbox backend, Environment and artifact settings. `admin.settings`.",
+        description: "The Tenant's sandbox backend, Environment, artifact and skill settings, and its Runtime limits. `admin.settings`.",
         operations: [
             "GET /v1/tenant/sandbox",
             "PUT /v1/tenant/sandbox",
             "GET /v1/tenant/artifacts",
             "PUT /v1/tenant/artifacts",
+            "GET /v1/tenant/skills",
+            "PUT /v1/tenant/skills",
+            "GET /v1/tenant/limits",
+            "PUT /v1/tenant/limits",
         ],
     },
 ];

package/dist/artifacts/disk.d.ts

@@ -2,10 +2,6 @@ import { type EnvironmentRestore, type EnvironmentSnapshot, type EnvironmentVers
 import type { Tx } from "../store/types.js";
 import type { TenantContext } from "../tenant/context.js";
 import { assertReaches } from "../tenant/environments.js";
-/** The most entries one version holds (R6 Q11). */
-export declare const DISK_MAX_ENTRIES = 200000;
-/** The most bytes one version's files hold. */
-export declare const DISK_MAX_BYTES: number;
 /** The name of an Environment's disk artifact. */
 export declare const DISK_ARTIFACT_NAME = "disk";
 /**