@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/tenant/environments.d.ts

@@ -1,174 +0,0 @@
-import { type EnvironmentRecipe, type EnvironmentView, type ForkEnvironmentRequest, type ForkEnvironmentResponse, type PutEnvironmentRequest, type PutEnvironmentSecretRequest } from "@nylorun/core/contracts";
-import type { Environment, EnvironmentEventsQuery, Tx } from "../store/types.js";
-import type { SandboxRouteDeps } from "../core/sandbox-routes.js";
-import { type AuthScope, type Session, type TenantContext } from "./context.js";
-import type { SealedSecretCopies } from "../vault/service.js";
-/** The Environment grants that limit `scope`, or undefined when it reaches every Environment. */
-export declare function environmentGrantsOf(scope: AuthScope): readonly string[] | undefined;
-/** Who the vault's audit rows name for a request: the subject, else the application. */
-export declare function actorOf(scope: AuthScope): string;
-/** Refuses (the 404 of a missing one) Environment `id` when the caller's grants miss it. */
-export declare function assertReaches(scope: AuthScope, id: string): void;
-/** An Environment, unless it is gone or being deleted. */
-export declare function liveEnvironment(t: Tx, id: string, options?: {
-    lock?: boolean;
-}): Promise<Environment | undefined>;
-/**
- * Why input files cannot be used: each that is not a version of a Tenant-wide artifact (a
- * session's artifacts go with the session). Pins nothing else: the version is the one named.
- */
-export declare function fileErrors(t: Tx, files: EnvironmentRecipe["files"]): Promise<string[]>;
-/**
- * `PUT /v1/environments/{id}`: creates the Environment and its vault (within the Tenant's limit
- * on their number) from an environment manifest's version or from the inline fields, or finds
- * the one with this id, so "get or create" is one call. An existing one never changes what it
- * runs (D63): its labels and owner guard may change, fields that match are accepted, and any
- * other difference is `409 environment_immutable`. Every `PUT` counts as the Environment's use.
- */
-export declare function putEnvironment(ctx: TenantContext, id: string, body: PutEnvironmentRequest, scope: AuthScope, options?: {
-    fork?: Fork;
-}): Promise<EnvironmentView>;
-/**
- * The secret write `raw` asks of Environment `id` (D64). When what it runs declares secret
- * slots, the name must be one (`409 secret_not_in_manifest`), and the body is `{ value }` (or
- * `{ headers }` for a `headers` slot) with the binding from the slot; a full typed body is
- * accepted only when its binding is the slot's. Without slots, today's typed body.
- */
-export declare function secretRequestFor(ctx: TenantContext, id: string, name: string, raw: unknown): Promise<PutEnvironmentSecretRequest>;
-/** What a create does for a fork (`POST .../fork`); `copied` is filled in by the create. */
-interface Fork {
-    source: string;
-    setup: boolean;
-    /**
-     * The source's secrets sealed by keys for the new vault `vaultId` (F4.2), before the create's
-     * transaction, which inserts them; absent with `secrets: none`.
-     */
-    sealed?: {
-        vaultId: string;
-        copies: SealedSecretCopies;
-    };
-    copied?: {
-        copied: string[];
-        dropped: string[];
-    };
-}
-/**
- * `POST /v1/environments/{id}/fork` (Q15): how an Environment gets a new manifest version. A new
- * Environment `body.id` is made from the manifest version (default the source's manifest at its
- * latest), its disk started from a version of the source's (`latest` takes a snapshot first,
- * refused during a turn), and its secrets copied inside the Runtime. A fork onto other setup
- * runs that setup on the copied disk before its first turn (Q17). The source keeps what it runs,
- * its disk and its sessions. With `dryRun`, the plan only.
- */
-export declare function forkEnvironment(ctx: TenantContext, sourceId: string, body: ForkEnvironmentRequest, scope: AuthScope): Promise<ForkEnvironmentResponse>;
-/** `GET /v1/environments/{id}`. */
-export declare function getEnvironment(ctx: TenantContext, id: string, scope: AuthScope): Promise<EnvironmentView>;
-/** `GET /v1/environments?label=k=v`: every Environment with all the labels, that the caller reaches. */
-export declare function listEnvironments(ctx: TenantContext, labels: Record<string, string>, scope: AuthScope): Promise<{
-    environments: EnvironmentView[];
-}>;
-/**
- * Asks pod Environment `id` to run when it is stopped or failed (a disk copy needs its engine),
- * with its recipe applied, as a turn start would.
- */
-export declare function wakePod(ctx: TenantContext, id: string): Promise<void>;
-/** Whether a disk lease (R2d step 3) holds `environment` now. */
-export declare function diskHeld(environment: Environment, now?: number): boolean;
-/** Refused while a snapshot or restore copies the disk (a pending seed does not count). */
-export declare function refuseDiskCopy(environment: Environment): void;
-/**
- * `DELETE /v1/environments/{id}`: deletes the Environment, its vault and its workspace. Refused
- * while a session that names it has an active turn. Sessions keep its id: their next turn is
- * refused (`environment_unavailable`) unless an Environment with this id exists again.
- */
-export declare function deleteEnvironment(ctx: TenantContext, id: string, scope: AuthScope): Promise<{
-    id: string;
-    deleted: boolean;
-}>;
-/**
- * Deletes every Environment unused for its `lifecycle.deleteAfter` (Q13): no turn, recipe
- * change, secret write, stop or reset since. One with a turn running waits for the next sweep.
- * Run by the Tenant sweep.
- */
-export declare function sweepUnusedEnvironments(ctx: TenantContext, now?: number): Promise<void>;
-/**
- * `POST /v1/environments/{id}/stop`: suspends a pod Environment. Its volume is kept, and the next
- * turn of a session that names it starts it again. Refused during a turn.
- */
-export declare function stopEnvironment(ctx: TenantContext, id: string, scope: AuthScope): Promise<EnvironmentView>;
-/**
- * `POST /v1/environments/{id}/reset`: a new pod on a new, empty volume (the next volume
- * generation), with a new join token and the recipe applied; the old Sandbox and volume are
- * deleted. Leaves `lost` and `failed`. Refused during a turn, and while an earlier reset's
- * Sandbox is still being deleted.
- */
-export declare function resetEnvironment(ctx: TenantContext, id: string, scope: AuthScope): Promise<EnvironmentView>;
-/**
- * Gives pod Environment `environment` (locked) a new pod on a new, empty volume, the next volume
- * generation, with its recipe applied: the old Sandbox and volume are retired. With `seed`, the
- * new volume starts from that disk version before any turn (R2d step 3): a restore, or the
- * recovery of a lost volume.
- */
-export declare function newVolume(ctx: TenantContext, t: Tx, environment: Environment, options?: {
-    seed?: {
-        artifactId: string;
-        version: number;
-    };
-    reason?: "restore" | "lost";
-}): Promise<number>;
-/** How long a pending seed holds the disk before another process may take it over. */
-export declare const SEED_LEASE_MS: number;
-/** `GET /v1/environments/{id}/events`: the Environment's lifecycle stream. */
-export declare function environmentEventsOf(ctx: TenantContext, id: string, scope: AuthScope, query?: EnvironmentEventsQuery): Promise<{
-    events: {
-        schema: "nylorun.environment-event/1";
-        eventId: string;
-        tenantId: string;
-        environmentId: string;
-        seq: number;
-        time: string;
-        type: "environment.attached" | "environment.created" | "environment.deleted" | "environment.detached" | "environment.egress" | "environment.failed" | "environment.forked" | "environment.lost" | "environment.relaunched" | "environment.reset" | "environment.running" | "environment.suspended";
-        payload: Record<string, unknown>;
-    }[];
-}>;
-/**
- * Opens a new session on Environment `id` (`PutSessionRequest.environment`): it must exist, be
- * reachable with `grants` and pass its owner guard. Runs in the session's transaction, after
- * its session row lock; holds the Environment's row lock.
- */
-export declare function openEnvironment(t: Tx, id: string, options: {
-    grants?: readonly string[];
-    ownerUserId: string;
-    opaque: boolean;
-}): Promise<Environment>;
-/** Records the attachment on the session's log and on the Environment's stream. */
-export declare function recordAttachment(t: Tx, sessionId: string, environmentId: string): Promise<void>;
-/**
- * Checks a turn start on a session that names an Environment, in the command's transaction
- * after the session row lock: the Environment still exists, a token caller's grants reach it,
- * its owner guard admits the session's owner, and no disk copy holds it. Other sessions' turns
- * do not stop it (D66). Holds the Environment row's lock until the transaction ends, so a turn
- * start and disk work on one Environment are decided one after the other.
- *
- * A pod Environment must also be usable: not lost (`environment_lost`), on a Runtime with
- * sandbox pods (`environment_unavailable`). A stopped or failed pod is asked to run again, with
- * its recipe applied, after the commit.
- */
-export declare function checkEnvironmentTurn(t: Tx, session: Session, scope: AuthScope, ctx?: TenantContext): Promise<void>;
-/** A sessions reset detaches every session from its Environment: each one's stream says so. */
-export declare function detachAllSessions(t: Tx): Promise<void>;
-/**
- * Marks the end of a turn's segment on Environment `id`: it was used now (`deleteAfter` counts
- * from here), and for a running pod idle counts from now and the idle timer is armed (D34).
- * Best effort.
- */
-export declare function touchEnvironment(ctx: TenantContext, id: string): Promise<void>;
-/**
- * Re-arms the idle timer of every running pod after the Tenant's settings change, so a shorter
- * `limits.idle` applies to pods already idle (D36: the settings are read whenever a timer is
- * set). Best effort.
- */
-export declare function rearmPodTimers(ctx: TenantContext): Promise<void>;
-/** Session lookups for the sandbox route handlers (`core/sandbox-routes.ts`). */
-export declare function sandboxRouteDeps(ctx: TenantContext): SandboxRouteDeps;
-export {};

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

