@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/api/components.js

@@ -5,7 +5,7 @@
  * global registry.
  */
 import { z } from "zod";
-import { EnvironmentManifestSchema, EnvironmentSecretSlotsSchema, DeleteEnvironmentManifestResponseSchema, EnvironmentManifestPlanSchema, EnvironmentManifestVersionsSchema, EnvironmentManifestViewSchema, ListEnvironmentManifestsResponseSchema, PutEnvironmentManifestRequestSchema, PutEnvironmentSecretValueRequestSchema, SaveEnvironmentManifestResponseSchema, SessionListItemSchema, ModelCallSchema, SessionPageSchema, SessionManifestViewSchema, HistoryPageSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, ModelCallExportPageSchema, EnvironmentPageSchema, ToolCallSchema, ToolCallsPageSchema, TurnTraceSchema, JwksSchema, SigningKeyListSchema, SigningKeyViewSchema, RotateSigningKeysRequestSchema, RevokeSigningKeyRequestSchema, MeResponseSchema, TenantStatusSchema, ResetTenantRequestSchema, ResetTenantResponseSchema, SeedTenantConfigRequestSchema, SeedTenantConfigResponseSchema, HostModelCatalogSchema, TenantSandboxViewSchema, ModelUsageTotalsSchema, ModelBudgetsSchema, PutModelBudgetsRequestSchema, ToolPolicySchema, PutToolPolicyRequestSchema, PutModelInputsRequestSchema, ModelInputsViewSchema, PutTenantEnvironmentsRequestSchema, ListProvidersResponseSchema, HostModelViewSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, PutEnvironmentSecretRequestSchema, EnvironmentSecretViewSchema, ListEnvironmentSecretsResponseSchema, McpPreviewRequestSchema, McpPreviewSchema, CredentialCoverageRequestSchema, CredentialCoverageSchema, DeletedResponseSchema, ListAgentsResponseSchema, ListPublicAgentsResponseSchema, ListSessionsResponseSchema, LiveEventSchema, PutAgentRequestSchema, PutAgentResponseSchema, PutSessionRequestSchema, SessionItemsResponseSchema, SessionViewSchema, StreamClosedFrameSchema, AcceptedResponseSchema, SandboxToolOutcomeSchema, PutEnvironmentRequestSchema, EnvironmentViewSchema, EnvironmentSnapshotSchema, RestoreEnvironmentRequestSchema, ForkEnvironmentRequestSchema, EnvironmentForkPlanSchema, ForkEnvironmentResponseSchema, EnvironmentRestoreSchema, EnvironmentVersionsSchema, ListEnvironmentsResponseSchema, DeleteEnvironmentResponseSchema, ListEnvironmentEventsResponseSchema, ArtifactViewSchema, ArtifactListItemSchema, ArtifactPageSchema, ArtifactVersionViewSchema, ListArtifactsResponseSchema, UploadArtifactResponseSchema, DefinitionFileViewSchema, DeleteArtifactResponseSchema, CreateArtifactLinkRequestSchema, ArtifactLinkSchema, PutTenantArtifactsRequestSchema, TenantArtifactsViewSchema, ArtifactTreeSchema, ArtifactDiffSchema, SessionCommandSchema, ListOperatorKeysResponseSchema, PutOperatorKeyResponseSchema, DeleteOperatorKeyResponseSchema, OperatorKeySchema, ProtocolRejectedResponseSchema, RejectedResponseSchema, EVENT_SCHEMAS, EVENT_TYPES, } from "@nylorun/core/contracts";
+import { QueuedResponseSchema, TriggerListSchema, MemoryListSchema, MemorySchema, PutMemoryRequestSchema, MemoryVersionPageSchema, MemoryVersionDetailSchema, TriggerRunPageSchema, RunTriggerResponseSchema, WebhookSecretResponseSchema, WebhookAcceptedResponseSchema, AgentManifestV8Schema, EnvironmentSecretSlotsSchema, DeleteAgentManifestResponseSchema, AgentManifestPlanSchema, AgentManifestVersionsSchema, AgentManifestViewSchema, ListAgentManifestsResponseSchema, PutAgentManifestRequestSchema, PutAgentSecretValueRequestSchema, SaveAgentManifestResponseSchema, SessionListItemSchema, ModelCallSchema, SessionPageSchema, SessionManifestViewSchema, HistoryPageSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, ModelCallExportPageSchema, AgentPageSchema, ToolCallSchema, ToolCallsPageSchema, TurnTraceSchema, JwksSchema, SigningKeyListSchema, SigningKeyViewSchema, RotateSigningKeysRequestSchema, RevokeSigningKeyRequestSchema, MeResponseSchema, TenantStatusSchema, ResetTenantRequestSchema, ResetTenantResponseSchema, SeedTenantConfigRequestSchema, SeedTenantConfigResponseSchema, HostModelCatalogSchema, TenantSandboxViewSchema, ModelUsageTotalsSchema, ModelBudgetsSchema, PutModelBudgetsRequestSchema, ToolPolicySchema, PutToolPolicyRequestSchema, PutModelInputsRequestSchema, ModelInputsViewSchema, PutTenantEnvironmentsRequestSchema, ListProvidersResponseSchema, HostModelViewSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, PutAgentSecretRequestSchema, AgentSecretViewSchema, ListAgentSecretsResponseSchema, McpPreviewRequestSchema, McpPreviewSchema, CredentialCoverageRequestSchema, CredentialCoverageSchema, DeletedResponseSchema, ListSessionsResponseSchema, LiveEventSchema, PutAgentRequestSchema, PutSessionRequestSchema, SessionItemsResponseSchema, SessionViewSchema, StreamClosedFrameSchema, AcceptedResponseSchema, SandboxToolOutcomeSchema, AgentViewSchema, AgentSnapshotSchema, RestoreAgentRequestSchema, ForkAgentRequestSchema, AgentForkPlanSchema, ForkAgentResponseSchema, PutAgentDryRunResponseSchema, RestartAgentRequestSchema, AgentRestoreSchema, AgentDiskVersionsSchema, ListAgentsResponseSchema, DeleteAgentResponseSchema, ListAgentEventsResponseSchema, ArtifactViewSchema, ArtifactListItemSchema, ArtifactPageSchema, ArtifactVersionViewSchema, ListArtifactsResponseSchema, UploadArtifactResponseSchema, DefinitionFileViewSchema, DeleteArtifactResponseSchema, CreateArtifactLinkRequestSchema, ArtifactLinkSchema, PutTenantArtifactsRequestSchema, PutTenantSkillsRequestSchema, PutTenantLimitsRequestSchema, TenantLimitsViewSchema, TenantArtifactsViewSchema, TenantSkillsViewSchema, ArtifactTreeSchema, ArtifactDiffSchema, SessionCommandSchema, ListOperatorKeysResponseSchema, PutOperatorKeyResponseSchema, DeleteOperatorKeyResponseSchema, OperatorKeySchema, ProtocolRejectedResponseSchema, RejectedResponseSchema, EVENT_SCHEMAS, EVENT_TYPES, } from "@nylorun/core/contracts";
 function named(id, schema) {
     return schema.meta({ id });
 }
