@nylorun/runtime 0.25.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",
@@ -121,7 +121,7 @@ export function sessionRoutes(api) {
         path: "/v1/sessions/{sessionId}",
         tags: ["Sessions"],
         summary: "Open a session",
-        description: "Creates the session, or re-attaches vaults to an identical one. Its sandbox is chosen now and fixed for its life.",
+        description: "Creates the session, or answers the one already opened with the same agent, owner, info and Environment. Its Environment (its sandbox and vault) is chosen now and fixed for its life.",
         request: { params: sessionId, body: body(PutSessionRequest) },
         responses: {
             200: json(SessionView, "The session"),
@@ -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";
 /**