@@ -1,20 +0,0 @@
-/**
- * The skill tools (track R2 M4): `load_skill` and `read_skill_resource`, which the Runtime pins
- * in the `runtime` block of an agent with skills. The Runtime runs them itself, like `save_artifact`, from the
- * definition files uploaded with the agent: no developer process is involved.
- *
- * - `load_skill`: the skill's instructions (its `SKILL.md` after the frontmatter), the paths of
- *   its other files, and, when the session has a sandbox, where they are in it
- *   (`/skills/<name>@<hash>/`, read-only, D66).
- * - `read_skill_resource`: one text file of the skill. A binary file is refused: the model reads
- *   it in the sandbox, when there is one.
- *
- * Expected problems are failed outcomes the model sees; only infrastructure errors throw.
- */
-import type { SandboxToolOutcome } from "@nylorun/core/contracts";
-import { type AgentManifest } from "@nylorun/core/define";
-import type { HostEffect } from "@nylorun/harness/run";
-import type { TenantContext } from "./context.js";
-/** True when `request` calls a skill tool the Runtime serves for `manifest`'s agent. */
-export declare function isSkillToolCall(manifest: AgentManifest | undefined, request: HostEffect): boolean;
-export declare function callSkillTool(ctx: TenantContext, manifest: AgentManifest, request: HostEffect, signal: AbortSignal): Promise<SandboxToolOutcome>;