@@ -16,28 +16,30 @@ export const ListOperatorKeysResponse = named("ListOperatorKeysResponse", ListOp
 export const PutOperatorKeyResponse = named("PutOperatorKeyResponse", PutOperatorKeyResponseSchema);
 export const DeleteOperatorKeyResponse = named("DeleteOperatorKeyResponse", DeleteOperatorKeyResponseSchema);
 export const SandboxToolOutcome = named("SandboxToolOutcome", SandboxToolOutcomeSchema);
-export const PutEnvironmentRequest = named("PutEnvironmentRequest", PutEnvironmentRequestSchema);
-export const EnvironmentView = named("EnvironmentView", EnvironmentViewSchema);
+export const PutAgentRequest = named("PutAgentRequest", PutAgentRequestSchema);
+export const AgentView = named("AgentView", AgentViewSchema);
 export const EnvironmentSecretSlots = named("EnvironmentSecretSlots", EnvironmentSecretSlotsSchema);
-export const EnvironmentManifest = named("EnvironmentManifest", EnvironmentManifestSchema);
-export const PutEnvironmentManifestRequest = named("PutEnvironmentManifestRequest", PutEnvironmentManifestRequestSchema);
-export const EnvironmentManifestView = named("EnvironmentManifestView", EnvironmentManifestViewSchema);
-export const EnvironmentManifestPlan = named("EnvironmentManifestPlan", EnvironmentManifestPlanSchema);
-export const SaveEnvironmentManifestResponse = named("SaveEnvironmentManifestResponse", SaveEnvironmentManifestResponseSchema);
-export const ListEnvironmentManifestsResponse = named("ListEnvironmentManifestsResponse", ListEnvironmentManifestsResponseSchema);
-export const EnvironmentManifestVersions = named("EnvironmentManifestVersions", EnvironmentManifestVersionsSchema);
-export const DeleteEnvironmentManifestResponse = named("DeleteEnvironmentManifestResponse", DeleteEnvironmentManifestResponseSchema);
-export const PutEnvironmentSecretValueRequest = named("PutEnvironmentSecretValueRequest", PutEnvironmentSecretValueRequestSchema);
-export const EnvironmentSnapshot = named("EnvironmentSnapshot", EnvironmentSnapshotSchema);
-export const RestoreEnvironmentRequest = named("RestoreEnvironmentRequest", RestoreEnvironmentRequestSchema);
-export const EnvironmentRestore = named("EnvironmentRestore", EnvironmentRestoreSchema);
-export const ForkEnvironmentRequest = named("ForkEnvironmentRequest", ForkEnvironmentRequestSchema);
-export const EnvironmentForkPlan = named("EnvironmentForkPlan", EnvironmentForkPlanSchema);
-export const ForkEnvironmentResponse = named("ForkEnvironmentResponse", ForkEnvironmentResponseSchema);
-export const EnvironmentVersions = named("EnvironmentVersions", EnvironmentVersionsSchema);
-export const ListEnvironmentsResponse = named("ListEnvironmentsResponse", ListEnvironmentsResponseSchema);
-export const DeleteEnvironmentResponse = named("DeleteEnvironmentResponse", DeleteEnvironmentResponseSchema);
-export const ListEnvironmentEventsResponse = named("ListEnvironmentEventsResponse", ListEnvironmentEventsResponseSchema);
+export const AgentManifest = named("AgentManifest", AgentManifestV8Schema);
+export const PutAgentManifestRequest = named("PutAgentManifestRequest", PutAgentManifestRequestSchema);
+export const AgentManifestView = named("AgentManifestView", AgentManifestViewSchema);
+export const AgentManifestPlan = named("AgentManifestPlan", AgentManifestPlanSchema);
+export const SaveAgentManifestResponse = named("SaveAgentManifestResponse", SaveAgentManifestResponseSchema);
+export const ListAgentManifestsResponse = named("ListAgentManifestsResponse", ListAgentManifestsResponseSchema);
+export const AgentManifestVersions = named("AgentManifestVersions", AgentManifestVersionsSchema);
+export const DeleteAgentManifestResponse = named("DeleteAgentManifestResponse", DeleteAgentManifestResponseSchema);
+export const PutAgentSecretValueRequest = named("PutAgentSecretValueRequest", PutAgentSecretValueRequestSchema);
+export const AgentSnapshot = named("AgentSnapshot", AgentSnapshotSchema);
+export const RestoreAgentRequest = named("RestoreAgentRequest", RestoreAgentRequestSchema);
+export const AgentRestore = named("AgentRestore", AgentRestoreSchema);
+export const ForkAgentRequest = named("ForkAgentRequest", ForkAgentRequestSchema);
+export const AgentForkPlan = named("AgentForkPlan", AgentForkPlanSchema);
+export const ForkAgentResponse = named("ForkAgentResponse", ForkAgentResponseSchema);
+export const PutAgentDryRunResponse = named("PutAgentDryRunResponse", PutAgentDryRunResponseSchema);
+export const RestartAgentRequest = named("RestartAgentRequest", RestartAgentRequestSchema);
+export const AgentDiskVersions = named("AgentDiskVersions", AgentDiskVersionsSchema);
+export const ListAgentsResponse = named("ListAgentsResponse", ListAgentsResponseSchema);
+export const DeleteAgentResponse = named("DeleteAgentResponse", DeleteAgentResponseSchema);
+export const ListAgentEventsResponse = named("ListAgentEventsResponse", ListAgentEventsResponseSchema);
 export const ArtifactVersionView = named("ArtifactVersionView", ArtifactVersionViewSchema);
 export const ArtifactView = named("ArtifactView", ArtifactViewSchema);
 export const ArtifactListItem = named("ArtifactListItem", ArtifactListItemSchema);
@@ -50,14 +52,25 @@ export const CreateArtifactLinkRequest = named("CreateArtifactLinkRequest", Crea
 export const ArtifactLink = named("ArtifactLink", ArtifactLinkSchema);
 export const PutTenantArtifactsRequest = named("PutTenantArtifactsRequest", PutTenantArtifactsRequestSchema);
 export const TenantArtifactsView = named("TenantArtifactsView", TenantArtifactsViewSchema);
+export const PutTenantSkillsRequest = named("PutTenantSkillsRequest", PutTenantSkillsRequestSchema);
+export const TenantSkillsView = named("TenantSkillsView", TenantSkillsViewSchema);
+export const PutTenantLimitsRequest = named("PutTenantLimitsRequest", PutTenantLimitsRequestSchema);
+export const TenantLimitsView = named("TenantLimitsView", TenantLimitsViewSchema);
 export const ArtifactTree = named("ArtifactTree", ArtifactTreeSchema);
 export const ArtifactDiff = named("ArtifactDiff", ArtifactDiffSchema);
 export const SessionCommand = named("SessionCommand", SessionCommandSchema);
 export const AcceptedResponse = named("AcceptedResponse", AcceptedResponseSchema);
-export const ListAgentsResponse = named("ListAgentsResponse", ListAgentsResponseSchema);
-export const ListPublicAgentsResponse = named("ListPublicAgentsResponse", ListPublicAgentsResponseSchema);
-export const PutAgentRequest = named("PutAgentRequest", PutAgentRequestSchema);
-export const PutAgentResponse = named("PutAgentResponse", PutAgentResponseSchema);
+export const QueuedResponse = named("QueuedResponse", QueuedResponseSchema);
+export const TriggerList = named("TriggerList", TriggerListSchema);
+export const MemoryList = named("MemoryList", MemoryListSchema);
+export const MemoryView = named("Memory", MemorySchema);
+export const PutMemoryRequest = named("PutMemoryRequest", PutMemoryRequestSchema);
+export const MemoryVersionPage = named("MemoryVersionPage", MemoryVersionPageSchema);
+export const MemoryVersionDetail = named("MemoryVersionDetail", MemoryVersionDetailSchema);
+export const TriggerRunPage = named("TriggerRunPage", TriggerRunPageSchema);
+export const RunTriggerResponse = named("RunTriggerResponse", RunTriggerResponseSchema);
+export const WebhookSecretResponse = named("WebhookSecretResponse", WebhookSecretResponseSchema);
+export const WebhookAcceptedResponse = named("WebhookAcceptedResponse", WebhookAcceptedResponseSchema);
 export const ListSessionsResponse = named("ListSessionsResponse", ListSessionsResponseSchema);
 export const PutSessionRequest = named("PutSessionRequest", PutSessionRequestSchema);
 export const SessionView = named("SessionView", SessionViewSchema);
@@ -92,9 +105,9 @@ export const ListProvidersResponse = named("ListProvidersResponse", ListProvider
 export const HostModelView = named("HostModelView", HostModelViewSchema);
 export const PutHostModelRequest = named("PutHostModelRequest", PutHostModelRequestSchema);
 export const SelectHostModelRequest = named("SelectHostModelRequest", SelectHostModelRequestSchema);
-export const PutEnvironmentSecretRequest = named("PutEnvironmentSecretRequest", PutEnvironmentSecretRequestSchema);
-export const EnvironmentSecretView = named("EnvironmentSecretView", EnvironmentSecretViewSchema);
-export const ListEnvironmentSecretsResponse = named("ListEnvironmentSecretsResponse", ListEnvironmentSecretsResponseSchema);
+export const PutAgentSecretRequest = named("PutAgentSecretRequest", PutAgentSecretRequestSchema);
+export const AgentSecretView = named("AgentSecretView", AgentSecretViewSchema);
+export const ListAgentSecretsResponse = named("ListAgentSecretsResponse", ListAgentSecretsResponseSchema);
 export const DeletedResponse = named("DeletedResponse", DeletedResponseSchema);
 export const McpPreviewRequest = named("McpPreviewRequest", McpPreviewRequestSchema);
 export const McpPreview = named("McpPreview", McpPreviewSchema);
@@ -113,7 +126,7 @@ export const HistoryPage = named("HistoryPage", HistoryPageSchema.extend({ items
 export const SessionUsageTotals = named("SessionUsageTotals", SessionUsageTotalsSchema);
 export const ModelCallsPage = named("ModelCallsPage", ModelCallsPageSchema.extend({ calls: z.array(ModelCall) }));
 export const ModelCallExportPage = named("ModelCallExportPage", ModelCallExportPageSchema.extend({ calls: z.array(ModelCall) }));
-export const EnvironmentPage = named("EnvironmentPage", EnvironmentPageSchema.extend({ environments: z.array(EnvironmentView) }));
+export const AgentPage = named("AgentPage", AgentPageSchema.extend({ environments: z.array(AgentView) }));
 export const ToolCall = named("ToolCall", ToolCallSchema);
 export const ToolCallsPage = named("ToolCallsPage", ToolCallsPageSchema.extend({ calls: z.array(ToolCall) }));
 export const TurnTrace = named("TurnTrace", TurnTraceSchema);

package/dist/api/gate/keys.js

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

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

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

package/dist/api/gate/routes.js

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

package/dist/api/http/app.js

@@ -12,8 +12,10 @@ import { declaredRoute, pathSegments, routeNotFound } from "./define.js";
 import { jsonResponse, rejectionOf } from "./respond.js";
 import { accessRoutes } from "./routes/access.js";
 import { meRoutes } from "./routes/me.js";
-import { environmentRoutes } from "./routes/environments.js";
-import { environmentManifestRoutes } from "./routes/environment-manifests.js";
+import { agentRoutes } from "./routes/agents.js";
+import { triggerRoutes, webhookRoutes } from "./routes/triggers.js";
+import { memoryRoutes } from "./routes/memories.js";
+import { agentManifestRoutes } from "./routes/agent-manifests.js";
 import { artifactRoutes } from "./routes/artifacts.js";
 import { readRoutes } from "./routes/reads.js";
 import { sessionRoutes } from "./routes/sessions.js";
@@ -45,8 +47,11 @@ function build() {
     });
     sessionRoutes(api);
     fileRoutes(api);
-    environmentRoutes(api);
-    environmentManifestRoutes(api);
+    agentRoutes(api);
+    triggerRoutes(api);
+    memoryRoutes(api);
+    webhookRoutes(api);
+    agentManifestRoutes(api);
     artifactRoutes(api);
     tenantRoutes(api);
     keyRoutes(api);

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

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

package/dist/api/http/body.js

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

package/dist/api/http/respond.js

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

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

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

package/dist/api/http/routes/agent-manifests.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Agent manifests (`/v1/agent-manifests/**`, protocol 16): save, read, list and delete the named,
+ * versioned documents Agents are made from, each with a harness and a runtime section. A save
+ * never changes an Agent. Reading needs `agents:read` (or a write scope), saving and deleting
+ * `agent-manifests:write`, from any client (Q12). A token caller reaches none: a manifest holds
+ * an agent's instructions, tools and servers.
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function agentManifestRoutes(api: OpenAPIHono<TenantEnv>): void;

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

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { isAgentManifestName, PutAgentManifestRequestSchema } from "@nylorun/core/contracts";
+import { AgentManifestPlan, AgentManifestVersions, AgentManifestView, DeleteAgentManifestResponse, ListAgentManifestsResponse, PutAgentManifestRequest, SaveAgentManifestResponse, } from "../../components.js";
+import { requirePrincipal } from "../../../tenant/auth.js";
+import { fail } from "../../../tenant/http.js";
+import { agentManifestVersions, deleteAgentManifest, getAgentManifest, listAgentManifests, saveAgentManifest, } from "../../../tenant/agent-manifests.js";
+import { readJson } from "../body.js";
+import { tenantRoute } from "../define.js";
+import { jsonResponse } from "../respond.js";
+const READ = {
+    credentials: ["application", "subject"],
+    scopes: ["agents:read", "agents:write", "agent-manifests:write"],
+};
+const WRITE = {
+    credentials: ["application", "subject"],
+    scopes: ["agent-manifests:write"],
+};
+const json = (schema, description) => ({
+    description,
+    content: { "application/json": { schema } },
+});
+const namePath = z.object({
+    name: z.string().meta({ description: "The agent manifest's name, such as `triage`" }),
+});
+function nameOf(value) {
+    if (!isAgentManifestName(value))
+        return fail(400, "An agent manifest's name is 1-64 letters, digits, '.', '_' and '-', starting with a letter or digit");
+    return value;
+}
+function versionOf(value) {
+    const version = Number(value);
+    if (!Number.isInteger(version) || version < 1)
+        return fail(400, "version is a positive integer");
+    return version;
+}
+/** `If-Match: <version>` (or `"<version>"`), when sent. */
+function ifMatchOf(value) {
+    if (value === undefined || value.trim() === "")
+        return undefined;
+    const version = Number(value.trim().replace(/^W\//, "").replace(/^"|"$/g, ""));
+    if (!Number.isInteger(version) || version < 0)
+        return fail(400, "If-Match is the version you read: a whole number, 0 for none yet");
+    return version;
+}
+export function agentManifestRoutes(api) {
+    tenantRoute(api, READ, {
+        method: "get",
+        path: "/v1/agent-manifests",
+        tags: ["Agent manifests"],
+        summary: "List agent manifests",
+        description: "Each manifest's latest version, by name, with how many Agents were made from it.",
+        responses: { 200: json(ListAgentManifestsResponse, "The manifests") },
+    }, async (c) => {
+        requirePrincipal(c.get("scope"));
+        return jsonResponse(200, await listAgentManifests(c.env.tenant));
+    });
+    tenantRoute(api, WRITE, {
+        method: "put",
+        path: "/v1/agent-manifests/{name}",
+        tags: ["Agent manifests"],
+        summary: "Save an agent manifest",
+        description: "Saves the manifest as its next version, or answers the latest unchanged when nothing differs. Every Agent that tracks the manifest moves to the new version (track T3): at once, at its pod's next start for a runtime change a pod applies only when it starts, or once a required secret the version adds is set; a pinned one stays, and so does one whose kind, harness or storage the version changes (`agents_behind`). The Runtime checks the harness and runtime sections against each other: a custom harness needs a pod with an image, every credential the harness names is a declared slot of the right type, and the runtime's kind gives the loop the sandbox it needs; every gap is named in one `422 manifest_inconsistent` (`details.gaps`). `If-Match: <version>` refuses the save with `412 manifest_changed` when the latest version is no longer the one you read (`0` for a manifest that does not exist yet). With `?dryRun=true` the answer is the plan: the changes by section, every reason a save would be refused (`errors`, the gaps first), warnings, the Agents it would move (`moves`) and how many stay on older versions (`behind`); nothing is saved. Clients compose the authoring files and drop their `$schema` before they send one document.",
+        request: {
+            params: namePath,
+            query: z.object({
+                dryRun: z.enum(["true", "false"]).optional().meta({ description: "`true`: answer the plan and save nothing" }),
+            }),
+            body: { required: true, content: { "application/json": { schema: PutAgentManifestRequest } } },
+        },
+        responses: {
+            200: json(z.union([SaveAgentManifestResponse, AgentManifestPlan]), "The version saved, or the plan with dryRun"),
+            400: {
+                description: "The manifest breaks the Tenant's limits, has a tool that runs code, or names files the Runtime does not hold (`definition_files_missing`)",
+            },
+            412: { description: "If-Match named a version that is no longer the latest (`manifest_changed`)" },
+            413: { description: "A skill's files hold more than the manifest's skill limit together (`limit_exceeded`)" },
+            422: { description: "The harness and runtime sections do not fit (`manifest_inconsistent`, `details.gaps`)" },
+        },
+    }, async (c) => {
+        const name = nameOf(c.req.param("name"));
+        const body = PutAgentManifestRequestSchema.parse(await readJson(c));
+        const ifMatch = ifMatchOf(c.req.header("if-match"));
+        const options = ifMatch === undefined ? {} : { ifMatch };
+        return jsonResponse(200, c.req.query("dryRun") === "true"
+            ? await saveAgentManifest(c.env.tenant, name, body, c.get("scope"), { ...options, dryRun: true })
+            : await saveAgentManifest(c.env.tenant, name, body, c.get("scope"), options));
+    });
+    tenantRoute(api, READ, {
+        method: "get",
+        path: "/v1/agent-manifests/{name}",
+        tags: ["Agent manifests"],
+        summary: "Get an agent manifest",
+        description: "Its latest version.",
+        request: { params: namePath },
+        responses: { 200: json(AgentManifestView, "The latest version") },
+    }, async (c) => {
+        requirePrincipal(c.get("scope"));
+        return jsonResponse(200, await getAgentManifest(c.env.tenant, nameOf(c.req.param("name"))));
+    });
+    tenantRoute(api, READ, {
+        method: "get",
+        path: "/v1/agent-manifests/{name}/versions",
+        tags: ["Agent manifests"],
+        summary: "List an agent manifest's versions",
+        description: "Every version, newest first, with who saved it and how many Agents were made from it.",
+        request: { params: namePath },
+        responses: { 200: json(AgentManifestVersions, "The versions") },
+    }, async (c) => {
+        requirePrincipal(c.get("scope"));
+        return jsonResponse(200, await agentManifestVersions(c.env.tenant, nameOf(c.req.param("name"))));
+    });
+    tenantRoute(api, READ, {
+        method: "get",
+        path: "/v1/agent-manifests/{name}/versions/{version}",
+        tags: ["Agent manifests"],
+        summary: "Get one version of an agent manifest",
+        request: { params: namePath.extend({ version: z.string().meta({ description: "The version number" }) }) },
+        responses: { 200: json(AgentManifestView, "The version") },
+    }, async (c) => {
+        requirePrincipal(c.get("scope"));
+        return jsonResponse(200, await getAgentManifest(c.env.tenant, nameOf(c.req.param("name")), versionOf(c.req.param("version"))));
+    });
+    tenantRoute(api, WRITE, {
+        method: "delete",
+        path: "/v1/agent-manifests/{name}",
+        tags: ["Agent manifests"],
+        summary: "Delete an agent manifest",
+        description: "Deletes every version. Refused while any Agent was made from one (`409 manifest_in_use`).",
+        request: { params: namePath },
+        responses: {
+            200: json(DeleteAgentManifestResponse, "Deleted, or there was none"),
+            409: { description: "An Agent was made from one of its versions (`manifest_in_use`)" },
+        },
+    }, async (c) => jsonResponse(200, await deleteAgentManifest(c.env.tenant, nameOf(c.req.param("name")))));
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Agents (`/v1/agents/**`, protocol 16; Environments from protocol 11, D55, D56): make one from a
+ * saved agent manifest or find it by id, read it, list them by label, state or manifest, read its
+ * lifecycle stream, stop, reset, fork and delete it, work its disk versions, and write its vault's
+ * secrets. Ids may hold `/`, sent percent-encoded as one path segment (`users%2Falice%2Ftriage`).
+ * A token caller reaches only the ids its Agent grants match, and changes them only with
+ * `agents:write`. Secret values are write-only: no route reads one back.
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function agentRoutes(api: OpenAPIHono<TenantEnv>): void;