@nylorun/agents 0.19.1-beta → 0.21.0-beta

package/dist/session-client.d.ts

@@ -3,10 +3,10 @@
  * which resolves the connection from the environment or the Project link.
  */
 import type { AgentManifest, BuiltAgent, BuiltWorkflow, JsonValue, SandboxToolName, WorkflowManifest } from "@nylorun/core/define";
-import { type SessionItemsResponse, type SessionSummary, type ListAgentsResponse, type ListPublicAgentsResponse, type SubjectScope, type CredentialSelection, type MessagePart, type SandboxRequest, type SessionCommand } from "@nylorun/core/contracts";
+import { type SessionItemsResponse, type SessionSummary, type ListAgentsResponse, type ListPublicAgentsResponse, type SubjectScope, type MessagePart, type SessionCommand } from "@nylorun/core/contracts";
 import { SessionsReadClient } from "./reads.js";
 import { AccessClient } from "./access.js";
-import { SandboxesClient } from "./sandboxes.js";
+import { EnvironmentsClient } from "./environments.js";
 import { ArtifactsClient } from "./artifacts.js";
 import { FilesClient } from "./files.js";
 import { Transport, type Destination } from "./http.js";
@@ -20,8 +20,6 @@ export interface AgentSource {
     build?(): BuiltAgent | BuiltWorkflow;
     getBinding?: BuiltAgent["getBinding"] | BuiltWorkflow["getBinding"];
 }