package/dist/tenant/skill-tool.js

@@ -1,67 +0,0 @@
-import { LOAD_SKILL_TOOL, SKILL_ENTRY, skillFolderOf, isSkillTool, skillInstructions, } from "@nylorun/core/define";
-import { sandboxToolSpec } from "../sandbox/runtime-tools.js";
-import { readDefinitionFile } from "./definition-files.js";
-const failed = (code, message) => ({ kind: "failed", code, message });
-/** True when `request` calls a skill tool the Runtime serves for `manifest`'s agent. */
-export function isSkillToolCall(manifest, request) {
-    return request.kind === "tool" && isSkillTool(manifest, request.toolName);
-}
-/** Every skill of the agent, by name. */
-function skillsOf(manifest) {
-    return new Map(Object.values(manifest.skills ?? {}).map((skill) => [skill.name, skill]));
-}
-/** UTF-8 text, or undefined for bytes that are not (a NUL byte, or invalid UTF-8). */
-function textOf(bytes) {
-    if (bytes.includes(0))
-        return undefined;
-    try {
-        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function callSkillTool(ctx, manifest, request, signal) {
-    const input = (request.input ?? {});
-    const skills = skillsOf(manifest);
-    const name = typeof input.name === "string" ? input.name : "";
-    const skill = skills.get(name);
-    if (!skill)
-        return request.toolName === LOAD_SKILL_TOOL
-            ? { kind: "completed", output: { unknown: name, available: [...skills.keys()].sort() } }
-            : failed("skill.unknown", `There is no skill '${name}'.`);
-    const sandboxed = sandboxToolSpec(manifest, "bash") !== undefined;
-    const directory = `${skillFolderOf(skill)}/`;
-    const read = async (path) => {
-        const bytes = await readDefinitionFile(ctx.blobs, skill.files[path], signal);
-        if (!bytes)
-            throw new Error(`The bytes of ${skill.files[path]} (${skill.name}/${path}) are missing from the Object store`);
-        return bytes;
-    };
-    if (request.toolName === LOAD_SKILL_TOOL) {
-        const text = textOf(await read(SKILL_ENTRY));
-        if (text === undefined)
-            return failed("skill.binary_resource", `${SKILL_ENTRY} of '${skill.name}' is not text.`);
-        const resources = Object.keys(skill.files)
-            .filter((path) => path !== SKILL_ENTRY)
-            .sort();
-        return {
-            kind: "completed",
-            output: {
-                name: skill.name,
-                content: skillInstructions(text),
-                ...(resources.length === 0 ? {} : { resources }),
-                ...(sandboxed ? { sandboxPath: directory } : {}),
-            },
-        };
-    }
-    const path = typeof input.path === "string" ? input.path : "";
-    if (skill.files[path] === undefined)
-        return failed("skill.unknown_resource", `Skill '${skill.name}' has no resource '${path}'.`);
-    const content = textOf(await read(path));
-    if (content === undefined)
-        return failed("skill.binary_resource", sandboxed
-            ? `${path} is not a text file. It is in the sandbox at ${directory}${path}; use it there.`
-            : `${path} is not a text file; only text files can be read without a sandbox.`);
-    return { kind: "completed", output: { name: skill.name, path, content } };
-}

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

@@ -1,57 +0,0 @@
-import type { HostEffect } from "@nylorun/harness/run";
-import type { TenantContext } from "./context.js";
-/** The most of one tool result that is recorded inline (Q22): 32 KiB, as JSON. */
-export declare const TOOL_RESULT_INLINE_BYTES: number;
-/** How much of a stored result's start, and of its end, the preview keeps. */
-export declare const PREVIEW_HEAD_BYTES: number;
-export declare const PREVIEW_TAIL_BYTES = 1024;
-/**
- * The most one step's results may hold together: a step's results are one transcript entry, so
- * one event, which must stay well under S2's 1 MiB record.
- */
-export declare const STEP_RESULTS_BUDGET_BYTES: number;
-/** A result's cap once its step's budget is spent: a stub naming its artifact. */
-export declare const TOOL_RESULT_STUB_BYTES = 512;
-/** A result this small is never shaped, nor counted against its step's budget. */
-export declare const TOOL_RESULT_SMALL_BYTES = 1024;
-/** The call whose outcome is shaped, and the session its artifacts belong to. */
-export interface ShapedCall {
-    readonly request: HostEffect;
-    readonly session: {
-        readonly id: string;
-        readonly ownerUserId: string;
-    };
-    /** A remote MCP tool's: its output may be the server's content parts. */
-    readonly mcp: boolean;
-    /** This result's cap (`resultLimit`). Default `TOOL_RESULT_INLINE_BYTES`. */
-    readonly limit?: number;
-}
-/** A result's cap when the other results of its step already took `used` bytes. */
-export declare function resultLimit(used: number): number;
-/** The JSON size of `value` in bytes: what it adds to an event or a prompt. */
-export declare function jsonBytes(value: unknown): number;
-/**
- * What a tool outcome's result weighs in its step's transcript entry: a completed one's output,
- * a failed one's message; 0 for anything else, such as a model call's outcome.
- */
-export declare function resultBytes(value: unknown): number;
-/**
- * False for an outcome `shapeToolOutcome` returns as it is, whatever made it: a model call's, a
- * small tool result with no parts. Spares a look at the effect for most outcomes.
- */
-export declare function mayNeedShaping(value: unknown): boolean;
-/**
- * The outcome `value` of `call`, shaped to fit its cap (see the module comment). An outcome that
- * fits and has no binary part comes back as it is.
- */
-export declare function shapeToolOutcome(ctx: TenantContext, call: ShapedCall, value: unknown, signal: AbortSignal): Promise<unknown>;
-/**
- * The start and end of `text` in whole characters, `budget` bytes split four to one: by default
- * the first `PREVIEW_HEAD_BYTES` and the last `PREVIEW_TAIL_BYTES`.
- */
-export declare function previewOf(text: string, budget?: number): string;
-/**
- * The nearest character boundary of the UTF-8 `bytes` at or before (`down`) or at or after
- * (`up`) byte `at`: never inside a character.
- */
-export declare function utf8Boundary(bytes: Uint8Array, at: number, direction: "down" | "up"): number;

package/dist/tenant/tool-results.js

@@ -1,298 +0,0 @@
-/**
- * Tool results that fit (R2b C11, Q22–Q24): core shapes what an agent's remote MCP tool or HTTP
- * tool returned before it records the outcome (`harness-api/record.ts`), so no journal row,
- * event or prompt holds more of one result than the inline cap. The gate already refused an
- * answer past 8 MiB (`mcp.too-large`, `http.too-large`).
- *
- * - An `image`, `audio` or blob `resource` part becomes a file artifact of the session, and the
- *   part says `{artifactId, version, contentType, size}`. An image also goes to the model as a
- *   file (`ToolOutcome.files`), which the model call shows to a model that reads images (Q23).
- * - Text or JSON past `TOOL_RESULT_INLINE_BYTES` (32 KiB, Q22) becomes a file artifact, and the
- *   model gets `{truncated: true, artifactId, size, preview}`: the first 4 KiB and the last 1 KiB.
- *   In a result of several parts each part is shaped alone, the largest text first, until the
- *   whole fits; one that still does not is stored whole.
- * - A `resource_link` stays a link, never fetched, and a text resource that fits stays inline.
- * - A failed outcome's message is cut to its start and end.
- * - When an artifact cannot be stored (the Tenant's artifact limits, an Object store that
- *   fails), the preview stays and `dropped` says why the rest is gone: a result never passes
- *   the cap. Only an abort throws.
- * - **One step's results share a budget** (`STEP_RESULTS_BUDGET_BYTES`, 256 KiB), since the
- *   transcript keeps a step's results in one entry, one event: the record seam counts what the
- *   step's other results took, under the session lock, and gives this one the rest as its cap
- *   (`resultLimit`). Once the budget is spent, a result past `TOOL_RESULT_SMALL_BYTES` becomes a
- *   stub naming its artifact, its preview cut to fit `TOOL_RESULT_STUB_BYTES`.
- *
- * The model reads a stored result with `read_artifact` (`artifact-tool.ts`). Artifacts are the
- * session's, saved by our engine (`source: "engine"`), with the turn and the tool call on their
- * `artifact.created` event.
- */
-import { READ_ARTIFACT_MAX_BYTES } from "@nylorun/core/define";
-import { MODEL_FILE_MAX_BYTES, extensionFor, isModelImage, isText, normalizeContentType, } from "../artifacts/media-types.js";
-import { uploadArtifact } from "../artifacts/service.js";
-import { DEFAULT_CONTENT_TYPE } from "../blob/index.js";
-import { HttpError } from "./http.js";
-import { toolIds } from "./transcript.js";
-/** The most of one tool result that is recorded inline (Q22): 32 KiB, as JSON. */
-export const TOOL_RESULT_INLINE_BYTES = READ_ARTIFACT_MAX_BYTES;
-/** How much of a stored result's start, and of its end, the preview keeps. */
-export const PREVIEW_HEAD_BYTES = 4 * 1024;
-export const PREVIEW_TAIL_BYTES = 1024;
-/**
- * The most one step's results may hold together: a step's results are one transcript entry, so
- * one event, which must stay well under S2's 1 MiB record.
- */
-export const STEP_RESULTS_BUDGET_BYTES = 256 * 1024;
-/** A result's cap once its step's budget is spent: a stub naming its artifact. */
-export const TOOL_RESULT_STUB_BYTES = 512;
-/** A result this small is never shaped, nor counted against its step's budget. */
-export const TOOL_RESULT_SMALL_BYTES = 1024;
-/** A result's cap when the other results of its step already took `used` bytes. */
-export function resultLimit(used) {
-    return Math.max(TOOL_RESULT_STUB_BYTES, Math.min(TOOL_RESULT_INLINE_BYTES, STEP_RESULTS_BUDGET_BYTES - used));
-}
-/** The JSON size of `value` in bytes: what it adds to an event or a prompt. */
-export function jsonBytes(value) {
-    return Buffer.byteLength(JSON.stringify(value) ?? "null");
-}
-/**
- * What a tool outcome's result weighs in its step's transcript entry: a completed one's output,
- * a failed one's message; 0 for anything else, such as a model call's outcome.
- */
-export function resultBytes(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return 0;
-    const outcome = value;
-    if (outcome.kind === "failed")
-        return typeof outcome.message === "string" ? Buffer.byteLength(outcome.message) : 0;
-    if (outcome.kind !== "completed" || outcome.output === undefined)
-        return 0;
-    return jsonBytes(outcome.output);
-}
-/**
- * False for an outcome `shapeToolOutcome` returns as it is, whatever made it: a model call's, a
- * small tool result with no parts. Spares a look at the effect for most outcomes.
- */
-export function mayNeedShaping(value) {
-    const output = value?.output;
-    if (value?.kind === "completed" && Array.isArray(output))
-        return true;
-    return resultBytes(value) > TOOL_RESULT_SMALL_BYTES;
-}
-/**
- * The outcome `value` of `call`, shaped to fit its cap (see the module comment). An outcome that
- * fits and has no binary part comes back as it is.
- */
-export async function shapeToolOutcome(ctx, call, value, signal) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const outcome = value;
-    const limit = call.limit ?? TOOL_RESULT_INLINE_BYTES;
-    if (outcome.kind === "failed" && typeof outcome.message === "string")
-        return Buffer.byteLength(outcome.message) > limit
-            ? { ...outcome, message: cutMessage(outcome.message, limit) }
-            : value;
-    if (outcome.kind !== "completed" || outcome.output === undefined)
-        return value;
-    const shaping = { ...call, limit, ctx, signal, files: [] };
-    let output = outcome.output;
-    if (call.mcp && isContentParts(output))
-        output = await shapeParts(shaping, output);
-    let truncated = false;
-    if (jsonBytes(output) > limit) {
-        output = await storedWhole(shaping, output);
-        truncated = true;
-    }
-    if (output === outcome.output)
-        return value;
-    return {
-        ...outcome,
-        output,
-        ...(shaping.files.length > 0 ? { files: shaping.files } : {}),
-        ...(truncated ? { truncated: true } : {}),
-    };
-}
-/** True for an MCP `content` array: objects with a `type` each. */
-function isContentParts(value) {
-    return (Array.isArray(value) &&
-        value.length > 0 &&
-        value.every((part) => !!part &&
-            typeof part === "object" &&
-            !Array.isArray(part) &&
-            typeof part.type === "string"));
-}
-/** An MCP result's parts: binary ones stored, then the largest text ones until the whole fits. */
-async function shapeParts(shaping, parts) {
-    const shaped = [];
-    for (const [index, part] of parts.entries())
-        shaped.push(await shapeBinary(shaping, part, index));
-    const texts = shaped
-        .map((part, index) => ({ index, bytes: textOf(part) === undefined ? 0 : jsonBytes(part) }))
-        .filter((item) => item.bytes > 0)
-        .sort((a, b) => b.bytes - a.bytes);
-    for (const { index } of texts) {
-        if (jsonBytes(shaped) <= shaping.limit)
-            break;
-        const part = shaped[index];
-        const text = textOf(part);
-        const resource = part.type === "resource" ? part.resource : undefined;
-        const contentType = resource ? textType(resource.mimeType) : "text/plain; charset=utf-8";
-        const kept = await store(shaping, text, contentType, nameOf(shaping, contentType, index));
-        shaped[index] = withPreview({
-            type: part.type,
-            ...(resource && typeof resource.uri === "string" ? { uri: resource.uri } : {}),
-            truncated: true,
-            ...kept,
-        }, text, shaping.limit);
-    }
-    return shaped;
-}
-/** An `image`, `audio` or blob `resource` part, stored; any other part as it is. */
-async function shapeBinary(shaping, part, index) {
-    const resource = part.type === "resource" && part.resource && typeof part.resource === "object"
-        ? part.resource
-        : undefined;
-    const data = part.type === "image" || part.type === "audio"
-        ? part.data
-        : resource !== undefined
-            ? resource.blob
-            : undefined;
-    if (typeof data !== "string")
-        return part;
-    const declared = resource ? resource.mimeType : part.mimeType;
-    const contentType = (typeof declared === "string" ? normalizeContentType(declared) : undefined) ??
-        DEFAULT_CONTENT_TYPE;
-    const name = nameOf(shaping, contentType, index);
-    const kept = await store(shaping, Buffer.from(data, "base64"), contentType, name);
-    // An image the model reads goes to it as a file, beside the part (Q23).
-    if (part.type === "image" &&
-        "artifactId" in kept &&
-        isModelImage(contentType) &&
-        kept.size <= MODEL_FILE_MAX_BYTES)
-        shaping.files.push({
-            mediaType: contentType,
-            reference: { artifactId: kept.artifactId, version: kept.version, name, size: kept.size },
-        });
-    return {
-        type: part.type,
-        ...(resource && typeof resource.uri === "string" ? { uri: resource.uri } : {}),
-        ...("artifactId" in kept ? kept : { contentType, ...kept }),
-    };
-}
-/** The text a part carries inline: a text part's, or a text resource's. */
-function textOf(part) {
-    if (part.type === "text" && typeof part.text === "string")
-        return part.text;
-    if (part.type === "resource" && part.resource && typeof part.resource === "object") {
-        const text = part.resource.text;
-        if (typeof text === "string")
-            return text;
-    }
-    return undefined;
-}
-function textType(declared) {
-    const type = typeof declared === "string" ? normalizeContentType(declared) : undefined;
-    return type !== undefined && isText(type) ? type : "text/plain; charset=utf-8";
-}
-/** `value` stored whole, as text or JSON, and the preview the model gets. */
-async function storedWhole(shaping, value) {
-    const text = typeof value === "string" ? value : JSON.stringify(value);
-    const contentType = typeof value === "string" ? "text/plain; charset=utf-8" : "application/json";
-    const kept = await store(shaping, text, contentType, nameOf(shaping, contentType));
-    return withPreview({ truncated: true, ...kept }, text, shaping.limit);
-}
-/**
- * `stub` with the preview of `text`: the first 4 KiB and the last 1 KiB, or less, so that the
- * whole fits `limit` (a step's budget spent, R2b C11); none when even a little does not.
- */
-function withPreview(stub, text, limit) {
-    let budget = Math.min(PREVIEW_HEAD_BYTES + PREVIEW_TAIL_BYTES, limit);
-    for (;;) {
-        const shaped = { ...stub, preview: previewOf(text, budget) };
-        const over = jsonBytes(shaped) - limit;
-        if (over <= 0 || budget === 0)
-            return shaped;
-        budget = budget - over < 64 ? 0 : budget - over;
-    }
-}
-/** Stores `body` as an artifact of the call's session, or says why it was not. */
-async function store(shaping, body, contentType, name) {
-    const bytes = typeof body === "string" ? Buffer.from(body, "utf8") : body;
-    const { ctx, request, session, signal } = shaping;
-    const ids = toolIds(request.context);
-    try {
-        const saved = await uploadArtifact(ctx, {
-            name,
-            contentType,
-            sessionId: session.id,
-            source: "engine",
-            turnId: request.turnId,
-            ...("callId" in ids ? { callId: ids.callId } : {}),
-        }, bytes, 
-        // Into the call's own session only.
-        { owner: session.ownerUserId }, signal);
-        return {
-            artifactId: saved.artifact.artifactId,
-            version: saved.version.version,
-            contentType: saved.version.contentType,
-            size: saved.version.size,
-        };
-    }
-    catch (error) {
-        if (signal.aborted)
-            throw error;
-        // A limit is the Tenant's to raise; any other failure is the store's. Never the bytes.
-        ctx.config.logger.warn("tool_result_not_stored", {
-            session: session.id,
-            effect: request.effectId,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return {
-            dropped: error instanceof HttpError
-                ? `The result could not be stored as an artifact: ${error.message}`
-                : "The result could not be stored as an artifact",
-            size: bytes.byteLength,
-        };
-    }
-}
-/** A name for a stored result: the tool's, with the part's number and the type's extension. */
-function nameOf(shaping, contentType, index) {
-    const tool = (shaping.request.toolName ?? "tool").replace(/[^A-Za-z0-9_.-]/gu, "_");
-    const extension = extensionFor(contentType) ?? "bin";
-    return `${tool.slice(0, 200)}-result${index === undefined ? "" : `-${index + 1}`}.${extension}`;
-}
-/**
- * The start and end of `text` in whole characters, `budget` bytes split four to one: by default
- * the first `PREVIEW_HEAD_BYTES` and the last `PREVIEW_TAIL_BYTES`.
- */
-export function previewOf(text, budget = PREVIEW_HEAD_BYTES + PREVIEW_TAIL_BYTES) {
-    const bytes = Buffer.from(text, "utf8");
-    if (bytes.byteLength <= budget)
-        return text;
-    if (budget <= 0)
-        return "";
-    const tailBytes = Math.floor(budget / 5);
-    const head = utf8Boundary(bytes, budget - tailBytes, "down");
-    const tail = utf8Boundary(bytes, bytes.byteLength - tailBytes, "up");
-    return `${bytes.subarray(0, head).toString("utf8")}\n…\n${bytes.subarray(tail).toString("utf8")}`;
-}
-/** A message past `limit`: its start and end, and how long it was. */
-function cutMessage(message, limit) {
-    const note = `\n(The message was ${Buffer.byteLength(message)} bytes; its middle is not shown.)`;
-    const budget = Math.min(PREVIEW_HEAD_BYTES + PREVIEW_TAIL_BYTES, limit - note.length - 16);
-    return `${previewOf(message, Math.max(0, budget))}${note}`;
-}
-/**
- * The nearest character boundary of the UTF-8 `bytes` at or before (`down`) or at or after
- * (`up`) byte `at`: never inside a character.
- */
-export function utf8Boundary(bytes, at, direction) {
-    let position = Math.max(0, Math.min(at, bytes.byteLength));
-    const inside = (index) => index < bytes.byteLength && (bytes[index] & 0xc0) === 0x80;
-    if (direction === "down")
-        while (position > 0 && inside(position))
-            position -= 1;
-    else
-        while (inside(position))
-            position += 1;
-    return position;
-}

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

@@ -1,39 +0,0 @@
-import type { HostEffect } from "@nylorun/harness/run";
-import { type McpSnapshot, type McpToolRecord } from "../mcp/snapshot.js";
-import { type TenantContext } from "./context.js";
-/**
- * True when `request` calls `tool_search`, the session tool an agent gets when the session's
- * pinned snapshot holds deferred tools of its own. The name is reserved: no tool of the agent's
- * own takes it.
- */
-export declare function isToolSearchCall(snapshot: McpSnapshot | undefined, request: HostEffect): boolean;
-/** Runs `tool_search` for the run's agent. */
-export declare function callToolSearch(ctx: TenantContext, request: HostEffect): Promise<{
-    output?: undefined;
-    kind: string;
-    code: string;
-    message: string;
-} | {
-    code?: undefined;
-    message?: undefined;
-    kind: string;
-    output: {
-        tools: {
-            name: string;
-            description?: string | undefined;
-            inputSchema: import("@nylorun/core/define").JsonObject;
-        }[];
-        message?: string | undefined;
-    };
-}>;
-/**
- * Lower-case words of `text`: `camelCase`, `snake_case` and `kebab-case` split into words, and a
- * plural `s` dropped (`issues` finds `issue`).
- */
-export declare function tokens(text: string): string[];
-/**
- * The tools that match `query`, best first, by BM25 over each tool's name (counted twice, with
- * the server's own name for it) and description. A tool no word of the query is in is left out;
- * ties keep the snapshot's order.
- */
-export declare function rank(tools: readonly McpToolRecord[], query: string): McpToolRecord[];