@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/tenant/artifact-tool.js

@@ -1,243 +0,0 @@
-/**
- * Our engine's built-in artifact tools, which the Runtime pins in a session agent's `runtime`
- * block (`sandbox/session-sandbox.ts`). The Runtime runs them itself, like the sandbox tools.
- *
- * `save_artifact` (F8.1), which comes with a session's sandbox, saves a file as an artifact of
- * its session:
- * - `path`: a file in the session's sandbox, read as bytes in the sandbox's queue;
- * - `content`: text the model passes.
- * The version commits with `artifact.created` (or `artifact.version.created`) on the session's
- * stream, carrying the turn and the tool call.
- *
- * `read_artifact` (R2b C11, Q24; every agent since protocol 12) reads a text artifact in pages of
- * at most 32 KiB, from a byte `offset`: how the model reads a tool result the Runtime stored
- * because it was too large to show (`tool-results.ts`), and a file of an earlier turn again, by
- * its reference line. Another file is shown as a file of the result when the Tenant's model reads
- * its type, and refused (`artifact.unsupported`) when it does not. It reaches the session's own
- * artifacts and the Tenant-wide ones its messages named (`Session.fileArtifacts`), never another
- * session's. `version` picks a version; the latest by default.
- *
- * Expected problems (no such file, too large, the Tenant's total reached, not text) are failed
- * outcomes the model sees; only infrastructure errors throw.
- */
-import { basename } from "node:path";
-import { READ_ARTIFACT_MAX_BYTES } from "@nylorun/core/define";
-import { isArtifactId } from "@nylorun/core/compatibility";
-import { readArtifactLimits } from "../artifacts/config.js";
-import { contentTypeFor, essence, isText, normalizeContentType, unreadableReason, } from "../artifacts/media-types.js";
-import { currentModelInputs } from "../model/catalog.js";
-import { uploadArtifact } from "../artifacts/service.js";
-import { DEFAULT_CONTENT_TYPE } from "../blob/index.js";
-import { sandboxToolSpec } from "../sandbox/manager.js";
-import { sandboxWorkspaceOf } from "../sandbox/share.js";
-import { sessionOf } from "./context.js";
-import { HttpError } from "./http.js";
-import { manifestFor } from "./session.js";
-import { jsonBytes, utf8Boundary } from "./tool-results.js";
-import { toolIds } from "./transcript.js";
-export { isReadArtifactCall, isSaveArtifactCall } from "../harness/calls.js";
-const failed = (code, message) => ({
-    kind: "failed",
-    code,
-    message,
-});
-export async function callSaveArtifact(ctx, request, signal) {
-    const input = (request.input ?? {});
-    const path = typeof input.path === "string" && input.path !== "" ? input.path : undefined;
-    const content = typeof input.content === "string" ? input.content : undefined;
-    if ((path === undefined) === (content === undefined))
-        return failed("artifact.invalid_input", "Give path or content, not both.");
-    const artifactId = typeof input.artifactId === "string" ? input.artifactId : undefined;
-    const { s, workspace, limits, ours } = await ctx.store.tx(async (t) => {
-        const s = await sessionOf(t, request.sessionId);
-        // A new version only of an artifact of this session.
-        const ours = artifactId === undefined ||
-            (isArtifactId(artifactId) && (await t.artifact(artifactId))?.sessionId === s.id);
-        return {
-            s,
-            workspace: sandboxWorkspaceOf(s),
-            limits: await readArtifactLimits(t),
-            ours,
-        };
-    });
-    if (!ours)
-        return failed("artifact.not_found", `Artifact ${artifactId} is not an artifact of this session.`);
-    let bytes;
-    let fileName;
-    if (path !== undefined) {
-        const spec = sandboxToolSpec(manifestFor(s.manifest, request.agent), "read");
-        if (!spec)
-            return failed("artifact.no_sandbox", "This session has no sandbox to read a path from.");
-        const read = await ctx.sandbox.readBytes({
-            id: workspace.ownerId,
-            activeTurnId: s.activeTurnId,
-            manifest: s.manifest,
-            ...(workspace.environmentId === undefined ? {} : { environmentId: workspace.environmentId }),
-        }, spec, path, limits.fileBytes, signal);
-        if (read.kind === "failed")
-            return read;
-        if (read.kind === "missing")
-            return failed("artifact.not_found", `${read.path} does not exist in the sandbox.`);
-        bytes = read.bytes;
-        fileName = basename(read.path);
-    }
-    else {
-        bytes = new TextEncoder().encode(content);
-        fileName = "artifact.txt";
-    }
-    const name = typeof input.name === "string" && input.name !== "" ? input.name : fileName;
-    let contentType;
-    if (typeof input.contentType === "string") {
-        const declared = normalizeContentType(input.contentType);
-        if (declared === undefined)
-            return failed("artifact.invalid_input", `${input.contentType} is not a media type.`);
-        contentType = declared;
-    }
-    else {
-        contentType = contentTypeFor(name);
-        if (content !== undefined && contentType === DEFAULT_CONTENT_TYPE)
-            contentType = "text/plain; charset=utf-8";
-    }
-    const ids = toolIds(request.context);
-    try {
-        const saved = await uploadArtifact(ctx, {
-            ...(artifactId !== undefined ? { artifactId } : { name }),
-            contentType,
-            sessionId: s.id,
-            source: "engine",
-            turnId: request.turnId,
-            ...("callId" in ids ? { callId: ids.callId } : {}),
-        }, bytes, 
-        // Our engine saves into its own session only.
-        { owner: s.ownerUserId }, signal);
-        return {
-            kind: "completed",
-            output: {
-                artifactId: saved.artifact.artifactId,
-                version: saved.version.version,
-                name: saved.artifact.name,
-                contentType: saved.version.contentType,
-                size: saved.version.size,
-                sha256: saved.version.sha256,
-            },
-        };
-    }
-    catch (error) {
-        if (error instanceof HttpError)
-            return failed(error.rejection.code === "limit_exceeded" ? "artifact.too_large" : "artifact.rejected", error.message);
-        throw error;
-    }
-}
-export async function callReadArtifact(ctx, request, signal) {
-    const input = (request.input ?? {});
-    const artifactId = typeof input.artifactId === "string" ? input.artifactId : "";
-    const wanted = input.version;
-    const offset = input.offset ?? 0;
-    const length = input.length ?? READ_ARTIFACT_MAX_BYTES;
-    if (artifactId === "" ||
-        (wanted !== undefined &&
-            (typeof wanted !== "number" || !Number.isSafeInteger(wanted) || wanted < 1)) ||
-        typeof offset !== "number" ||
-        !Number.isSafeInteger(offset) ||
-        offset < 0 ||
-        typeof length !== "number" ||
-        !Number.isSafeInteger(length) ||
-        length < 1 ||
-        length > READ_ARTIFACT_MAX_BYTES)
-        return failed("artifact.invalid_input", `Give artifactId, a version of 1 or more if any, an offset of 0 or more, and a length of 1 to ${READ_ARTIFACT_MAX_BYTES}.`);
-    const found = await ctx.store.tx(async (t) => {
-        const s = await sessionOf(t, request.sessionId);
-        if (!isArtifactId(artifactId))
-            return undefined;
-        // An artifact of this session, or a Tenant-wide one its messages named; never another
-        // session's.
-        const artifact = await t.artifact(artifactId);
-        if (!artifact ||
-            (artifact.sessionId !== s.id &&
-                !(artifact.sessionId === null && s.fileArtifacts?.includes(artifact.id))))
-            return undefined;
-        const version = await t.artifactVersion(artifact.id, typeof wanted === "number" ? wanted : artifact.latestVersion);
-        return { artifact, version };
-    });
-    if (!found)
-        return failed("artifact.not_found", `Artifact ${artifactId} is not an artifact of this session.`);
-    if (!found.version)
-        return failed("artifact.not_found", `Artifact ${artifactId} has no version ${String(wanted)}.`);
-    const { artifact, version } = found;
-    const about = {
-        artifactId: artifact.id,
-        version: version.version,
-        name: artifact.name,
-        contentType: version.contentType,
-        size: version.size,
-    };
-    if (artifact.kind !== "file")
-        return failed("artifact.not_text", `${artifact.name} is a folder; read_artifact reads a file.`);
-    if (!isText(version.contentType)) {
-        // A file the Tenant's model reads goes to it beside the result (protocol 12). Without a
-        // model in the vault (a test's fake provider), text and images.
-        const inputs = (await currentModelInputs(ctx)) ?? ["text", "image"];
-        const reason = unreadableReason(version.contentType, inputs);
-        if (reason)
-            return failed("artifact.unsupported", `${artifact.name} is ${essence(version.contentType)}: ${reason}.`);
-        return {
-            kind: "completed",
-            output: about,
-            files: [
-                {
-                    mediaType: version.contentType,
-                    reference: {
-                        artifactId: artifact.id,
-                        version: version.version,
-                        name: artifact.name,
-                        size: version.size,
-                    },
-                },
-            ],
-        };
-    }
-    if (offset > version.size || (offset === version.size && version.size > 0))
-        return failed("artifact.invalid_input", `Offset ${offset} is past the end of ${artifact.name}, which is ${version.size} bytes.`);
-    const end = Math.min(offset + length, version.size);
-    const bytes = end === offset ? new Uint8Array() : await readRange(ctx, version.blobKey, offset, end - 1, signal);
-    const page = textPage(bytes, end === version.size);
-    const next = offset + page.bytes;
-    return {
-        kind: "completed",
-        output: {
-            ...about,
-            offset,
-            content: page.text,
-            ...(next < version.size ? { nextOffset: next } : {}),
-        },
-    };
-}
-/** Bytes `start` to `end` (both inclusive) of a version's blob. */
-async function readRange(ctx, blobKey, start, end, signal) {
-    const got = await ctx.blobs.get(blobKey, { range: { start, end }, signal });
-    if (!got)
-        throw new Error("The artifact's bytes are missing from the Object store");
-    return new Uint8Array(await new Response(got.body).arrayBuffer());
-}
-/**
- * The text of a page of UTF-8 `bytes` in whole characters, at most `READ_ARTIFACT_MAX_BYTES`
- * once escaped as JSON, and how many bytes it used: the next page starts there. A page that
- * starts inside a character skips its rest, and one that ends inside one (not `last`) stops
- * before it.
- */
-function textPage(bytes, last) {
-    const from = utf8Boundary(bytes, 0, "up");
-    let to = last ? bytes.byteLength : utf8Boundary(bytes, bytes.byteLength, "down");
-    // A page shorter than one character: take what there is.
-    if (to <= from)
-        to = bytes.byteLength;
-    const decode = () => Buffer.from(bytes.subarray(from, to)).toString("utf8");
-    let text = decode();
-    // Escaped (quotes, newlines, control characters), text takes more room than its bytes: each
-    // byte left out frees at least one.
-    for (let size = jsonBytes(text); to > from && size > READ_ARTIFACT_MAX_BYTES; size = jsonBytes(text)) {
-        to = utf8Boundary(bytes, Math.max(from, to - (size - READ_ARTIFACT_MAX_BYTES)), "down");
-        text = decode();
-    }
-    return { text, bytes: to };
-}