-/** Closures stay on the live binding. The published manifest cannot name them. */
-export declare function assertNoMiddlewareClosures(agent: AgentSource): void;
 export interface SessionView {
     id: string;
     agentId: string;
@@ -38,16 +36,12 @@ export interface CreateSessionOptions {
     ownerUserId: string;
     info?: Record<string, unknown>;
     requestId?: string;
-    vaultIds?: readonly string[];
-    credentialSelections?: readonly CredentialSelection[];
     /**
-     * The session's sandbox: omit for the Tenant default, `false` for none, `{ id }` to attach a
-     * sandbox resource (`client.sandboxes`, Host feature `sandboxes`), or an inline sandbox
-     * (`image`, `network.allow`, `resources`) checked against the Tenant's limits. `{ session }`
-     * shares another session's and is deprecated: use `client.sandboxes.forSession()` or
-     * `ensure()` and `{ id }`. Fixed once the session exists.
+     * The Environment the session runs in (`client.environments`): its sandbox, and its vault's
+     * credentials for the session's shell, MCP servers and HTTP tools. Omit for no sandbox and no
+     * credentials. Fixed once the session exists.
      */
-    sandbox?: SandboxRequest;
+    environment?: string;
 }
 export interface ActAsOptions {
     /** What the subject may do; the Runtime grants nothing else. Default `["sessions:own"]`. */
@@ -61,17 +55,18 @@ export declare class AgentsClient {
     /**
      * A client that acts for `subject`: every call sends `Nylorun-Subject` and
      * `Nylorun-Scopes`, and the Runtime limits it to the scopes and to the subject's own sessions
-     * and vaults (Host feature `subject-headers`). For app servers, which authenticate the person
+     * (Host feature `subject-headers`). For app servers, which authenticate the person
      * themselves and hold the key; nothing is minted, cached or refreshed.
      */
     as(subject: string, options?: ActAsOptions): AgentsClient;
     /** The public keys that verify the tokens the Tenant signs. */
     get access(): AccessClient;
     /**
-     * Sandboxes as a resource (Host feature `sandboxes`): `ensure` one by id, `list` them by
-     * label, `delete` one, or give a session its own with `forSession`.
+     * Environments (protocol 11): `put` one by id (create, find or change), write its `secrets`,
+     * `list` them by label, `stop`, `reset` or `delete` one, or give a session its own with
+     * `forSession`.
      */
-    get sandboxes(): SandboxesClient;
+    get environments(): EnvironmentsClient;
     /** File artifacts: upload, list, download with Range, capability links (protocol 6). */
     get artifacts(): ArtifactsClient;
     /** Definition files: the skill files a definition names, by content hash. */
@@ -98,12 +93,14 @@ export declare class AgentsClient {
      * Registers the agent's definition (`PUT /v1/agents/{id}`), first uploading the skill files
      * it names that the Runtime does not hold. A definition with a tool that runs your code
      * (`tool({ run })`, a flow's tool stage) is refused before anything is sent: the Runtime runs
-     * no code of yours during a session. `implementationVersion` defaults to
-     * `NYLORUN_IMPLEMENTATION_VERSION`, else `dev`.
+     * agents from their manifests alone. `implementationVersion` defaults to
+     * `NYLORUN_IMPLEMENTATION_VERSION`, else `dev`. `dryRun` (protocol 14) runs every check and
+     * saves nothing; the skill files are still uploaded, since they are stored by content.
      */
     saveAgent(agent: AgentSource | BuiltWorkflow, options?: {
         implementationVersion?: string;
         requestId?: string;
+        dryRun?: boolean;
     }): Promise<unknown>;
     createSession(options: CreateSessionOptions): Promise<SessionClient>;
     session(sessionId: string): SessionClient;
@@ -206,6 +203,7 @@ export declare class SessionClient {
     }): Promise<{
         calls: {
             id: string;
+            effectId: string;
             sessionId: string;
             turnId: string;
             agentId: string;
@@ -229,6 +227,91 @@ export declare class SessionClient {
         nextCursor: string | null;
         asOf: string;
     }>;
+    /**
+     * The session's tool calls (R5, Host feature `tool-calls`), in the order they were first sent:
+     * each one's tool, input, status and sends. `attempts` above 1: a crash re-sent it.
+     */
+    toolCalls(options?: {
+        turnId?: string;
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        calls: {
+            effectId: string;
+            turnId: string;
+            callId: string | null;
+            toolName: string | null;
+            kind: "harness" | "http" | "mcp" | "platform" | "sandbox" | null;
+            server: string | null;
+            skill: string | null;
+            plugin: {
+                name: string;
+                version?: string | undefined;
+            } | null;
+            status: "cancelled" | "completed" | "failed" | "held" | "invoking" | "uncertain";
+            attempts: number;
+            input: unknown;
+            error: {
+                code: string;
+                message: string;
+            } | null;
+            startedAt: string | null;
+            settledAt: string | null;
+            durationMs: number | null;
+        }[];
+        nextCursor: string | null;
+        asOf: string;
+    }>;
+    /**
+     * A turn's trace (R7, Host feature `traces`): its spans as OTLP/HTTP JSON (`resourceSpans`), as
+     * the Runtime posts them to an OTLP collector. Post it to a collector's `/v1/traces` to backfill
+     * one, or read it without one.
+     */
+    trace(turnId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        [x: string]: unknown;
+        resourceSpans: {
+            [x: string]: unknown;
+            resource: {
+                [x: string]: unknown;
+                attributes: {
+                    [x: string]: unknown;
+                    key: string;
+                    value: Record<string, unknown>;
+                }[];
+            };
+            scopeSpans: {
+                [x: string]: unknown;
+                scope: {
+                    [x: string]: unknown;
+                    name: string;
+                    version?: string | undefined;
+                };
+                spans: {
+                    [x: string]: unknown;
+                    traceId: string;
+                    spanId: string;
+                    parentSpanId?: string | undefined;
+                    name: string;
+                    kind: number;
+                    startTimeUnixNano: string;
+                    endTimeUnixNano: string;
+                    attributes: {
+                        [x: string]: unknown;
+                        key: string;
+                        value: Record<string, unknown>;
+                    }[];
+                    status: {
+                        [x: string]: unknown;
+                        code: number;
+                        message?: string | undefined;
+                    };
+                }[];
+            }[];
+        }[];
+    }>;
     /** `agent` narrows to one agent used as a tool: its delegationId or its path. */
     history(options: {
         cursor?: string;
@@ -261,10 +344,14 @@ export declare class SessionClient {
         time: string;
         schemaVersion: number;
         source: {
-            kind: "api" | "controller" | "edge" | "egress-gate" | "evidence" | "harness" | "human" | "init" | "loop" | "model-gate" | "operator" | "sandboxes" | "supervisor" | "tool-gate";
+            kind: "api" | "client" | "controller" | "core" | "edge" | "egress-gate" | "evidence" | "harness" | "human" | "init" | "loop" | "model-gate" | "operator" | "sandboxes" | "supervisor" | "tool-gate";
             id: string;
         };
         evidence: "asserted" | "attested" | "claimed" | "measured" | "observed";
+        principal?: {
+            kind: "application" | "core" | "flow-host" | "subject";
+            id: string;
+        } | undefined;
         trace?: {
             traceId: string;
             spanId: string;
@@ -286,5 +373,5 @@ export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
 export type { Destination, IncompatibleReason } from "./http.js";
 export type { LiveEvent } from "@nylorun/core/contracts";
 export { AccessClient } from "./access.js";
-export { SandboxesClient } from "./sandboxes.js";
-export type { ForSessionOptions, SandboxSpec, SessionSandboxHandle } from "./sandboxes.js";
+export { EnvironmentManifestsClient, EnvironmentSecretsClient, EnvironmentsClient, environmentFiles, environmentManifest, } from "./environments.js";
+export type { EnvironmentFileBytes, EnvironmentInput, EnvironmentManifestInput, EnvironmentSecretInput, ForSessionOptions, SessionEnvironmentHandle, } from "./environments.js";

package/dist/session-client.js

@@ -1,10 +1,10 @@
-import { SANDBOX_TOOL_NAMES, codeToolRefusal, delegateOf, isBuiltWorkflow, isSandboxToolName, } from "@nylorun/core/define";
+import { SANDBOX_TOOL_NAMES, approvalRefusal, codeToolRefusal, delegateOf, isBuiltWorkflow, isSandboxToolName, } from "@nylorun/core/define";
 import { z } from "zod";
 import { SCOPES_HEADER, SUBJECT_HEADER } from "@nylorun/core/compatibility";
-import { SessionManifestViewSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, parseSessionEvent, parseSubjectHeaders, } from "@nylorun/core/contracts";
+import { SessionManifestViewSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, ToolCallsPageSchema, TurnTraceSchema, parseSessionEvent, parseSubjectHeaders, } from "@nylorun/core/contracts";
 import { SessionsReadClient } from "./reads.js";
 import { AccessClient } from "./access.js";
-import { SandboxesClient } from "./sandboxes.js";
+import { EnvironmentsClient } from "./environments.js";
 import { ArtifactsClient } from "./artifacts.js";
 import { FilesClient } from "./files.js";
 import { Transport, env, id, segment } from "./http.js";
@@ -30,7 +30,6 @@ function linkedSessionId(event) {
         ? sessionId
         : undefined;
 }
-const middlewareClosure = "Hosted definitions support declarative capabilities, not middleware closures";
 /** The agent's declarations, then those of each agent it uses as a tool. */
 function declarationsOf(agent) {
     if (isBuiltWorkflow(agent) || agent.manifest.kind === "workflow")
@@ -39,15 +38,15 @@ function declarationsOf(agent) {
     if (isBuiltWorkflow(built))
         return [];
     const binding = built.getBinding?.();
-    if (!binding || !("declarations" in binding))
+    if (!binding || !("parts" in binding))
         return [];
-    const found = [...(binding.declarations ?? [])];
+    const found = [...(binding.parts ?? [])];
     for (const tool of binding.tools ?? []) {
         const delegate = delegateOf(tool);
-        found.push(...(delegate?.agent?.getBinding().declarations ?? []));
+        found.push(...(delegate?.agent?.getBinding().parts ?? []));
         // A flow agent used as a tool: its agents' declarations.
         for (const leaf of Object.values(delegate?.workflow?.getBinding().agents ?? {}))
-            found.push(...(leaf.declarations ?? []));
+            found.push(...(leaf.parts ?? []));
     }
     return found;
 }
@@ -58,11 +57,6 @@ function skillFilesOf(agent, into = new Map()) {
             into.set(sha256, source);
     return into;
 }
-/** Closures stay on the live binding. The published manifest cannot name them. */
-export function assertNoMiddlewareClosures(agent) {
-    if (declarationsOf(agent).some((item) => item.hasMiddleware))
-        throw new Error(middlewareClosure);
-}
 export class AgentsClient {
     transport;
     /** The subject this client acts for (`as`), or `undefined` for the principal itself. */
@@ -74,7 +68,7 @@ export class AgentsClient {
     /**
      * A client that acts for `subject`: every call sends `Nylorun-Subject` and
      * `Nylorun-Scopes`, and the Runtime limits it to the scopes and to the subject's own sessions
-     * and vaults (Host feature `subject-headers`). For app servers, which authenticate the person
+     * (Host feature `subject-headers`). For app servers, which authenticate the person
      * themselves and hold the key; nothing is minted, cached or refreshed.
      */
     as(subject, options = {}) {
@@ -98,11 +92,12 @@ export class AgentsClient {
         return new AccessClient(this.transport);
     }
     /**
-     * Sandboxes as a resource (Host feature `sandboxes`): `ensure` one by id, `list` them by
-     * label, `delete` one, or give a session its own with `forSession`.
+     * Environments (protocol 11): `put` one by id (create, find or change), write its `secrets`,
+     * `list` them by label, `stop`, `reset` or `delete` one, or give a session its own with
+     * `forSession`.
      */
-    get sandboxes() {
-        return new SandboxesClient(this.transport, (options) => this.createSession(options));
+    get environments() {
+        return new EnvironmentsClient(this.transport, (options) => this.createSession(options));
     }
     /** File artifacts: upload, list, download with Range, capability links (protocol 6). */
     get artifacts() {
@@ -132,8 +127,9 @@ export class AgentsClient {
      * Registers the agent's definition (`PUT /v1/agents/{id}`), first uploading the skill files
      * it names that the Runtime does not hold. A definition with a tool that runs your code
      * (`tool({ run })`, a flow's tool stage) is refused before anything is sent: the Runtime runs
-     * no code of yours during a session. `implementationVersion` defaults to
-     * `NYLORUN_IMPLEMENTATION_VERSION`, else `dev`.
+     * agents from their manifests alone. `implementationVersion` defaults to
+     * `NYLORUN_IMPLEMENTATION_VERSION`, else `dev`. `dryRun` (protocol 14) runs every check and
+     * saves nothing; the skill files are still uploaded, since they are stored by content.
      */
     async saveAgent(agent, options = {}) {
         const files = new Map();
@@ -141,19 +137,18 @@ export class AgentsClient {
             // A flow agent embeds its agents: one document, carrying their files.
             for (const binding of Object.values(agent.getBinding().agents)) {
                 const leaf = { id: binding.manifest.id, manifest: binding.manifest, getBinding: () => binding };
-                assertNoMiddlewareClosures(leaf);
                 skillFilesOf(leaf, files);
             }
         }
         else {
-            assertNoMiddlewareClosures(agent);
             skillFilesOf(agent, files);
         }
-        const refusal = codeToolRefusal(agent.manifest);
+        const refusal = codeToolRefusal(agent.manifest) ??
+            approvalRefusal(agent.manifest);
         if (refusal)
             throw new Error(refusal);
         await this.files.ensure(files);
-        return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
+        return this.transport.json(`/v1/agents/${segment(agent.id)}${options.dryRun ? "?dryRun=true" : ""}`, "PUT", {
             requestId: options.requestId ?? id(),
             manifest: agent.manifest,
             implementationVersion: options.implementationVersion ?? env("NYLORUN_IMPLEMENTATION_VERSION") ?? "dev",
@@ -166,11 +161,7 @@ export class AgentsClient {
             agentId: options.agentId,
             ownerUserId: options.ownerUserId,
             ...(options.info ? { info: options.info } : {}),
-            ...(options.vaultIds ? { vaultIds: options.vaultIds } : {}),
-            ...(options.credentialSelections
-                ? { credentialSelections: options.credentialSelections }
-                : {}),
-            ...(options.sandbox === undefined ? {} : { sandbox: options.sandbox }),
+            ...(options.environment === undefined ? {} : { environment: options.environment }),
         });
         return this.session(sessionId);
     }
@@ -274,6 +265,28 @@ export class SessionClient {
             query.set("cursor", options.cursor);
         return ModelCallsPageSchema.parse(await this.transport.json(`${this.path}/calls/model?${query}`, "GET", undefined, options.signal));
     }
+    /**
+     * The session's tool calls (R5, Host feature `tool-calls`), in the order they were first sent:
+     * each one's tool, input, status and sends. `attempts` above 1: a crash re-sent it.
+     */
+    async toolCalls(options = {}) {
+        await this.transport.requireFeature("tool-calls", options.signal);
+        const query = new URLSearchParams({ limit: String(options.limit ?? 50) });
+        if (options.turnId !== undefined)
+            query.set("turnId", options.turnId);
+        if (options.cursor !== undefined)
+            query.set("cursor", options.cursor);
+        return ToolCallsPageSchema.parse(await this.transport.json(`${this.path}/calls/tool?${query}`, "GET", undefined, options.signal));
+    }
+    /**
+     * A turn's trace (R7, Host feature `traces`): its spans as OTLP/HTTP JSON (`resourceSpans`), as
+     * the Runtime posts them to an OTLP collector. Post it to a collector's `/v1/traces` to backfill
+     * one, or read it without one.
+     */
+    async trace(turnId, options = {}) {
+        await this.transport.requireFeature("traces", options.signal);
+        return TurnTraceSchema.parse(await this.transport.json(`${this.path}/turns/${encodeURIComponent(turnId)}/trace`, "GET", undefined, options.signal));
+    }
     async history(options = {}) {
         const query = new URLSearchParams();
         if (options.cursor)
@@ -372,4 +385,4 @@ export class SessionClient {
 }
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
 export { AccessClient } from "./access.js";
-export { SandboxesClient } from "./sandboxes.js";
+export { EnvironmentManifestsClient, EnvironmentSecretsClient, EnvironmentsClient, environmentFiles, environmentManifest, } from "./environments.js";

package/dist/skills/index.d.ts

@@ -1,5 +1,3 @@
-export { skills } from "./skills.js";
-export type { SkillsCapability, SkillsOptions } from "./skills.js";
 export { loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./load.js";
 export type { LoadedSkill, SkillDiagnostic } from "./load.js";
-export { formatSkillCatalog, SKILLS_USAGE } from "./catalog.js";
+export { formatSkillCatalog, SKILLS_USAGE } from "@nylorun/core/define";

package/dist/skills/index.js

@@ -1,3 +1,2 @@
-export { skills } from "./skills.js";
 export { loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./load.js";
-export { formatSkillCatalog, SKILLS_USAGE } from "./catalog.js";
+export { formatSkillCatalog, SKILLS_USAGE } from "@nylorun/core/define";

package/dist/skills/skills.d.ts

@@ -1,16 +1,12 @@
-import type { CapabilityDeclaration } from "@nylorun/core/define";
+import type { PartDeclaration, PluginLabel } from "@nylorun/core/define";
 import { type LoadedSkill, type SkillDiagnostic } from "./load.js";
-export interface SkillsOptions {
-    /** Capability id. Defaults to the catalog directory basename. */
-    readonly id?: string;
-}
-export interface SkillsCapability extends CapabilityDeclaration {
+export interface SkillsPart extends PartDeclaration {
     readonly diagnostics: readonly SkillDiagnostic[];
     /** Absolute catalog directory that was loaded. */
     readonly root: string;
 }
 /**
- * Load an agentskills.io catalog folder and return one capability for `Agent.use`.
+ * Load an agentskills.io catalog folder as one part of an agent, for `.skills()`.
  *
  * Expected layout:
  * ```
@@ -23,8 +19,12 @@ export interface SkillsCapability extends CapabilityDeclaration {
  *
  * Sets `skills`: each skill's name, description and files (every file of its folder, binary
  * included, by content hash). The client uploads the files the Runtime lacks when it registers
- * the agent, and the Runtime serves `load_skill` / `read_skill_resource` from them.
+ * the agent; the Runtime adds the skill catalog and serves `load_skill` / `read_skill_resource`
+ * from them.
+ */
+export declare function skills(directory: string): SkillsPart;
+/**
+ * The manifest's skills and the bytes behind their files. A plugin's skills carry its label, so
+ * a tool call can be traced to the plugin that brought the skill.
  */
-export declare function skills(directory: string, options?: SkillsOptions): SkillsCapability;
-/** The manifest's skills and the bytes behind their files, for a capability declaration. */
-export declare function skillsDeclaration(listed: readonly LoadedSkill[]): Required<Pick<CapabilityDeclaration, "skills" | "skillFiles">>;
+export declare function skillsDeclaration(listed: readonly LoadedSkill[], plugin?: PluginLabel): Required<Pick<PartDeclaration, "skills" | "skillFiles">>;

package/dist/skills/skills.js

@@ -1,8 +1,7 @@
 import { basename } from "node:path";
-import { formatSkillCatalog, SKILLS_USAGE } from "./catalog.js";
 import { loadSkillsFromDirectory, resolveSkillsRoot, } from "./load.js";
 /**
- * Load an agentskills.io catalog folder and return one capability for `Agent.use`.
+ * Load an agentskills.io catalog folder as one part of an agent, for `.skills()`.
  *
  * Expected layout:
  * ```
@@ -15,39 +14,34 @@ import { loadSkillsFromDirectory, resolveSkillsRoot, } from "./load.js";
  *
  * Sets `skills`: each skill's name, description and files (every file of its folder, binary
  * included, by content hash). The client uploads the files the Runtime lacks when it registers
- * the agent, and the Runtime serves `load_skill` / `read_skill_resource` from them.
+ * the agent; the Runtime adds the skill catalog and serves `load_skill` / `read_skill_resource`
+ * from them.
  */
-export function skills(directory, options = {}) {
+export function skills(directory) {
     const root = resolveSkillsRoot(directory);
     const diagnostics = [];
     const loaded = loadSkillsFromDirectory(root, diagnostics);
     const listed = Object.values(loaded);
-    const id = options.id ?? basename(root);
+    const id = `skills:${basename(root)}`;
     if (listed.length === 0) {
         return { id, root, diagnostics };
     }
-    const { skills: skillManifest, skillFiles } = skillsDeclaration(listed);
-    return {
-        id,
-        root,
-        instructions: [
-            SKILLS_USAGE,
-            formatSkillCatalog(listed.map((skill) => ({
-                name: skill.name,
-                description: skill.description,
-            }))),
-        ],
-        skills: skillManifest,
-        skillFiles,
-        diagnostics,
-    };
+    return { id, root, ...skillsDeclaration(listed), diagnostics };
 }
-/** The manifest's skills and the bytes behind their files, for a capability declaration. */
-export function skillsDeclaration(listed) {
+/**
+ * The manifest's skills and the bytes behind their files. A plugin's skills carry its label, so
+ * a tool call can be traced to the plugin that brought the skill.
+ */
+export function skillsDeclaration(listed, plugin) {
     return {
         skills: Object.fromEntries(listed.map((skill) => [
             skill.name,
-            { name: skill.name, description: skill.description, files: skill.files },
+            {
+                name: skill.name,
+                description: skill.description,
+                files: skill.files,
+                ...(plugin === undefined ? {} : { plugin }),
+            },
         ])),
         skillFiles: Object.assign({}, ...listed.map((skill) => skill.sources)),
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/agents",
-  "version": "0.19.1-beta",
+  "version": "0.21.0-beta",
   "description": "Nylorun agent definitions and session client",
   "type": "module",
   "license": "Apache-2.0",
@@ -43,14 +43,14 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@nylorun/core": "0.19.0-beta",
+    "@nylorun/core": "0.21.0-beta",
     "gray-matter": "^4.0.3"
   },
   "peerDependencies": {
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
+    "@types/node": "^26.6.4",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "vitest": "^5.0.2"
   },
@@ -60,7 +60,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nylorun/agents.git",
-    "directory": "agents"
+    "directory": "sdks/agents"
   },
   "publishConfig": {
     "access": "public",

package/dist/sandboxes.d.ts

@@ -1,106 +0,0 @@
-/**
- * Sandboxes as a resource (Host feature `sandboxes`): `client.sandboxes`. A sandbox has its own
- * id and outlives the sessions attached to it; whether it serves one session, one person or a
- * project is the app's choice, made here:
- *
- * - `sandboxes.forSession(...)`: one sandbox for one session. It creates the sandbox, opens the
- *   session attached to it, and `release()` deletes the sandbox when the session is done. It
- *   replaces sharing through another session (`sandbox: { session }`, `sandboxOwnerId`).
- * - `sandboxes.ensure(id, spec)`: one sandbox per person or per project, by a deterministic id
- *   (`user-42`, `team-a/proj-42`); get-or-create in one call. Attach sessions to it with
- *   `createSession({ sandbox: { id } })`.
- *
- * Ids may hold `/`; they are sent percent-encoded as one path segment.
- */
-import { type DeleteSandboxResponse, type PutSandboxRequest, type SandboxEvent, type SandboxView } from "@nylorun/core/contracts";
-import { type Transport } from "./http.js";
-import type { CreateSessionOptions, SessionClient } from "./session-client.js";
-/** What a sandbox is made of: fixed once it exists, except its labels. */
-export type SandboxSpec = Omit<PutSandboxRequest, "requestId">;
-/** A session opened on a sandbox of its own (`sandboxes.forSession`). */
-export interface SessionSandboxHandle {
-    readonly session: SessionClient;
-    readonly sandbox: SandboxView;
-    /** Deletes the sandbox and its files; call it when the session is done. */
-    release(options?: {
-        signal?: AbortSignal;
-    }): Promise<DeleteSandboxResponse>;
-}
-export interface ForSessionOptions {
-    /** The session to open, as `createSession` takes it, without `sandbox`. */
-    readonly session: Omit<CreateSessionOptions, "sandbox">;
-    /** The sandbox's spec and labels. Default: a virtual sandbox within the Tenant's defaults. */
-    readonly spec?: SandboxSpec;
-    /** The sandbox's id. Default: `sessions/<session id>`. */
-    readonly sandboxId?: string;
-    readonly signal?: AbortSignal;
-}
-export declare class SandboxesClient {
-    private readonly transport;
-    /** `AgentsClient.createSession`, bound. */
-    private readonly createSession;
-    constructor(transport: Transport, 
-    /** `AgentsClient.createSession`, bound. */
-    createSession: (options: CreateSessionOptions) => Promise<SessionClient>);
-    private path;
-    /**
-     * Creates the sandbox, or finds the one with this id (`PUT /v1/sandboxes/{id}`). Its spec is
-     * fixed once it exists: a different one is a 409. Labels, when given, replace its labels.
-     */
-    ensure(sandboxId: string, spec?: SandboxSpec, options?: {
-        signal?: AbortSignal;
-    }): Promise<SandboxView>;
-    get(sandboxId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<SandboxView>;
-    /** The sandboxes with every label in `labels` that this client reaches. */
-    list(options?: {
-        labels?: Readonly<Record<string, string>>;
-        signal?: AbortSignal;
-    }): Promise<SandboxView[]>;
-    page(options?: {
-        labels?: Readonly<Record<string, string>>;
-        limit?: number;
-        cursor?: string;
-        signal?: AbortSignal;
-    }): Promise<{
-        sandboxes: {
-            id: string;
-            kind: "pod" | "virtual";
-            labels: Record<string, string>;
-            spec: Record<string, unknown>;
-            state: "creating" | "ready" | "running" | "stopped";
-            pod?: {
-                desired: "deleted" | "running" | "suspended";
-                observed: "creating" | "deleting" | "expired" | "failed" | "lost" | "running" | "suspended";
-                volumeGeneration: number;
-                hostEpoch: number;
-                expiresAt?: string | undefined;
-                reason?: string | undefined;
-            } | undefined;
-            sessions: {
-                id: string;
-                activeTurnId: string | null;
-            }[];
-            createdAt: string;
-            updatedAt: string;
-        }[];
-        nextCursor: string | null;
-    }>;
-    /** Deletes the sandbox and its files; `deleted` is false when there was none. */
-    delete(sandboxId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<DeleteSandboxResponse>;
-    /** The sandbox's lifecycle events, from `from` on. */
-    events(sandboxId: string, options?: {
-        from?: number;
-        signal?: AbortSignal;
-    }): Promise<SandboxEvent[]>;
-    /**
-     * One sandbox for one session: creates the sandbox (`sessions/<session id>` unless
-     * `sandboxId` names another), opens the session attached to it, and returns both with
-     * `release()`, which deletes the sandbox. If the session cannot be opened, the sandbox is
-     * deleted again.
-     */
-    forSession(options: ForSessionOptions): Promise<SessionSandboxHandle>;
-}