@nylorun/runtime 0.16.0-beta → 0.19.0-beta

package/dist/tenant/endpoints.d.ts

@@ -1,67 +0,0 @@
-/**
- * Action endpoints (design: Action endpoints §4.2): where the Runtime delivers each agent's
- * Actions, registered with the application key.
- */
-import { type Endpoint, type PutEndpointsRequest } from "@nylorun/core/contracts";
-import type { EndpointRow } from "../store/types.js";
-import type { TenantContext } from "./context.js";
-/** An endpoint as the Tenant API answers it. */
-export declare function endpointView(row: EndpointRow): Endpoint;
-/** `GET /v1/endpoints`. */
-export declare function listEndpoints(ctx: TenantContext): Promise<{
-    endpoints: {
-        agentId: string;
-        url: string;
-        implementationVersion: string;
-        manifestHash?: string | undefined;
-        timeoutMs: number;
-        maxConcurrent: number;
-        health: {
-            lastDeliveryAt?: string | undefined;
-            lastSuccessAt?: string | undefined;
-            lastError?: {
-                code: string;
-                message: string;
-            } | undefined;
-            consecutiveFailures: number;
-            served?: {
-                implementationVersion: string;
-                manifestHash?: string | undefined;
-            } | undefined;
-        };
-        updatedAt: string;
-    }[];
-}>;
-/**
- * `PUT /v1/endpoints`: upsert the batch in one transaction, then send the Actions already
- * waiting for these agents. Answers every registered endpoint of the batch.
- */
-export declare function putEndpoints(ctx: TenantContext, principalId: string, body: PutEndpointsRequest): Promise<{
-    endpoints: {
-        agentId: string;
-        url: string;
-        implementationVersion: string;
-        manifestHash?: string | undefined;
-        timeoutMs: number;
-        maxConcurrent: number;
-        health: {
-            lastDeliveryAt?: string | undefined;
-            lastSuccessAt?: string | undefined;
-            lastError?: {
-                code: string;
-                message: string;
-            } | undefined;
-            consecutiveFailures: number;
-            served?: {
-                implementationVersion: string;
-                manifestHash?: string | undefined;
-            } | undefined;
-        };
-        updatedAt: string;
-    }[];
-}>;
-/** `DELETE /v1/endpoints/:agentId`. The agent's pending Actions wait for a new endpoint. */
-export declare function deleteEndpoint(ctx: TenantContext, agentId: string): Promise<{
-    agentId: string;
-    deleted: true;
-}>;

package/dist/tenant/endpoints.js