package/dist/tenant/environment-manifests.d.ts

@@ -1,57 +0,0 @@
-/**
- * Environment manifests (protocol 14, D63): `/v1/environment-manifests/{name}`, named and
- * versioned definitions of a kind of Environment, saved like agents.
- *
- * - **Versions.** A save whose manifest hashes the same as the latest answers it unchanged;
- *   any other writes the next version. A version is never changed or deleted alone.
- * - **No Environment changes.** Saving a version reaches no Environment: an Environment is made
- *   from one version and keeps it for life (`putEnvironment`). The plan counts those behind.
- * - **Plan and drift.** `?dryRun=true` answers what a save would do and saves nothing: the
- *   changes from the latest, every reason the Runtime would refuse it (the Tenant's limits,
- *   missing artifacts), warnings, and how many Environments stay on older versions.
- *   `If-Match: <version>` refuses (`412 manifest_changed`) a save whose latest version moved
- *   since the client read it; `0` asks for a manifest that does not exist yet.
- * - **Every client is equal** (Q12): a version records who saved it (`savedBy`), and nothing is
- *   read-only by where it was saved from.
- */
-import { type EnvironmentManifest, type EnvironmentManifestPlan, type EnvironmentManifestVersions, type EnvironmentManifestView, type PutEnvironmentManifestRequest, type SaveEnvironmentManifestResponse } from "@nylorun/core/contracts";
-import { type RecipeRequest } from "../sandbox/resolve.js";
-import type { AuthScope, TenantContext } from "./context.js";
-/** What an environment manifest asks of an Environment's recipe. */
-export declare function manifestRecipeRequest(manifest: EnvironmentManifest): RecipeRequest;
-/** The hash a manifest's version records: equal manifests hash the same. */
-export declare function environmentManifestHash(manifest: EnvironmentManifest): string;
-/** Each field that differs between `before` and `after`, by path; arrays compare whole. */
-export declare function manifestChanges(before: unknown, after: unknown, path?: string): {
-    path: string;
-    from?: unknown;
-    to?: unknown;
-}[];
-/**
- * `PUT /v1/environment-manifests/{name}`: saves `body` as manifest `name`'s next version, or
- * answers the latest unchanged; with `dryRun`, the plan of that save and nothing saved.
- */
-export declare function saveEnvironmentManifest(ctx: TenantContext, name: string, body: PutEnvironmentManifestRequest, scope: AuthScope, options: {
-    dryRun: true;
-    ifMatch?: number;
-}): Promise<EnvironmentManifestPlan>;
-export declare function saveEnvironmentManifest(ctx: TenantContext, name: string, body: PutEnvironmentManifestRequest, scope: AuthScope, options?: {
-    dryRun?: false;
-    ifMatch?: number;
-}): Promise<SaveEnvironmentManifestResponse>;
-/** `GET /v1/environment-manifests/{name}` (the latest) and `.../versions/{n}`. */
-export declare function getEnvironmentManifest(ctx: TenantContext, name: string, version?: number): Promise<EnvironmentManifestView>;
-/** `GET /v1/environment-manifests`: each manifest's latest version. */
-export declare function listEnvironmentManifests(ctx: TenantContext): Promise<{
-    manifests: EnvironmentManifestView[];
-}>;
-/** `GET /v1/environment-manifests/{name}/versions`: every version, newest first. */
-export declare function environmentManifestVersions(ctx: TenantContext, name: string): Promise<EnvironmentManifestVersions>;
-/**
- * `DELETE /v1/environment-manifests/{name}`: deletes every version, refused while any Environment
- * was made from one (`409 manifest_in_use`): the Environment names the version it runs.
- */
-export declare function deleteEnvironmentManifest(ctx: TenantContext, name: string): Promise<{
-    name: string;
-    deleted: boolean;
-}>;

