@nylorun/runtime 0.26.0-beta → 0.28.0-beta

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/record/environment.d.ts

@@ -1,25 +0,0 @@
-import { type EnvironmentEvent, type EnvironmentEventPayload, type EnvironmentEventType } from "@nylorun/core/contracts";
-/** The Environment stream's two statements, in the caller's transaction. */
-export interface EnvironmentRecordWriter {
-    /** The seq the Environment's next event takes: one past its last, or 0. */
-    nextSeq(environmentId: string): Promise<number>;
-    insert(row: {
-        environmentId: string;
-        seq: number;
-        type: string;
-        body: EnvironmentEvent;
-    }): Promise<void>;
-}
-export interface EnvironmentAppendInput<T extends EnvironmentEventType> {
-    tenantId: string;
-    environmentId: string;
-    time: Date;
-    type: T;
-    payload: EnvironmentEventPayload<T>;
-}
-/** Builds the event and checks it against the Environment event catalog. */
-export declare function buildEnvironmentEvent<T extends EnvironmentEventType>(input: EnvironmentAppendInput<T> & {
-    seq: number;
-}): EnvironmentEvent;
-/** Appends one event to the Environment's stream through `writer`. */
-export declare function appendEnvironmentEvent<T extends EnvironmentEventType>(writer: EnvironmentRecordWriter, input: EnvironmentAppendInput<T>): Promise<EnvironmentEvent>;

package/dist/record/environment.js

@@ -1,44 +0,0 @@
-/**
- * A environment's lifecycle stream (blueprint D39, F7.1): `environment.created`, `environment.attached`,
- * `environment.detached` and `environment.deleted` (and the rest of `ENVIRONMENT_EVENT_TYPES`, egress-gate's
- * `environment.egress` for every connection among them, D67), on the `nylorun.environment-event/1` envelope, numbered
- * from 0 per environment id in `nylorun_streams.environment_events`. The record module is its only
- * writer, as for session events; the store runs the two statements through
- * `EnvironmentRecordWriter` in the caller's transaction, under the environment row's lock (or, for a
- * environment being created, its new row).
- *
- * The stream lives in the record only: it is not published to the stream relay, so no S2
- * stream follows it yet. Clients read it with `GET /v1/environmentes/{id}/events`.
- */
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { ENVIRONMENT_EVENT_PAYLOADS, ENVIRONMENT_EVENT_SCHEMA, EnvironmentEventSchema, } from "@nylorun/core/contracts";
-import { InvalidEventError } from "./envelope.js";
-/** Builds the event and checks it against the Environment event catalog. */
-export function buildEnvironmentEvent(input) {
-    const payload = ENVIRONMENT_EVENT_PAYLOADS[input.type];
-    const checkedPayload = payload.safeParse(input.payload);
-    if (!checkedPayload.success)
-        throw new InvalidEventError(input.type, z.prettifyError(checkedPayload.error));
-    const event = JSON.parse(JSON.stringify({
-        schema: ENVIRONMENT_EVENT_SCHEMA,
-        eventId: randomUUID(),
-        tenantId: input.tenantId,
-        environmentId: input.environmentId,
-        seq: input.seq,
-        time: input.time.toISOString(),
-        type: input.type,
-        payload: input.payload,
-    }));
-    const checked = EnvironmentEventSchema.safeParse(event);
-    if (!checked.success)
-        throw new InvalidEventError(input.type, z.prettifyError(checked.error));
-    return event;
-}
-/** Appends one event to the Environment's stream through `writer`. */
-export async function appendEnvironmentEvent(writer, input) {
-    const seq = await writer.nextSeq(input.environmentId);
-    const event = buildEnvironmentEvent({ ...input, seq });
-    await writer.insert({ environmentId: input.environmentId, seq, type: input.type, body: event });
-    return event;
-}

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;

package/dist/sandbox/session-sandbox.js

