@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/vault/headers.js

@@ -4,6 +4,7 @@
  * Runtime sets itself, so a credential can never replace them.
  */
 import { VaultError } from "./error.js";
+import { hostTuning } from "../tuning.js";
 /** Headers the MCP transport and the HTTP tool call own. */
 const RESERVED_HEADERS = new Set([
     "host",
@@ -25,13 +26,14 @@ const RESERVED_HEADERS = new Set([
 export function credentialSecrets(headers, identity) {
     const skip = identity?.header.toLowerCase();
     const secrets = new Set();
+    const least = hostTuning().harness.scrubMinChars;
     for (const [name, value] of Object.entries(headers)) {
         if (name.toLowerCase() === skip)
             continue;
-        if (value.length >= 8)
+        if (value.length >= least)
             secrets.add(value);
         const bearer = /^bearer\s+(\S+)\s*$/iu.exec(value)?.[1];
-        if (bearer !== undefined && bearer.length >= 8)
+        if (bearer !== undefined && bearer.length >= least)
             secrets.add(bearer);
     }
     return [...secrets];

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.25.0-beta";
+export declare const RUNTIME_VERSION = "0.27.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/server/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.25.0-beta";
+export const RUNTIME_VERSION = "0.27.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.25.0-beta",
+  "version": "0.27.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -65,8 +65,8 @@
     "@hono/node-server": "^2.1.3",
     "@hono/zod-openapi": "^1.6.3",
     "@modelcontextprotocol/sdk": "^1.32.1",
-    "@nylorun/core": "0.21.0-beta",
-    "@nylorun/harness": "0.27.0-beta",
+    "@nylorun/core": "0.23.0-beta",
+    "@nylorun/harness": "0.28.0-beta",
     "@restatedev/restate-sdk": "1.17.2",
     "@restatedev/restate-sdk-clients": "1.17.2",
     "@s2-dev/streamstore": "0.28.0",

package/dist/artifacts/export.d.ts

@@ -1,8 +0,0 @@
-import type { TenantContext } from "../tenant/context.js";
-/** The directory every sandbox's outputs are exported from. */
-export declare const OUTPUTS_DIR = "/workspace/outputs";
-/**
- * Exports the outputs of turn `turnId` of session `sessionId`, if it completed and its sandbox
- * has any. Never throws.
- */
-export declare function exportOutputs(ctx: TenantContext, sessionId: string, turnId: string | null, signal: AbortSignal): Promise<void>;

package/dist/artifacts/export.js

@@ -1,204 +0,0 @@
-/**
- * The turn-end export (F8.2): when an agent's turn completes, core reads `/workspace/outputs` of
- * the session's sandbox through the `WorkspaceReader` seam and keeps it as a version of the
- * session's folder artifact `outputs` (the first export creates it; later turns add versions,
- * and a turn whose outputs did not change adds none).
- *
- * - **After the turn.** The advance calls `exportOutputs` once `settle` has committed the turn,
- *   outside its transaction and while it still holds the session's lease, so the next turn
- *   cannot change the workspace under it. Nothing here fails the turn: a sandbox or store
- *   failure is logged and recorded as `artifact.export.failed`.
- * - **Claimed.** The listing and the bytes are what the holder of the workspace supplied: the
- *   version's source is `export` and its event says `claimed: true`.
- * - **Bounded.** At most `EXPORT_MAX_FILES` files and `EXPORT_MAX_BYTES` bytes per export, each
- *   file within the Tenant's per-file limit, and the new bytes within its total; past any of
- *   them nothing is stored and `artifact.export.skipped` says why.
- * - **Deduplicated.** Each file is stored content-addressed (`folders.ts`); a file the store
- *   already holds is not stored again.
- *
- * No sandbox, a sandbox never created, or an empty or missing `/workspace/outputs` exports
- * nothing and records nothing. The package's declared outputs are left for later: the manifest
- * has no `outputs` field yet.
- */
-import { posix } from "node:path";
-import { EXPORT_MAX_BYTES, EXPORT_MAX_FILES, OUTPUTS_ARTIFACT_NAME, } from "@nylorun/core/contracts";
-import { SANDBOX_WORKSPACE } from "@nylorun/core/define";
-import { isWorkflowManifest } from "../core/flow-host.js";
-import { sandboxWorkspaceOf } from "../sandbox/share.js";
-import { SandboxFileTooLargeError } from "../sandbox/types.js";
-import { readArtifactLimits } from "./config.js";
-import { collectContent, commitFolderVersion, contentEpoch, contentKey, encodeManifest, FolderCommitRefused, sha256Hex, } from "./folders.js";
-import { contentTypeFor } from "./media-types.js";
-/** The directory every sandbox's outputs are exported from. */
-export const OUTPUTS_DIR = `${SANDBOX_WORKSPACE}/outputs`;
-/** Stops the export with `artifact.export.skipped`. */
-class Skip extends Error {
-    reason;
-    limit;
-    path;
-    constructor(reason, message, limit, path) {
-        super(message);
-        this.reason = reason;
-        this.limit = limit;
-        this.path = path;
-    }
-}
-/**
- * Exports the outputs of turn `turnId` of session `sessionId`, if it completed and its sandbox
- * has any. Never throws.
- */
-export async function exportOutputs(ctx, sessionId, turnId, signal) {
-    try {
-        await runExport(ctx, sessionId, turnId, signal);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (signal.aborted) {
-            ctx.config.logger.info("outputs export stopped", { sessionId, message });
-            return;
-        }
-        const skip = error instanceof Skip
-            ? error
-            : error instanceof FolderCommitRefused && error.reason === "tenant_total"
-                ? new Skip("tenant_total", error.message, error.limit)
-                : undefined;
-        if (!skip)
-            ctx.config.logger.warn("outputs export failed", { sessionId, message });
-        try {
-            await ctx.store.tx(async (t) => {
-                if (skip)
-                    await t.event(sessionId, turnId, "artifact.export.skipped", {
-                        name: OUTPUTS_ARTIFACT_NAME,
-                        reason: skip.reason,
-                        message: skip.message,
-                        ...(skip.limit === undefined ? {} : { limit: skip.limit }),
-                        ...(skip.path === undefined ? {} : { path: skip.path }),
-                    });
-                else
-                    await t.event(sessionId, turnId, "artifact.export.failed", {
-                        name: OUTPUTS_ARTIFACT_NAME,
-                        message,
-                    });
-            });
-        }
-        catch {
-            /* the session is gone (reset) or the store closed */
-        }
-    }
-}
-async function runExport(ctx, sessionId, turnId, signal) {
-    const found = await ctx.store.tx(async (t) => {
-        const s = await t.get("sessions", sessionId);
-        // Only a turn that completed, and only an agent's (a flow agent's sandbox is its agents').
-        if (!s || s.status !== "completed" || s.lastTurnId !== turnId || isWorkflowManifest(s.manifest))
-            return undefined;
-        const workspace = sandboxWorkspaceOf(s);
-        const prior = (await t.listArtifacts({ sessionId })).find((row) => row.kind === "folder" && row.name === OUTPUTS_ARTIFACT_NAME);
-        const latest = prior ? await t.artifactVersion(prior.id, prior.latestVersion) : undefined;
-        return {
-            session: {
-                sessionId,
-                turnId,
-                ownerId: workspace.ownerId,
-                ...(workspace.environmentId === undefined ? {} : { environmentId: workspace.environmentId }),
-                manifest: s.manifest,
-            },
-            limits: await readArtifactLimits(t),
-            priorId: prior?.id,
-            latestSha: latest?.sha256,
-            epoch: await contentEpoch(t),
-        };
-    });
-    if (!found)
-        return;
-    const { session, limits } = found;
-    const listing = await ctx.workspaces.list(session, OUTPUTS_DIR, {
-        maxEntries: EXPORT_MAX_FILES,
-        signal,
-    });
-    if (!listing || listing.entries.length === 0)
-        return;
-    if (listing.truncated)
-        throw new Skip("too_many_files", `${OUTPUTS_DIR} holds more than ${EXPORT_MAX_FILES} files`, EXPORT_MAX_FILES);
-    const large = listing.entries.find((entry) => entry.size > limits.fileBytes);
-    if (large)
-        throw tooLargeFile(large.path, large.size, limits.fileBytes);
-    const maxBytes = Math.min(EXPORT_MAX_BYTES, limits.totalBytes);
-    const listed = listing.entries.reduce((sum, entry) => sum + entry.size, 0);
-    if (listed > maxBytes)
-        throw tooLarge(listed, maxBytes);
-    // The files this export stored: removed again if it commits nothing, unless another version
-    // names them by then.
-    const put = [];
-    try {
-        await storeAndCommit(ctx, found, listing.entries, maxBytes, put, signal);
-    }
-    catch (error) {
-        if (put.length > 0)
-            await ctx.store
-                .tx(async (t) => {
-                await t.lockArtifactQuota();
-                await collectContent(ctx.blobs, t, put);
-            })
-                .catch(() => undefined);
-        throw error;
-    }
-}
-async function storeAndCommit(ctx, found, listed, maxBytes, put, signal) {
-    const { session, limits } = found;
-    const { sessionId, turnId } = session;
-    const entries = [];
-    const stored = new Set();
-    let read = 0;
-    for (const entry of listed) {
-        let bytes;
-        try {
-            bytes = await ctx.workspaces.readBytes(session, posix.join(OUTPUTS_DIR, entry.path), {
-                maxBytes: limits.fileBytes,
-                signal,
-            });
-        }
-        catch (error) {
-            if (error instanceof SandboxFileTooLargeError)
-                throw tooLargeFile(entry.path, error.size, limits.fileBytes);
-            throw error;
-        }
-        // Gone since the listing: the folder is what is there now.
-        if (bytes === undefined)
-            continue;
-        read += bytes.length;
-        if (read > maxBytes)
-            throw tooLarge(read, maxBytes);
-        const sha256 = sha256Hex(bytes);
-        const contentType = contentTypeFor(posix.basename(entry.path));
-        if (!stored.has(sha256)) {
-            stored.add(sha256);
-            const key = contentKey(sha256);
-            if (!(await ctx.blobs.head(key))) {
-                put.push(sha256);
-                await ctx.blobs.put(key, bytes, { contentType, signal });
-            }
-        }
-        entries.push({ path: entry.path, size: bytes.length, sha256, contentType });
-    }
-    // Every file vanished, or nothing changed since the last export: no new version.
-    if (entries.length === 0)
-        return;
-    if (found.latestSha !== undefined && sha256Hex(encodeManifest(entries)) === found.latestSha)
-        return;
-    await commitFolderVersion(ctx, {
-        sessionId,
-        turnId,
-        ...(found.priorId === undefined ? {} : { artifactId: found.priorId }),
-        name: OUTPUTS_ARTIFACT_NAME,
-        entries,
-        epoch: found.epoch,
-        totalBytes: limits.totalBytes,
-    });
-}
-function tooLargeFile(path, size, limit) {
-    return new Skip("file_too_large", `${OUTPUTS_DIR}/${path} is ${size} bytes; a file may hold at most ${limit}`, limit, path);
-}
-function tooLarge(bytes, limit) {
-    return new Skip("too_large", `${OUTPUTS_DIR} holds ${bytes} bytes; an export stores at most ${limit}`, limit);
-}

package/dist/artifacts/media-types.d.ts

@@ -1,30 +0,0 @@
-/**
- * Media types of file artifacts: what an upload may declare, what a name's extension implies,
- * and which model input a file is (`modelInputOf`, protocol 12): text, an image, a PDF, an Office
- * document, audio or video. A model reads a file only when its inputs include that one.
- */
-import type { ModelInput } from "@nylorun/core/contracts";
-/** Images the model reads as images. */
-export declare const MODEL_IMAGE_TYPES: readonly string[];
-/** The largest image or text file a model call carries inline. */
-export declare const MODEL_FILE_MAX_BYTES: number;
-/** The type part of a `Content-Type` value, lowercased, without parameters. */
-export declare function essence(contentType: string): string;
-/** A declared `Content-Type` as stored, or undefined when it is not a media type. */
-export declare function normalizeContentType(value: string | undefined): string | undefined;
-/** The media type a file name implies, or `application/octet-stream`. */
-export declare function contentTypeFor(name: string): string;
-export declare function isModelImage(contentType: string): boolean;
-/** Files the model reads as text: `text/*`, JSON, XML, YAML and their `+json`/`+xml` kin. */
-export declare function isText(contentType: string): boolean;
-/** The usual extension of a media type, for a name the Runtime gives a file; undefined if none. */
-export declare function extensionFor(contentType: string): string | undefined;
-/** The model input a file of `contentType` is, or undefined for a type no model reads. */
-export declare function modelInputOf(contentType: string): ModelInput | undefined;
-/** An input, in a sentence: "PDFs", "Office documents"; "files of this type" for none. */
-export declare function inputLabel(input: ModelInput | undefined): string;
-/**
- * Why a model that reads `inputs` cannot read a file of `contentType`, or undefined when it can.
- * An image must also be PNG, JPEG, GIF or WebP.
- */
-export declare function unreadableReason(contentType: string, inputs: readonly ModelInput[]): string | undefined;

package/dist/artifacts/media-types.js

@@ -1,137 +0,0 @@
-import { DEFAULT_CONTENT_TYPE } from "../blob/index.js";
-const MEDIA_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,126}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,126}$/;
-const BY_EXTENSION = {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp",
-    svg: "image/svg+xml",
-    pdf: "application/pdf",
-    doc: "application/msword",
-    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    xls: "application/vnd.ms-excel",
-    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ppt: "application/vnd.ms-powerpoint",
-    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    txt: "text/plain",
-    md: "text/markdown",
-    csv: "text/csv",
-    html: "text/html",
-    htm: "text/html",
-    css: "text/css",
-    js: "text/javascript",
-    mjs: "text/javascript",
-    ts: "text/x-typescript",
-    py: "text/x-python",
-    sh: "text/x-sh",
-    json: "application/json",
-    xml: "application/xml",
-    yaml: "application/yaml",
-    yml: "application/yaml",
-    zip: "application/zip",
-    tar: "application/x-tar",
-    gz: "application/gzip",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    mp4: "video/mp4",
-};
-/** Images the model reads as images. */
-export const MODEL_IMAGE_TYPES = Object.freeze([
-    "image/png",
-    "image/jpeg",
-    "image/webp",
-    "image/gif",
-]);
-/** The largest image or text file a model call carries inline. */
-export const MODEL_FILE_MAX_BYTES = 8 * 1024 * 1024;
-/** The type part of a `Content-Type` value, lowercased, without parameters. */
-export function essence(contentType) {
-    return contentType.split(";")[0].trim().toLowerCase();
-}
-/** A declared `Content-Type` as stored, or undefined when it is not a media type. */
-export function normalizeContentType(value) {
-    if (value === undefined)
-        return undefined;
-    const trimmed = value.trim();
-    if (trimmed === "" || trimmed.length > 255)
-        return undefined;
-    return MEDIA_TYPE.test(essence(trimmed)) ? trimmed : undefined;
-}
-/** The media type a file name implies, or `application/octet-stream`. */
-export function contentTypeFor(name) {
-    const dot = name.lastIndexOf(".");
-    if (dot < 0)
-        return DEFAULT_CONTENT_TYPE;
-    return BY_EXTENSION[name.slice(dot + 1).toLowerCase()] ?? DEFAULT_CONTENT_TYPE;
-}
-export function isModelImage(contentType) {
-    return MODEL_IMAGE_TYPES.includes(essence(contentType));
-}
-/** Files the model reads as text: `text/*`, JSON, XML, YAML and their `+json`/`+xml` kin. */
-export function isText(contentType) {
-    const type = essence(contentType);
-    return (type.startsWith("text/") ||
-        type === "application/json" ||
-        type === "application/xml" ||
-        type === "application/yaml" ||
-        type === "application/x-yaml" ||
-        type === "application/javascript" ||
-        type.endsWith("+json") ||
-        type.endsWith("+xml"));
-}
-/** The usual extension of a media type, for a name the Runtime gives a file; undefined if none. */
-export function extensionFor(contentType) {
-    const type = essence(contentType);
-    return Object.keys(BY_EXTENSION).find((extension) => BY_EXTENSION[extension] === type);
-}
-/** Word, Excel and PowerPoint documents, old and Open XML. */
-function isOffice(type) {
-    return (type === "application/msword" ||
-        type === "application/vnd.ms-excel" ||
-        type === "application/vnd.ms-powerpoint" ||
-        type.startsWith("application/vnd.openxmlformats-officedocument."));
-}
-/** The model input a file of `contentType` is, or undefined for a type no model reads. */
-export function modelInputOf(contentType) {
-    const type = essence(contentType);
-    if (isText(type))
-        return "text";
-    if (type.startsWith("image/"))
-        return "image";
-    if (type === "application/pdf")
-        return "pdf";
-    if (isOffice(type))
-        return "office";
-    if (type.startsWith("audio/"))
-        return "audio";
-    if (type.startsWith("video/"))
-        return "video";
-    return undefined;
-}
-const LABELS = {
-    text: "text files",
-    image: "images",
-    pdf: "PDFs",
-    office: "Office documents",
-    audio: "audio",
-    video: "video",
-};
-/** An input, in a sentence: "PDFs", "Office documents"; "files of this type" for none. */
-export function inputLabel(input) {
-    return input === undefined ? "files of this type" : LABELS[input];
-}
-/**
- * Why a model that reads `inputs` cannot read a file of `contentType`, or undefined when it can.
- * An image must also be PNG, JPEG, GIF or WebP.
- */
-export function unreadableReason(contentType, inputs) {
-    const input = modelInputOf(contentType);
-    if (input === undefined)
-        return `no model reads ${essence(contentType)} files`;
-    if (!inputs.includes(input))
-        return `this model does not read ${LABELS[input]}`;
-    if (input === "image" && !isModelImage(contentType))
-        return "the model reads PNG, JPEG, GIF and WebP images only";
-    return undefined;
-}

package/dist/artifacts/workspace.d.ts

@@ -1,60 +0,0 @@
-/**
- * The `WorkspaceReader` seam (F8.2): how core reads a session's sandbox workspace at turn end, to
- * export its outputs as a folder artifact. Two calls, a listing and one file's bytes, both the
- * claim of whoever holds the workspace: the Runtime stores what it is given without observing it.
- *
- * One implementation, `sandboxWorkspaceReader`, over the workspace feature (F6.2,
- * `harness-api/workspace.ts`): the in-process `SandboxManager`, or the harness that serves the
- * Tenant's workspaces (`workspace.read`). F6.2 reimplements it over the Harness API's `workspace.read`, and F7.2's pod
- * sandboxes are read through the same seam, so the export never knows which kind of sandbox it
- * reads.
- */
-import type { AgentManifest } from "@nylorun/core/define";
-import { type SandboxManager } from "../sandbox/manager.js";
-/** What the reader needs of a workspace: a `SandboxManager`, or the workspace feature. */
-export type WorkspaceFiles = Pick<SandboxManager, "listFiles" | "readBytes">;
-/** Whose workspace to read: the session whose turn ended, resolved to the workspace it uses. */
-export interface WorkspaceSession {
-    /** The session whose turn ended. */
-    readonly sessionId: string;
-    /** The turn that ended. */
-    readonly turnId: string | null;
-    /** The session that owns the workspace (one hop through `sandboxOwnerId`). */
-    readonly ownerId: string;
-    /** The sandbox resource the workspace belongs to, when the owner is attached to one. */
-    readonly environmentId?: string;
-    /** The session's pinned manifest: its `runtime` block carries the sandbox's spec. */
-    readonly manifest: AgentManifest;
-}
-/** One regular file under the listed directory. */
-export interface WorkspaceEntry {
-    /** Relative to the directory listed, `/`-separated, never `.` or `..` segments. */
-    readonly path: string;
-    readonly size: number;
-}
-export interface WorkspaceListing {
-    /** The files in path order, symbolic links left out. */
-    readonly entries: readonly WorkspaceEntry[];
-    /** More than `maxEntries` files: `entries` holds `maxEntries + 1` of them. */
-    readonly truncated: boolean;
-}
-export interface WorkspaceReader {
-    /**
-     * The regular files under `dir` (absolute, e.g. `/workspace/outputs`), recursively. Undefined
-     * when the session has no sandbox, its sandbox was never created, or `dir` is not a directory.
-     */
-    list(session: WorkspaceSession, dir: string, options: {
-        readonly maxEntries: number;
-        readonly signal: AbortSignal;
-    }): Promise<WorkspaceListing | undefined>;
-    /**
-     * One file's bytes (absolute path), or undefined when it is gone. A file larger than
-     * `maxBytes` throws `SandboxFileTooLargeError`; a sandbox that fails throws.
-     */
-    readBytes(session: WorkspaceSession, path: string, options: {
-        readonly maxBytes: number;
-        readonly signal: AbortSignal;
-    }): Promise<Uint8Array | undefined>;
-}
-/** The reader over the workspaces, in each sandbox's queue of tool calls. */
-export declare function sandboxWorkspaceReader(sandbox: WorkspaceFiles): WorkspaceReader;

package/dist/artifacts/workspace.js

@@ -1,45 +0,0 @@
-import { sandboxToolSpec } from "../sandbox/manager.js";
-import { SandboxFileTooLargeError } from "../sandbox/types.js";
-/** The reader over the workspaces, in each sandbox's queue of tool calls. */
-export function sandboxWorkspaceReader(sandbox) {
-    const target = (session) => {
-        const spec = sandboxToolSpec(session.manifest, "read");
-        if (!spec)
-            return undefined;
-        return {
-            spec,
-            ref: {
-                id: session.ownerId,
-                activeTurnId: session.turnId,
-                manifest: session.manifest,
-                ...(session.environmentId === undefined ? {} : { environmentId: session.environmentId }),
-            },
-        };
-    };
-    return {
-        async list(session, dir, options) {
-            const found = target(session);
-            if (!found)
-                return undefined;
-            const listed = await sandbox.listFiles(found.ref, found.spec, dir, options.maxEntries, options.signal);
-            if (listed.kind === "missing")
-                return undefined;
-            if (listed.kind === "failed")
-                throw new Error(listed.message);
-            return listed.listing;
-        },
-        async readBytes(session, path, options) {
-            const found = target(session);
-            if (!found)
-                return undefined;
-            const read = await sandbox.readBytes(found.ref, found.spec, path, options.maxBytes, options.signal);
-            if (read.kind === "read")
-                return read.bytes;
-            if (read.kind === "missing")
-                return undefined;
-            if (read.code === "artifact.too_large")
-                throw new SandboxFileTooLargeError(path, options.maxBytes + 1, options.maxBytes);
-            throw new Error(read.message);
-        },
-    };
-}

package/dist/media.d.ts

@@ -1,10 +0,0 @@
-/**
- * Image checks for code that handles image bytes itself (a service behind an HTTP tool):
- * the supported types, the size cap and a signature check. Storing images is the job of file
- * artifacts (`artifacts/`, protocol 6), which replaced `MediaStore`.
- */
-export declare const IMAGE_MEDIA_TYPES: readonly string[];
-export declare const MAX_IMAGE_BYTES: number;
-export declare function decodeImageBase64(mediaType: string, base64: string): Uint8Array;
-/** Verify the asserted media type and lightweight file signature for a supported image. */
-export declare function validateImageBytes(mediaType: string, bytes: Uint8Array): void;

package/dist/media.js

@@ -1,58 +0,0 @@
-/**
- * Image checks for code that handles image bytes itself (a service behind an HTTP tool):
- * the supported types, the size cap and a signature check. Storing images is the job of file
- * artifacts (`artifacts/`, protocol 6), which replaced `MediaStore`.
- */
-export const IMAGE_MEDIA_TYPES = Object.freeze([
-    "image/jpeg",
-    "image/png",
-    "image/webp",
-]);
-export const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
-export function decodeImageBase64(mediaType, base64) {
-    if (!IMAGE_MEDIA_TYPES.includes(mediaType))
-        throw new Error("Only JPEG, PNG, and WebP images are supported.");
-    if (typeof base64 !== "string" || base64 === "")
-        throw new Error("Image data is required.");
-    if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64))
-        throw new Error("Image data must be canonical base64.");
-    const decoded = atob(base64);
-    const bytes = Uint8Array.from(decoded, (character) => character.charCodeAt(0));
-    if (btoa(decoded) !== base64)
-        throw new Error("Image data must be canonical base64.");
-    validateImageBytes(mediaType, bytes);
-    return bytes;
-}
-/** Verify the asserted media type and lightweight file signature for a supported image. */
-export function validateImageBytes(mediaType, bytes) {
-    if (!IMAGE_MEDIA_TYPES.includes(mediaType))
-        throw new Error("Only JPEG, PNG, and WebP images are supported.");
-    if (bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES)
-        throw new Error("Images must be no larger than 8 MiB.");
-    const signature = mediaType === "image/jpeg"
-        ? bytes.byteLength >= 3 &&
-            bytes[0] === 0xff &&
-            bytes[1] === 0xd8 &&
-            bytes[2] === 0xff
-        : mediaType === "image/png"
-            ? bytes.byteLength >= 8 &&
-                bytes[0] === 0x89 &&
-                bytes[1] === 0x50 &&
-                bytes[2] === 0x4e &&
-                bytes[3] === 0x47 &&
-                bytes[4] === 0x0d &&
-                bytes[5] === 0x0a &&
-                bytes[6] === 0x1a &&
-                bytes[7] === 0x0a
-            : bytes.byteLength >= 12 &&
-                bytes[0] === 0x52 &&
-                bytes[1] === 0x49 &&
-                bytes[2] === 0x46 &&
-                bytes[3] === 0x46 &&
-                bytes[8] === 0x57 &&
-                bytes[9] === 0x45 &&
-                bytes[10] === 0x42 &&
-                bytes[11] === 0x50;
-    if (!signature)
-        throw new Error(`Image bytes do not match ${mediaType}.`);
-}

package/dist/sandbox/runtime-tools.d.ts

@@ -1,9 +0,0 @@
-import { type AgentManifest, type SandboxManifest } from "@nylorun/core/define";
-/**
- * The session's sandbox spec when `toolName` is one of the sandbox tools the Runtime pinned on
- * `manifest` (its `runtime` block); undefined for any other tool. A tool's name alone says whose
- * it is: an author tool may not take a Runtime tool's name.
- */
-export declare function sandboxToolSpec(manifest: AgentManifest | undefined, toolName: string | undefined): SandboxManifest | undefined;
-/** True when `toolName` is a tool the Runtime pinned on `manifest` (its `runtime.tools`). */
-export declare function isPinnedRuntimeTool(manifest: AgentManifest | undefined, toolName: string | undefined): boolean;

package/dist/sandbox/runtime-tools.js

@@ -1,16 +0,0 @@
-import { isSandboxToolName, runtimeToolOf, } from "@nylorun/core/define";
-/**
- * The session's sandbox spec when `toolName` is one of the sandbox tools the Runtime pinned on
- * `manifest` (its `runtime` block); undefined for any other tool. A tool's name alone says whose
- * it is: an author tool may not take a Runtime tool's name.
- */
-export function sandboxToolSpec(manifest, toolName) {
-    if (!toolName || !isSandboxToolName(toolName))
-        return undefined;
-    const sandbox = manifest?.runtime?.sandbox;
-    return sandbox !== undefined && runtimeToolOf(manifest, toolName) !== undefined ? sandbox : undefined;
-}
-/** True when `toolName` is a tool the Runtime pinned on `manifest` (its `runtime.tools`). */
-export function isPinnedRuntimeTool(manifest, toolName) {
-    return runtimeToolOf(manifest, toolName) !== undefined;
-}

package/dist/sandbox/session-sandbox.d.ts

@@ -1,16 +0,0 @@
-import { type AgentManifest, type SandboxManifest } from "@nylorun/core/define";
-export type SandboxedManifest = {
-    readonly ok: true;
-    readonly manifest: AgentManifest;
-    readonly manifestHash: string;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};
-/** The agent's pinned manifest with the session's sandbox, or why it cannot take one. */
-export declare function withSandbox(manifest: AgentManifest, spec: SandboxManifest): SandboxedManifest;
-/**
- * The pinned manifest of an agent session without a sandbox: `read_artifact` for each agent of
- * the tree (R2b C11, protocol 12), and the skill tools for each with skills.
- */
-export declare function withRuntimeTools(manifest: AgentManifest): SandboxedManifest;