@nylorun/runtime 0.26.0-beta → 0.28.0-beta

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";
@@ -17,9 +18,15 @@ import { tenantReset, streamsStatus, } from "../../../tenant/streams.js";
 import { readJson } from "../body.js";
 import { pathSegments, tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
-import { rearmPodTimers } from "../../../tenant/environments.js";
+import { rearmPodTimers } from "../../../tenant/agents.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 } },
@@ -30,7 +37,7 @@ const body = (schema) => ({
 });
 const budgetRow = (budget, updatedAt) => ({
     scope: budget.scope,
-    scopeId: budget.scope === "agent" ? budget.id : "*",
+    scopeId: budget.scope === "manifest" ? budget.id : "*",
     period: budget.period ?? null,
     limitUsd: budget.limitUsd ?? null,
     limitTokens: budget.limitTokens ?? null,
@@ -38,7 +45,7 @@ const budgetRow = (budget, updatedAt) => ({
 });
 const budgetView = (row) => ({
     scope: row.scope,
-    ...(row.scope === "agent" ? { id: row.scopeId } : {}),
+    ...(row.scope === "manifest" ? { id: row.scopeId } : {}),
     ...(row.period ? { period: row.period } : {}),
     ...(row.limitUsd !== null ? { limitUsd: row.limitUsd } : {}),
     ...(row.limitTokens !== null ? { limitTokens: row.limitTokens } : {}),
@@ -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 } : {}),
@@ -107,16 +114,16 @@ export function tenantRoutes(api) {
         path: "/v1/tenant/reset",
         tags: ["Tenant"],
         summary: "Reset the Tenant",
-        description: "Deletes its sessions, its Environments (with their vaults), or both, after draining or cancelling the turns in progress. The Tenant stays open.",
+        description: "Deletes its sessions, its Agents (with their vaults), or both, after draining or cancelling the turns in progress. The Tenant stays open.",
         request: { body: body(ResetTenantRequest) },
         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";
+        const sessionsReset = request.scope !== "agents";
         await resetTenant({
             store: ctx.store,
             sandbox: ctx.sandbox,
@@ -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,24 +190,51 @@ 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",
         tags: ["Tenant"],
-        summary: "Get the Tenant's sandbox backend and Environment settings",
+        summary: "Get the Tenant's sandbox backend and Agent compute settings",
         responses: { 200: json(TenantSandboxView, "The backend in use and the configuration in force") },
     }, async (c) => jsonResponse(200, await sandboxView(c.env.tenant)));
     tenantRoute(api, MANAGEMENT, {
         method: "put",
         path: "/v1/tenant/sandbox",
         tags: ["Tenant"],
-        summary: "Set the Tenant's Environment settings",
-        description: "The limits every Environment's recipe must fit, the pods' stop grace and where harnesses may run (Tenant setting `environments.config`).",
+        summary: "Set the Tenant's Agent compute settings",
+        description: "The limits every Agent's runtime must fit, the pods' stop grace and where harnesses may run (Tenant setting `environments.config`).",
         request: { body: body(PutTenantEnvironmentsRequest) },
         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/http/routes/triggers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An Agent's triggers and their runs (track T4, D74): read them, pause and resume one, run one now
+ * (keyed by `Idempotency-Key`), and page the runs; make a webhook trigger's signing secret, and
+ * take a sender's delivery at its endpoint (D75), an anonymous, unversioned route. What a trigger is lives in the Agent's manifest
+ * (`runtime.triggers`); these routes change only what the Agent owns, its status.
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function triggerRoutes(api: OpenAPIHono<TenantEnv>): void;
+export declare function webhookRoutes(api: OpenAPIHono<TenantEnv>): void;

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

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { isAgentId } from "@nylorun/core/contracts";
+import { RunTriggerResponse, TriggerList, TriggerRunPage, WebhookAcceptedResponse, WebhookSecretResponse, } from "../../components.js";
+import { assertReaches } from "../../../tenant/agents.js";
+import { fail } from "../../../tenant/http.js";
+import { listRuns, listTriggers, receiveWebhook, rotateWebhookSecret, runTriggerNow, setTriggerStatus, } from "../../../tenant/triggers.js";
+import { readRuntimeLimits } from "../../../tenant/runtime-limits.js";
+import { readBytes } from "../body.js";
+import { tenantRoute } from "../define.js";
+import { pageQuery, pageSize, parseQuery } from "./reads.js";
+import { jsonResponse } from "../respond.js";
+const READ = {
+    credentials: ["application", "subject", "token"],
+    scopes: ["sessions:own", "agents:read", "agents:write"],
+};
+const WRITE = {
+    credentials: ["application", "subject", "token"],
+    scopes: ["agents:write"],
+};
+const json = (schema, description) => ({
+    description,
+    content: { "application/json": { schema } },
+});
+const agentId = z.object({
+    agentId: z.string().meta({ description: "The Agent id, percent-encoded" }),
+});
+const triggerPath = agentId.extend({
+    triggerId: z.string().meta({ description: "The trigger's id in the manifest's `runtime.triggers`" }),
+});
+function idOf(value) {
+    if (!isAgentId(value))
+        return fail(400, "An Agent id is up to 200 characters: /-separated segments of letters, digits, '.', '_' and '-'");
+    return value;
+}
+export function triggerRoutes(api) {
+    tenantRoute(api, READ, {
+        method: "get",
+        path: "/v1/agents/{agentId}/triggers",
+        tags: ["Triggers"],
+        summary: "List an Agent's triggers",
+        description: "Each trigger its manifest declares, with what the Agent holds of it: its status (`active`, `paused` with a reason, `completed` for an `at` that ran), when it runs next and last ran.",
+        request: { params: agentId },
+        responses: { 200: json(TriggerList, "The triggers") },
+    }, async (c) => {
+        const id = idOf(c.req.param("agentId"));
+        assertReaches(c.get("scope"), id);
+        return jsonResponse(200, await listTriggers(c.env.tenant, id, originOf(c.req.url)));
+    });
+    for (const action of ["pause", "resume"])
+        tenantRoute(api, WRITE, {
+            method: "post",
+            path: `/v1/agents/{agentId}/triggers/{triggerId}/${action}`,
+            tags: ["Triggers"],
+            summary: action === "pause" ? "Pause a trigger" : "Resume a trigger",
+            description: action === "pause"
+                ? "It stops firing until it is resumed; a run already started or queued goes on."
+                : "It fires again from its next time after now; missed times are not run. An `at` whose time has passed is refused (`trigger_expired`).",
+            request: { params: triggerPath },
+            responses: {
+                200: json(TriggerList, "The Agent's triggers"),
+                409: { description: "An `at` whose time has passed (`trigger_expired`)" },
+            },
+        }, async (c) => {
+            const id = idOf(c.req.param("agentId"));
+            assertReaches(c.get("scope"), id);
+            return jsonResponse(200, await setTriggerStatus(c.env.tenant, id, c.req.param("triggerId"), action, originOf(c.req.url)));
+        });
+    tenantRoute(api, WRITE, {
+        method: "post",
+        path: "/v1/agents/{agentId}/triggers/{triggerId}/run",
+        tags: ["Triggers"],
+        summary: "Run a trigger now",
+        description: "Runs it once now, paused or not, as if it had fired: a turn on its session, or a queued message when a turn runs there. A retried request with the same `Idempotency-Key` answers the same run.",
+        request: {
+            params: triggerPath,
+            headers: z.object({ "Idempotency-Key": z.string().min(1).max(200) }),
+        },
+        responses: { 200: json(RunTriggerResponse, "The run") },
+    }, async (c) => {
+        const id = idOf(c.req.param("agentId"));
+        assertReaches(c.get("scope"), id);
+        const key = c.req.header("idempotency-key")?.trim();
+        if (!key || key.length > 200)
+            fail(400, "Idempotency-Key is required: 1-200 characters");
+        return jsonResponse(200, { run: await runTriggerNow(c.env.tenant, id, c.req.param("triggerId"), key) });
+    });
+    tenantRoute(api, READ, {
+        method: "get",
+        path: "/v1/agents/{agentId}/runs",
+        tags: ["Triggers"],
+        summary: "List an Agent's runs",
+        description: "Each time one of its triggers fired or was run by hand, newest first: when it was due, whether it was late, and what came of it (`started`, `queued`, `skipped` or `failed`, with a reason), with the session and turn.",
+        request: {
+            params: agentId,
+            query: pageQuery.extend({
+                triggerId: z.string().optional().meta({ description: "Only this trigger's runs" }),
+            }),
+        },
+        responses: { 200: json(TriggerRunPage, "A page of runs") },
+    }, async (c) => {
+        const id = idOf(c.req.param("agentId"));
+        assertReaches(c.get("scope"), id);
+        const triggerId = c.req.query("triggerId");
+        const { limit, cursor } = parseQuery(pageQuery, { limit: c.req.query("limit"), cursor: c.req.query("cursor") });
+        return jsonResponse(200, await listRuns(c.env.tenant, id, {
+            ...(triggerId ? { triggerId } : {}),
+            ...(cursor ? { cursor } : {}),
+            limit: await pageSize(c.env.tenant, limit, { fallback: 50 }),
+        }));
+    });
+}
+/** A delivery: no credential, no protocol header, any body; the endpoint id and the signature are the grant. */
+const DELIVERY = {
+    credentials: ["application", "subject", "token"],
+    scopes: "any",
+    anonymous: true,
+    unversioned: true,
+    bytes: true,
+};
+export function webhookRoutes(api) {
+    tenantRoute(api, WRITE, {
+        method: "post",
+        path: "/v1/agents/{agentId}/triggers/{triggerId}/secret",
+        tags: ["Triggers"],
+        summary: "Make a webhook trigger's signing secret",
+        description: "A new Standard Webhooks secret (`whsec_…`) for a webhook trigger, shown this once; the one before stops working at once. Give it to the sender with the trigger's `webhookUrl`.",
+        request: { params: triggerPath },
+        responses: {
+            200: json(WebhookSecretResponse, "The secret, this once"),
+            400: { description: "Not a webhook trigger" },
+        },
+    }, async (c) => {
+        const id = idOf(c.req.param("agentId"));
+        assertReaches(c.get("scope"), id);
+        return jsonResponse(200, await rotateWebhookSecret(c.env.tenant, id, c.req.param("triggerId"), originOf(c.req.url)));
+    });
+    tenantRoute(api, DELIVERY, {
+        method: "post",
+        path: "/v1/webhooks/{endpointId}",
+        tags: ["Triggers"],
+        summary: "Deliver to a webhook trigger",
+        description: "A sender's delivery, signed with Standard Webhooks (`webhook-id`, `webhook-timestamp` within 5 minutes by default, `webhook-signature`): no credential and no `Nylorun-Protocol`. The body, any media type, at most the Runtime limit `webhookBodyBytes`, is read as bytes and verified before anything else. It runs the trigger once per `webhook-id`: a retry answers the first run. The body reaches the model as data under the trigger's prompt. Other senders (GitHub, Stripe, Slack) are relayed by an app.",
+        request: {
+            params: z.object({ endpointId: z.string().meta({ description: "The trigger's endpoint id, `wh_…`" }) }),
+            headers: z.object({
+                "webhook-id": z.string().optional().meta({ description: "The delivery's id; a retry sends the same" }),
+                "webhook-timestamp": z.string().optional().meta({ description: "Seconds since the epoch" }),
+                "webhook-signature": z.string().optional().meta({ description: "`v1,<base64>`, space-separated" }),
+            }),
+            body: {
+                required: true,
+                description: "The payload, of any media type",
+                content: { "*/*": { schema: z.string().meta({ format: "binary" }) } },
+            },
+        },
+        responses: {
+            202: json(WebhookAcceptedResponse, "The run it made: started, queued, skipped or failed"),
+            401: { description: "Not signed with the endpoint's secret, or a timestamp out of tolerance" },
+            404: { description: "No endpoint has this id" },
+            409: { description: "The trigger is paused (`trigger_paused`)" },
+            413: { description: "Over `webhookBodyBytes`" },
+        },
+    }, async (c) => {
+        const tenant = c.env.tenant;
+        const { webhookBodyBytes } = await tenant.store.tx((t) => readRuntimeLimits(t));
+        const body = await readBytes(c.req.raw, webhookBodyBytes, "webhookBodyBytes");
+        const header = (name) => c.req.header(name)?.trim() || undefined;
+        return jsonResponse(202, await receiveWebhook(tenant, c.req.param("endpointId"), {
+            id: header("webhook-id"),
+            timestamp: header("webhook-timestamp"),
+            signature: header("webhook-signature"),
+            contentType: header("content-type"),
+            body,
+        }));
+    });
+}
+/** The origin a request reached: where its webhook URLs live. */
+function originOf(url) {
+    return new URL(url).origin;
+}

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;