@@ -1,77 +0,0 @@
-/**
- * Gives a session the sandbox chosen when it was opened, and the Runtime tools its agents need.
- * An agent session's pinned manifest is its definition with a `runtime` block
- * (`runtimeManifestFor`) on each agent of the tree:
- *
- * - with a sandbox, the six sandbox tools, their instructions and the resolved spec, and
- *   `save_artifact`, so files the agent makes reach the user (F8.1). The agents it uses as tools
- *   get the same spec, so the tree shares one sandbox. The sandbox's instructions name the
- *   agent's skills' folders (`/skills/<name>@<hash>/`);
- * - with or without a sandbox, `read_artifact` (R2b C11, protocol 12): the Runtime stores a result
- *   of an MCP or HTTP tool too large to show as an artifact, and the model reads it in pages; a
- *   file of an earlier turn is a reference line the model reads again with it;
- * - with skills, `load_skill`, `read_skill_resource` and the skill catalog.
- *
- * `tool_search` and `tool_call` are not pinned: they are session tools, given per run when the
- * session defers some MCP tools (R2b C10). An author tool may not take any of these names (the
- * manifest schema refuses it), so a tool's name alone says whose it is. The definition in the
- * registry never changes.
- */
-import { AgentManifestSchema } from "@nylorun/core/contracts";
-import { hashManifest, runtimeManifestFor, } from "@nylorun/core/define";
-function isAgentManifest(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        value.kind !== "workflow" &&
-        typeof value.id === "string");
-}
-/** `manifest` with its `runtime` block, and each agent it uses as a tool with its own. */
-function pinRuntime(manifest, spec) {
-    let changed = false;
-    const tools = manifest.tools?.map((tool) => {
-        // Agents used as tools share the session's sandbox; flow agents used as tools run in linked
-        // sessions that inherit it.
-        if (tool.agent === undefined || !isAgentManifest(tool.agent))
-            return tool;
-        const agent = pinRuntime(tool.agent, spec);
-        if (agent === tool.agent)
-            return tool;
-        changed = true;
-        return { ...tool, agent };
-    });
-    const runtime = runtimeManifestFor(manifest, {
-        ...(spec === undefined ? {} : { sandbox: spec }),
-        save: spec !== undefined,
-        read: true,
-    });
-    if (runtime === undefined && !changed)
-        return manifest;
-    return {
-        ...manifest,
-        ...(changed ? { tools } : {}),
-        ...(runtime === undefined ? {} : { runtime }),
-    };
-}
-/** `pinned` checked as a manifest, with its hash. */
-function checked(original, pinned) {
-    const parsed = AgentManifestSchema.safeParse(pinned);
-    if (!parsed.success) {
-        const issues = parsed.error.issues.map((issue) => issue.message);
-        return {
-            ok: false,
-            message: `'${original.id}' cannot take the Runtime's tools: ${[...new Set(issues)].join("; ")}`,
-        };
-    }
-    return { ok: true, manifest: pinned, manifestHash: hashManifest(pinned) };
-}
-/** The agent's pinned manifest with the session's sandbox, or why it cannot take one. */
-export function withSandbox(manifest, spec) {
-    return checked(manifest, pinRuntime(manifest, spec));
-}
-/**
- * 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 function withRuntimeTools(manifest) {
-    return checked(manifest, pinRuntime(manifest, undefined));
-}

package/dist/tenant/artifact-tool.d.ts

@@ -1,13 +0,0 @@
-import type { SandboxToolOutcome } from "@nylorun/core/contracts";
-import { type ToolResultFile } from "@nylorun/core/define";
-import type { HostEffect } from "@nylorun/harness/run";
-import { type TenantContext } from "./context.js";
-export { isReadArtifactCall, isSaveArtifactCall } from "../harness/calls.js";
-export declare function callSaveArtifact(ctx: TenantContext, request: HostEffect, signal: AbortSignal): Promise<SandboxToolOutcome>;
-/** What `read_artifact` returns: a page of a text artifact, or a file the model reads. */
-interface ReadOutcome {
-    readonly kind: "completed";
-    readonly output: Record<string, unknown>;
-    readonly files?: readonly ToolResultFile[];
-}
-export declare function callReadArtifact(ctx: TenantContext, request: HostEffect, signal: AbortSignal): Promise<ReadOutcome | SandboxToolOutcome>;