@@ -1,90 +0,0 @@
-/**
- * Action endpoints (design: Action endpoints §4.2): where the Runtime delivers each agent's
- * Actions, registered with the application key.
- */
-import { ENDPOINT_MAX_CONCURRENT_DEFAULT, ENDPOINT_TIMEOUT_DEFAULT_MS, } from "@nylorun/core/contracts";
-import { fail } from "./http.js";
-/** An endpoint as the Tenant API answers it. */
-export function endpointView(row) {
-    const served = row.servedImplementationVersion === undefined
-        ? undefined
-        : {
-            implementationVersion: row.servedImplementationVersion,
-            ...(row.servedManifestHash === undefined
-                ? {}
-                : { manifestHash: row.servedManifestHash }),
-        };
-    return {
-        agentId: row.agentId,
-        url: row.url,
-        implementationVersion: row.implementationVersion,
-        ...(row.manifestHash === undefined ? {} : { manifestHash: row.manifestHash }),
-        timeoutMs: row.timeoutMs,
-        maxConcurrent: row.maxConcurrent,
-        health: {
-            ...(row.lastDeliveryAt === undefined ? {} : { lastDeliveryAt: row.lastDeliveryAt }),
-            ...(row.lastSuccessAt === undefined ? {} : { lastSuccessAt: row.lastSuccessAt }),
-            ...(row.lastErrorCode === undefined
-                ? {}
-                : {
-                    lastError: {
-                        code: row.lastErrorCode,
-                        message: row.lastErrorMessage ?? "",
-                    },
-                }),
-            consecutiveFailures: row.consecutiveFailures,
-            ...(served ? { served } : {}),
-        },
-        updatedAt: row.updatedAt,
-    };
-}
-/** `GET /v1/endpoints`. */
-export async function listEndpoints(ctx) {
-    const rows = await ctx.store.tx((t) => t.listEndpoints());
-    return { endpoints: rows.map(endpointView) };
-}
-/**
- * `PUT /v1/endpoints`: upsert the batch in one transaction, then send the Actions already
- * waiting for these agents. Answers every registered endpoint of the batch.
- */
-export async function putEndpoints(ctx, principalId, body) {
-    const updatedAt = new Date().toISOString();
-    const rows = await ctx.store.tx(async (t) => {
-        const saved = [];
-        for (const endpoint of body.endpoints) {
-            await t.putEndpoint({
-                agentId: endpoint.agentId,
-                url: endpoint.url,
-                implementationVersion: endpoint.implementationVersion,
-                ...(endpoint.manifestHash === undefined
-                    ? {}
-                    : { manifestHash: endpoint.manifestHash }),
-                timeoutMs: endpoint.timeoutMs ?? ENDPOINT_TIMEOUT_DEFAULT_MS,
-                maxConcurrent: endpoint.maxConcurrent ?? ENDPOINT_MAX_CONCURRENT_DEFAULT,
-                principalId,
-                updatedAt,
-            });
-            saved.push((await t.getEndpoint(endpoint.agentId)));
-        }
-        return saved;
-    });
-    // Actions already waiting for these agents go to their endpoint now.
-    const waiting = await ctx.store.tx(async (t) => {
-        const actions = [];
-        for (const endpoint of body.endpoints)
-            actions.push(...(await t.pendingActions(endpoint.agentId)));
-        return actions;
-    });
-    for (const action of waiting)
-        await ctx.deliver(action.actionId);
-    return { endpoints: rows.map(endpointView) };
-}
-/** `DELETE /v1/endpoints/:agentId`. The agent's pending Actions wait for a new endpoint. */
-export async function deleteEndpoint(ctx, agentId) {
-    await ctx.store.tx(async (t) => {
-        if (!(await t.getEndpoint(agentId)))
-            fail(404, "Endpoint not found");
-        await t.deleteEndpoint(agentId);
-    });
-    return { agentId, deleted: true };
-}

package/dist/tenant/subject-limits.d.ts

@@ -1,16 +0,0 @@
-/**
- * Subject limits (Host feature `subject-tokens`): a subject token's role may cap how many turns
- * its subject starts per hour and how many run at once. Every turn spends the Tenant's model
- * budget, so these ship with the first credential that reaches the Runtime without an app
- * server in between.
- *
- * Turns per hour is a token bucket per subject (capacity `turnsPerHour`, refilled
- * continuously): no hourly rows and no burst at a window boundary. Concurrent turns counts the
- * subject's sessions with work in flight; `paused` is not counted, so an unanswered approval
- * never locks a person out. Checked inside the command's transaction, after the session row
- * lock, so one subject's messages serialize on the bucket row.
- */
-import type { RoleLimits } from "@nylorun/core/contracts";
-import type { Tx } from "../store/types.js";
-/** Charges one turn to `subject`, or answers `429 limit_exceeded`. */
-export declare function chargeTurn(t: Tx, subject: string, limits: RoleLimits, now?: number): Promise<void>;

package/dist/tenant/subject-limits.js