package/dist/tenant/environment-manifests.js

@@ -1,200 +0,0 @@
-/**
- * Environment manifests (protocol 14, D63): `/v1/environment-manifests/{name}`, named and
- * versioned definitions of a kind of Environment, saved like agents.
- *
- * - **Versions.** A save whose manifest hashes the same as the latest answers it unchanged;
- *   any other writes the next version. A version is never changed or deleted alone.
- * - **No Environment changes.** Saving a version reaches no Environment: an Environment is made
- *   from one version and keeps it for life (`putEnvironment`). The plan counts those behind.
- * - **Plan and drift.** `?dryRun=true` answers what a save would do and saves nothing: the
- *   changes from the latest, every reason the Runtime would refuse it (the Tenant's limits,
- *   missing artifacts), warnings, and how many Environments stay on older versions.
- *   `If-Match: <version>` refuses (`412 manifest_changed`) a save whose latest version moved
- *   since the client read it; `0` asks for a manifest that does not exist yet.
- * - **Every client is equal** (Q12): a version records who saved it (`savedBy`), and nothing is
- *   read-only by where it was saved from.
- */
-import {} from "@nylorun/core/contracts";
-import { hashManifest } from "@nylorun/core/compatibility";
-import { canonical } from "../store/canonical.js";
-import { resolveRecipe } from "../sandbox/resolve.js";
-import { effectiveSandboxConfig, readSandboxConfig } from "../sandbox/tenant-config.js";
-import { actorOf, fileErrors } from "./environments.js";
-import { fail } from "./http.js";
-/** What an environment manifest asks of an Environment's recipe. */
-export function manifestRecipeRequest(manifest) {
-    return {
-        ...(manifest.image === undefined ? {} : { image: manifest.image }),
-        ...(manifest.resources === undefined ? {} : { resources: manifest.resources }),
-        ...(manifest.storage === undefined ? {} : { storage: manifest.storage }),
-        ...(manifest.network === undefined ? {} : { network: manifest.network }),
-        ...(manifest.harness === undefined ? {} : { harness: manifest.harness }),
-        ...(manifest.lifecycle === undefined ? {} : { lifecycle: manifest.lifecycle }),
-        ...(manifest.setup === undefined ? {} : { setup: manifest.setup }),
-        ...(manifest.files === undefined ? {} : { files: manifest.files }),
-        ...(manifest.secrets === undefined ? {} : { secrets: manifest.secrets }),
-    };
-}
-/** The hash a manifest's version records: equal manifests hash the same. */
-export function environmentManifestHash(manifest) {
-    return hashManifest(manifest);
-}
-const notFound = (name, version) => fail(404, version === undefined ? `No environment manifest is named ${name}.` : `Environment manifest ${name} has no version ${version}.`, {
-    code: "manifest_not_found",
-});
-function viewOf(row, counts) {
-    return {
-        name: row.name,
-        version: row.version,
-        hash: row.hash,
-        manifest: row.body,
-        savedBy: row.savedBy,
-        createdAt: row.createdAt,
-        environments: counts.get(row.version) ?? 0,
-    };
-}
-/** Each field that differs between `before` and `after`, by path; arrays compare whole. */
-export function manifestChanges(before, after, path = "") {
-    const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-    if (object(before) && object(after)) {
-        const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort();
-        return keys.flatMap((key) => manifestChanges(before[key], after[key], path ? `${path}.${key}` : key));
-    }
-    if (canonical(before) === canonical(after))
-        return [];
-    return [
-        {
-            path,
-            ...(before === undefined ? {} : { from: before }),
-            ...(after === undefined ? {} : { to: after }),
-        },
-    ];
-}
-/** What a save of `manifest` should tell its saver, though it would be saved. */
-function warningsOf(ctx, manifest) {
-    const warnings = [];
-    if (manifest.image !== undefined && !manifest.image.includes("@sha256:"))
-        warnings.push({
-            code: "image_tag",
-            message: `image ${manifest.image} is a tag, not a digest: each Environment pins what its first pod pulls, so two Tenants may run different bytes.`,
-        });
-    if (manifest.kind === "pod" && !ctx.pods)
-        warnings.push({
-            code: "pods_unavailable",
-            message: "kind pod needs sandbox pods, which this Tenant does not have: an Environment made from it is refused until `nylorun local sandbox enable`.",
-        });
-    return warnings;
-}
-/** Every reason the Runtime would refuse `manifest` now: the Tenant's limits and its files. */
-async function errorsOf(t, manifest) {
-    const config = effectiveSandboxConfig(await readSandboxConfig(t));
-    const resolved = resolveRecipe(manifest.kind ?? "virtual", manifestRecipeRequest(manifest), config);
-    return [...(resolved.kind === "error" ? resolved.errors : []), ...(await fileErrors(t, manifest.files))];
-}
-export async function saveEnvironmentManifest(ctx, name, body, scope, options = {}) {
-    const { requestId: _, ...manifest } = body;
-    if (manifest.name !== name)
-        fail(400, `The manifest is named ${manifest.name}, and the path names ${name}: they must match.`);
-    const hash = environmentManifestHash(manifest);
-    const warnings = warningsOf(ctx, manifest);
-    return ctx.store.tx(async (t) => {
-        await t.lockEnvironmentManifest(name);
-        const latest = await t.environmentManifest(name);
-        if (options.ifMatch !== undefined && (latest?.version ?? 0) !== options.ifMatch)
-            fail(412, latest === undefined
-                ? `Environment manifest ${name} does not exist, and If-Match named version ${options.ifMatch}.`
-                : `Environment manifest ${name} is at version ${latest.version}, not ${options.ifMatch}: someone saved it since you read it. Read it again, or save without If-Match to replace it.`, { code: "manifest_changed", details: { latest: latest?.version ?? 0 } });
-        const unchanged = latest?.hash === hash;
-        const to = unchanged ? latest.version : (latest?.version ?? 0) + 1;
-        const counts = await t.environmentsOfManifest(name);
-        const errors = await errorsOf(t, manifest);
-        if (options.dryRun) {
-            let behind = 0;
-            for (const [version, n] of counts)
-                if (version < to)
-                    behind += n;
-            return {
-                name,
-                from: latest?.version ?? null,
-                to,
-                unchanged,
-                changes: unchanged ? [] : manifestChanges(latest?.body ?? {}, manifest),
-                warnings,
-                errors,
-                behind,
-            };
-        }
-        if (errors.length > 0)
-            fail(400, errors.join(" "));
-        if (unchanged)
-            return { manifest: viewOf(latest, counts), unchanged: true, warnings };
-        const row = {
-            name,
-            version: to,
-            body: manifest,
-            hash,
-            savedBy: { actor: actorOf(scope) },
-            createdAt: new Date().toISOString(),
-        };
-        await t.insertEnvironmentManifest(row);
-        // Its files by hash (Q6), recorded as a definition's are, for the sweep that deletes unused ones.
-        const shas = [...new Set((manifest.files ?? []).flatMap((file) => ("files" in file ? Object.values(file.files) : [])))];
-        if (shas.length > 0)
-            await t.insertDefinitionFileUses(`environment-manifest:${name}`, hash, shas);
-        return { manifest: viewOf(row, counts), unchanged: false, warnings };
-    });
-}
-/** `GET /v1/environment-manifests/{name}` (the latest) and `.../versions/{n}`. */
-export async function getEnvironmentManifest(ctx, name, version) {
-    return ctx.store.tx(async (t) => {
-        const row = (await t.environmentManifest(name, version)) ?? notFound(name, version);
-        return viewOf(row, await t.environmentsOfManifest(name));
-    });
-}
-/** `GET /v1/environment-manifests`: each manifest's latest version. */
-export async function listEnvironmentManifests(ctx) {
-    return ctx.store.tx(async (t) => {
-        const manifests = [];
-        for (const row of await t.listEnvironmentManifests())
-            manifests.push(viewOf(row, await t.environmentsOfManifest(row.name)));
-        return { manifests };
-    });
-}
-/** `GET /v1/environment-manifests/{name}/versions`: every version, newest first. */
-export async function environmentManifestVersions(ctx, name) {
-    return ctx.store.tx(async (t) => {
-        const rows = await t.environmentManifestVersions(name);
-        if (rows.length === 0)
-            notFound(name);
-        const counts = await t.environmentsOfManifest(name);
-        return {
-            name,
-            latest: rows[0].version,
-            versions: rows.map((row) => ({
-                version: row.version,
-                hash: row.hash,
-                savedBy: row.savedBy,
-                createdAt: row.createdAt,
-                environments: counts.get(row.version) ?? 0,
-            })),
-        };
-    });
-}
-/**
- * `DELETE /v1/environment-manifests/{name}`: deletes every version, refused while any Environment
- * was made from one (`409 manifest_in_use`): the Environment names the version it runs.
- */
-export async function deleteEnvironmentManifest(ctx, name) {
-    return ctx.store.tx(async (t) => {
-        await t.lockEnvironmentManifest(name);
-        let made = 0;
-        for (const n of (await t.environmentsOfManifest(name)).values())
-            made += n;
-        if (made > 0)
-            fail(409, `${made} Environment(s) were made from environment manifest ${name}: delete them first, or keep the manifest.`, {
-                code: "manifest_in_use",
-                details: { environments: made },
-            });
-        return { name, deleted: (await t.deleteEnvironmentManifest(name)) > 0 };
-    });
-}