@@ -1,45 +0,0 @@
-import { fail } from "./http.js";
-/** Session statuses that hold a turn in flight. */
-const ACTIVE_STATUSES = ["runnable", "running", "waiting"];
-const CONCURRENT_RETRY_SECONDS = 5;
-/** Floating-point slack when a refill lands exactly on a whole turn. */
-const EPSILON = 1e-9;
-/** Charges one turn to `subject`, or answers `429 limit_exceeded`. */
-export async function chargeTurn(t, subject, limits, now = Date.now()) {
-    if (limits.concurrentTurns !== undefined) {
-        const active = await t.countOwnerSessions(subject, ACTIVE_STATUSES);
-        if (active >= limits.concurrentTurns)
-            fail(429, `At most ${limits.concurrentTurns} turns may run at once`, {
-                code: "limit_exceeded",
-                details: {
-                    limit: "concurrentTurns",
-                    retryAfterSeconds: CONCURRENT_RETRY_SECONDS,
-                },
-            }, { "retry-after": String(CONCURRENT_RETRY_SECONDS) });
-    }
-    const capacity = limits.turnsPerHour;
-    if (capacity === undefined)
-        return;
-    const perMs = capacity / 3_600_000;
-    const usage = await t.lockSubjectUsage({
-        subject,
-        turnTokens: capacity,
-        refilledAt: new Date(now).toISOString(),
-    });
-    const elapsed = Math.max(0, now - Date.parse(usage.refilledAt));
-    const tokens = Math.min(capacity, usage.turnTokens + elapsed * perMs);
-    if (tokens < 1 - EPSILON) {
-        // Rounded before the ceiling so floating-point dust never adds a second.
-        const wait = Math.round(((1 - tokens) / perMs / 1000) * 1000) / 1000;
-        const retryAfterSeconds = Math.max(1, Math.ceil(wait));
-        fail(429, `At most ${capacity} turns per hour`, {
-            code: "limit_exceeded",
-            details: { limit: "turnsPerHour", retryAfterSeconds },
-        }, { "retry-after": String(retryAfterSeconds) });
-    }
-    await t.putSubjectUsage({
-        subject,
-        turnTokens: Math.max(0, tokens - 1),
-        refilledAt: new Date(now).toISOString(),
-    });
-}

package/dist/tenant/tokens.d.ts

@@ -1,14 +0,0 @@
-import { type CreateTokenRequest, type CreateTokenResponse } from "@nylorun/core/contracts";
-import type { AuthScope, TenantContext } from "./context.js";
-export { looksLikeToken } from "./jwt.js";
-export declare function mintToken(ctx: TenantContext, body: CreateTokenRequest): Promise<CreateTokenResponse>;
-export type TokenScopeAuth = Extract<AuthScope, {
-    kind: "token";
-}>;
-/**
- * Verifies a subject token. Returns the request's scope, answers `401 token_expired` for
- * the cases a new token fixes, and the opaque 404 for everything else.
- */
-export declare function verifySubjectToken(ctx: TenantContext, raw: string): Promise<TokenScopeAuth>;
-/** True when a token caller may reach `agentId`. Other callers always may. */
-export declare function mayUseAgent(scope: AuthScope, agentId: string): boolean;

package/dist/tenant/tokens.js

@@ -1,187 +0,0 @@
-/**
- * Subject tokens (Host feature `subject-tokens`): ES256 JWTs minted by `POST /v1/tokens` with
- * an application key, for one subject and one role of the access policy.
- *
- * Verification order matters: everything a forger controls is checked before any signature
- * work, and nothing but the signature-verified cases reveals more than the opaque 404.
- * Expired tokens, a stale revocation epoch, a revoked key or a removed role answer
- * `401 token_expired`, so clients always react the same way: get a new token.
- */
-import { randomUUID } from "node:crypto";
-import { errors, jwtVerify } from "jose";
-import { isSandboxGrant, isSubject, SUBJECT_TOKEN_AUDIENCE, SUBJECT_TOKEN_TYPE, subjectTokenIssuer, TOKEN_SANDBOX_GRANTS_MAX, TOKEN_SCOPES, TOKEN_TTL_MIN_SECONDS, } from "@nylorun/core/contracts";
-import { agentAllowed, readPolicy, resolveRole } from "./access-policy.js";
-import { fail, failOpaque, HttpError } from "./http.js";
-import { CLOCK_TOLERANCE_SECONDS, tokenKeyId } from "./jwt.js";
-/** Allowed spread between `iat` and `exp` beyond the policy's longest lifetime. */
-const LIFETIME_SLACK_SECONDS = 60;
-export { looksLikeToken } from "./jwt.js";
-/** The 401 every "get a new token" case answers. The reason is logged, never returned. */
-function expired(ctx, reason, jti) {
-    ctx.config.logger.warn("subject token refused", {
-        reason,
-        ...(jti ? { jti } : {}),
-    });
-    throw new HttpError(401, "The subject token has expired or was revoked", { code: "token_expired" }, { "www-authenticate": 'Bearer error="invalid_token"' });
-}
-function rejected(ctx, reason) {
-    ctx.config.logger.warn("credential rejected", { reason });
-    return failOpaque();
-}
-export async function mintToken(ctx, body) {
-    const tenantId = ctx.config.tenantId;
-    const { access, epoch, ttl } = await ctx.store.tx(async (t) => {
-        const policy = await readPolicy(t);
-        const role = Object.hasOwn(policy.roles, body.role)
-            ? policy.roles[body.role]
-            : undefined;
-        if (!role)
-            return fail(400, `Role ${body.role} is not in the access policy`, {
-                code: "invalid_request",
-            });
-        const scopes = body.scopes ?? role.scopes;
-        const outside = scopes.filter((scope) => !role.scopes.includes(scope));
-        if (outside.length > 0)
-            fail(400, `Role ${body.role} does not allow ${outside.join(", ")}`, {
-                code: "invalid_request",
-            });
-        if (body.agents && role.agents !== "*") {
-            const allowed = new Set(role.agents);
-            const extra = body.agents.filter((agent) => !allowed.has(agent));
-            if (extra.length > 0)
-                fail(400, `Role ${body.role} does not allow agent ${extra.join(", ")}`, {
-                    code: "invalid_request",
-                });
-        }
-        const maxTtl = policy.tokens.maxTtlSeconds;
-        const ttl = Math.min(body.ttlSeconds ?? maxTtl, maxTtl);
-        if (ttl < TOKEN_TTL_MIN_SECONDS)
-            fail(400, `ttlSeconds must be at least ${TOKEN_TTL_MIN_SECONDS}`);
-        return {
-            access: resolveRole(policy, body.role, scopes, body.agents),
-            epoch: await t.subjectEpoch(body.subject),
-            ttl,
-        };
-    });
-    const iat = Math.floor(Date.now() / 1000);
-    const jti = randomUUID();
-    const scopes = [...access.scopes];
-    const claims = {
-        tnt: tenantId,
-        role: body.role,
-        scp: scopes.join(" "),
-        ...(body.agents ? { agt: [...body.agents] } : {}),
-        ...(body.sandboxes?.length ? { sbx: [...new Set(body.sandboxes)] } : {}),
-        epc: epoch,
-    };
-    // Signed by the keys service (F4.2): this process never holds the private key.
-    const { token, keyId } = await ctx.keys.sign({
-        typ: SUBJECT_TOKEN_TYPE,
-        claims: {
-            ...claims,
-            iss: subjectTokenIssuer(tenantId),
-            aud: SUBJECT_TOKEN_AUDIENCE,
-            sub: body.subject,
-            iat,
-            exp: iat + ttl,
-            jti,
-        },
-    });
-    const signer = { id: keyId };
-    ctx.config.logger.info("subject token minted", {
-        jti,
-        kid: signer.id,
-        role: body.role,
-    });
-    return {
-        token,
-        expiresAt: new Date((iat + ttl) * 1000).toISOString(),
-        subject: body.subject,
-        role: body.role,
-        scopes,
-        agents: access.agents === "*" ? "*" : [...access.agents],
-        ...(claims.sbx ? { sandboxes: [...claims.sbx] } : {}),
-        keyId: signer.id,
-    };
-}
-/**
- * Verifies a subject token. Returns the request's scope, answers `401 token_expired` for
- * the cases a new token fixes, and the opaque 404 for everything else.
- */
-export async function verifySubjectToken(ctx, raw) {
-    const checked = tokenKeyId(raw, SUBJECT_TOKEN_TYPE);
-    if ("refused" in checked)
-        return rejected(ctx, checked.refused === "malformed" ? "token_malformed" : "token_header");
-    const { kid } = checked;
-    const { row, policy } = await ctx.store.tx(async (t) => ({
-        row: await t.signingKey(kid),
-        policy: await readPolicy(t),
-    }));
-    if (!row)
-        return rejected(ctx, "token_key_unknown");
-    const tenantId = ctx.config.tenantId;
-    let claims;
-    try {
-        const verified = await jwtVerify(raw, await ctx.signingKeys.publicKey(row), {
-            algorithms: ["ES256"],
-            issuer: subjectTokenIssuer(tenantId),
-            audience: SUBJECT_TOKEN_AUDIENCE,
-            typ: SUBJECT_TOKEN_TYPE,
-            clockTolerance: CLOCK_TOLERANCE_SECONDS,
-            requiredClaims: ["sub", "iat", "exp", "jti"],
-        });
-        claims = verified.payload;
-    }
-    catch (error) {
-        if (error instanceof errors.JWTExpired) {
-            // The signature was valid; only now may the answer differ from a forgery.
-            return expired(ctx, "expired");
-        }
-        return rejected(ctx, "token_invalid");
-    }
-    // The key was revoked after it signed: a new token uses the current key.
-    if (row.state === "revoked")
-        return expired(ctx, "key_revoked", claims.jti);
-    const scopeNames = typeof claims.scp === "string" ? claims.scp.split(" ").filter(Boolean) : [];
-    if (claims.tnt !== tenantId ||
-        !isSubject(claims.sub) ||
-        typeof claims.role !== "string" ||
-        typeof claims.epc !== "number" ||
-        !Number.isInteger(claims.epc) ||
-        claims.exp - claims.iat >
-            policy.tokens.maxTtlSeconds + LIFETIME_SLACK_SECONDS ||
-        scopeNames.some((name) => !TOKEN_SCOPES.includes(name)) ||
-        (claims.agt !== undefined &&
-            (!Array.isArray(claims.agt) ||
-                claims.agt.some((agent) => typeof agent !== "string"))) ||
-        (claims.sbx !== undefined &&
-            (!Array.isArray(claims.sbx) ||
-                claims.sbx.length > TOKEN_SANDBOX_GRANTS_MAX ||
-                claims.sbx.some((grant) => !isSandboxGrant(grant)))))
-        return rejected(ctx, "token_claims");
-    const epoch = await ctx.store.tx((t) => t.subjectEpoch(claims.sub));
-    if (claims.epc !== epoch)
-        return expired(ctx, "revoked", claims.jti);
-    const access = resolveRole(policy, claims.role, scopeNames, claims.agt);
-    if (!access)
-        return expired(ctx, "role_removed", claims.jti);
-    if (access.scopes.size === 0)
-        return expired(ctx, "role_narrowed", claims.jti);
-    return {
-        kind: "token",
-        subject: claims.sub,
-        scopes: access.scopes,
-        agents: access.agents,
-        role: access.role,
-        ...(access.limits ? { limits: access.limits } : {}),
-        ...(claims.sbx ? { sandboxes: claims.sbx } : {}),
-        epoch,
-        expiresAt: claims.exp * 1000,
-        tokenId: claims.jti,
-        keyId: kid,
-    };
-}
-/** True when a token caller may reach `agentId`. Other callers always may. */
-export function mayUseAgent(scope, agentId) {
-    return scope.kind !== "token" || agentAllowed(scope.agents, agentId);
-}