@nylorun/agents 0.23.0-beta → 0.25.0-beta

package/dist/index.d.ts

@@ -6,22 +6,24 @@ export { Agent, AgentBuilder } from "./builder.js";
 export { AgentBuildError, AgentLifecycleError, VerdictSchema, isVerdict, WorkflowBuildError, isBuiltWorkflow, flow, tool, http, defineSchema, ToolError, } from "@nylorun/core/define";
 export type { FlowAgentBuilder, Flow, Named, LoopOptions, StageOptions, HttpTarget, } from "@nylorun/core/define";
 export type { AgentOptions, AgentManifest, BuiltAgent, BuiltWorkflow, Verdict, WorkflowBinding, WorkflowManifest, ToolDefinition, ToolExecutionContext, ToolOutcome, JsonValue, JsonObject, } from "@nylorun/core/define";
-export type { SessionPage, SessionListItem, SessionManifestView, HistoryPage, SessionUsageTotals, ModelCall, ModelCallsPage, EnvironmentPage, ToolCall, ToolCallsPage, LiveEvent, SessionEvent, SessionEventOf, EventType, SessionCommand, SubjectScope, EnvironmentView, EnvironmentEvent, EnvironmentEventType, EgressRunningTurn, EnvironmentKind, EnvironmentRecipe, EnvironmentSecretView, EnvironmentSnapshot, EnvironmentRestore, EnvironmentVersions, RestoreEnvironmentRequest, EnvironmentForkPlan, ForkEnvironmentRequest, ForkEnvironmentResponse, EnvironmentManifest, EnvironmentManifestPlan, EnvironmentManifestView, EnvironmentManifestVersions, SaveEnvironmentManifestResponse, MessagePart, ArtifactView, ArtifactKind, ArtifactListItem, ArtifactPage, ArtifactVersionView, ArtifactLink, UploadArtifactResponse, DefinitionFileView, ArtifactTree, ArtifactDiff, FolderEntry, } from "@nylorun/core/contracts";
-export { ENVIRONMENT_EVENT_TYPES, RUNTIME_LIMIT_DEFAULTS, SUBJECT_SCOPES } from "@nylorun/core/contracts";
+export type { SessionPage, SessionListItem, SessionManifestView, HistoryPage, SessionUsageTotals, CostSplit, ModelCall, ModelCallsPage, AgentPage, ToolCall, ToolCallsPage, LiveEvent, SessionEvent, SessionEventOf, EventType, SessionCommand, SubjectScope, AgentView, AgentState, AgentAttention, AgentEvent, AgentEventType, EgressRunningTurn, EnvironmentKind, EnvironmentRecipe, EnvironmentSecretSlot, AgentSecretView, AgentSnapshot, AgentRestore, AgentDiskVersions, RestoreAgentRequest, AgentForkPlan, AgentMovePlan, RestartAgentRequest, ForkAgentRequest, ForkAgentResponse, DeleteAgentResponse, PutAgentRequest, PutAgentSecretRequest, AgentManifestV8, AgentManifestFile, HarnessManifestFile, RuntimeManifestFile, RuntimeSection, AgentManifestChange, AgentManifestWarning, AgentManifestPlan, AgentManifestView, AgentManifestVersions, SaveAgentManifestResponse, DeleteAgentManifestResponse, MessagePart, ArtifactView, ArtifactKind, ArtifactListItem, ArtifactPage, ArtifactVersionView, ArtifactLink, UploadArtifactResponse, DefinitionFileView, ArtifactTree, ArtifactDiff, FolderEntry, } from "@nylorun/core/contracts";
+export { AGENT_EVENT_TYPES, AGENT_STATES, COMPUTE_STATES, RUNTIME_LIMIT_DEFAULTS, SUBJECT_SCOPES, } from "@nylorun/core/contracts";
+export type { AgentHarnessSection, HarnessSection, HarnessSkill, HarnessMcpServer, WorkflowHarnessSection, } from "@nylorun/core";
 export { AgentsClient, SessionClient, createClient } from "./client.js";
 export { ArtifactsClient } from "./artifacts.js";
 export { FilesClient, definitionFileHash } from "./files.js";
 export type { ArtifactBody, ArtifactPageOptions, ArtifactLinkWithUrl, UploadArtifactOptions, } from "./artifacts.js";
-export type { ActAsOptions, AgentSource, SessionView, CommandOptions, CreateSessionOptions, SessionSandbox, ForSessionOptions, EnvironmentFileBytes, EnvironmentInput, EnvironmentManifestInput, EnvironmentSecretInput, SessionEnvironmentHandle, } from "./client.js";
-export { EnvironmentManifestsClient, EnvironmentsClient, EnvironmentSecretsClient, environmentFiles, environmentManifest, } from "./client.js";
+export type { ActAsOptions, AgentSource, SessionView, CommandOptions, CreateSessionOptions, SessionSandbox, AgentFilter, AgentInput, AgentSecretInput, RuntimeFileBytes, AgentManifestDocument, AgentManifestFromAgent, AgentManifestInput, AgentManifestSaveOptions, ComposedManifest, DefinitionFiles, } from "./client.js";
+export { AgentInstancesClient, AgentManifestsClient, AgentMemoriesClient, AgentSecretsClient, ManifestGapsError, agentManifest, requirementGaps, runtimeFiles, } from "./client.js";
+export { composeManifest, manifestFolders, ComposeError, AGENT_MANIFEST_FILE } from "./compose.js";
 export { AccessClient } from "./access.js";
 export { resolveConnection, ConnectionError } from "./connection.js";
 export type { ResolvedConnection } from "./connection.js";
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
 export type { Destination, IncompatibleReason, TokenSource } from "./http.js";
-export { loadPlugin, PluginError } from "./plugins/load.js";
+export { loadMcpServers, loadPlugin, PluginError } from "./plugins/load.js";
 export type { LoadedPlugin, PluginDiagnostic } from "./plugins/load.js";
-export { loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./skills/index.js";
+export { hashFolder, loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./skills/index.js";
 export type { SkillDiagnostic } from "./skills/index.js";
 export { McpError } from "./mcp/index.js";
 export type { McpServerSpec } from "./mcp/index.js";

package/dist/index.js

@@ -4,14 +4,15 @@ export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFIN
 export { checkHealth, describeIncompatibility, parseProtocolRange, } from "@nylorun/core/transport";
 export { Agent, AgentBuilder } from "./builder.js";
 export { AgentBuildError, AgentLifecycleError, VerdictSchema, isVerdict, WorkflowBuildError, isBuiltWorkflow, flow, tool, http, defineSchema, ToolError, } from "@nylorun/core/define";
-export { ENVIRONMENT_EVENT_TYPES, RUNTIME_LIMIT_DEFAULTS, SUBJECT_SCOPES } from "@nylorun/core/contracts";
+export { AGENT_EVENT_TYPES, AGENT_STATES, COMPUTE_STATES, RUNTIME_LIMIT_DEFAULTS, SUBJECT_SCOPES, } from "@nylorun/core/contracts";
 export { AgentsClient, SessionClient, createClient } from "./client.js";
 export { ArtifactsClient } from "./artifacts.js";
 export { FilesClient, definitionFileHash } from "./files.js";
-export { EnvironmentManifestsClient, EnvironmentsClient, EnvironmentSecretsClient, environmentFiles, environmentManifest, } from "./client.js";
+export { AgentInstancesClient, AgentManifestsClient, AgentMemoriesClient, AgentSecretsClient, ManifestGapsError, agentManifest, requirementGaps, runtimeFiles, } from "./client.js";
+export { composeManifest, manifestFolders, ComposeError, AGENT_MANIFEST_FILE } from "./compose.js";
 export { AccessClient } from "./access.js";
 export { resolveConnection, ConnectionError } from "./connection.js";
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
-export { loadPlugin, PluginError } from "./plugins/load.js";
-export { loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./skills/index.js";
+export { loadMcpServers, loadPlugin, PluginError } from "./plugins/load.js";
+export { hashFolder, loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./skills/index.js";
 export { McpError } from "./mcp/index.js";

package/dist/plugins/load.d.ts

@@ -23,3 +23,13 @@ export interface LoadedPlugin {
     readonly diagnostics: readonly PluginDiagnostic[];
 }
 export declare function loadPlugin(directory: string): LoadedPlugin;
+/**
+ * The remote MCP servers of an `mcp.json` in the Agent Plugins format (`$schema` and
+ * `mcpServers`), as a manifest declares them: a plugin's, or the one a `harness.manifest.json`
+ * names. A file that cannot be read is a `<prefix>.mcp-invalid` diagnostic and no servers; an
+ * invalid server is skipped with a diagnostic; a stdio server throws.
+ */
+export declare function loadMcpServers(location: string, diagnostics: PluginDiagnostic[], options?: {
+    readonly boundary?: string;
+    readonly codePrefix?: string;
+}): Readonly<Record<string, McpServerManifest>>;

package/dist/plugins/load.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { stdioMcpRefusal } from "@nylorun/core/define";
 import { HEADER_NAME_PATTERN, LOOPBACK_HOSTS, McpServerManifestSchema, } from "@nylorun/core/contracts";
 import { loadSkillsFromDirectory } from "../skills/load.js";
@@ -137,12 +137,23 @@ function loadMcp(root, diagnostics) {
     const location = join(root, "mcp.json");
     if (!existsSync(location))
         return {};
-    const real = realInside(root, location);
+    return loadMcpServers(location, diagnostics, { boundary: root });
+}
+/**
+ * The remote MCP servers of an `mcp.json` in the Agent Plugins format (`$schema` and
+ * `mcpServers`), as a manifest declares them: a plugin's, or the one a `harness.manifest.json`
+ * names. A file that cannot be read is a `<prefix>.mcp-invalid` diagnostic and no servers; an
+ * invalid server is skipped with a diagnostic; a stdio server throws.
+ */
+export function loadMcpServers(location, diagnostics, options = {}) {
+    const prefix = options.codePrefix ?? "plugin";
+    const boundary = options.boundary ?? dirname(resolve(location));
+    const real = realInside(boundary, location);
     if (!real || !statSync(real).isFile()) {
         diagnostics.push({
             severity: "warning",
-            code: "plugin.mcp-invalid",
-            message: "mcp.json is not a file inside the package",
+            code: `${prefix}.mcp-invalid`,
+            message: `${basename(location)} is not a file inside the package`,
             path: location,
         });
         return {};
@@ -154,8 +165,8 @@ function loadMcp(root, diagnostics) {
     catch {
         diagnostics.push({
             severity: "warning",
-            code: "plugin.mcp-invalid",
-            message: "mcp.json is not valid JSON",
+            code: `${prefix}.mcp-invalid`,
+            message: `${basename(location)} is not valid JSON`,
             path: location,
         });
         return {};
@@ -163,8 +174,8 @@ function loadMcp(root, diagnostics) {
     if (!isRecord(parsed) || Object.keys(parsed).some((key) => key !== "$schema" && key !== "mcpServers")) {
         diagnostics.push({
             severity: "warning",
-            code: "plugin.mcp-invalid",
-            message: "mcp.json must contain only $schema and mcpServers",
+            code: `${prefix}.mcp-invalid`,
+            message: `${basename(location)} must contain only $schema and mcpServers`,
             path: location,
         });
         return {};
@@ -172,8 +183,8 @@ function loadMcp(root, diagnostics) {
     if (parsed.$schema !== MCP_SCHEMA) {
         diagnostics.push({
             severity: "warning",
-            code: "plugin.mcp-invalid",
-            message: "mcp.json $schema does not match the plugin schema version",
+            code: `${prefix}.mcp-invalid`,
+            message: `${basename(location)} $schema does not match the plugin schema version`,
             path: location,
         });
         return {};
@@ -181,8 +192,8 @@ function loadMcp(root, diagnostics) {
     if (!isRecord(parsed.mcpServers)) {
         diagnostics.push({
             severity: "warning",
-            code: "plugin.mcp-invalid",
-            message: "mcp.json mcpServers must be an object",
+            code: `${prefix}.mcp-invalid`,
+            message: `${basename(location)} mcpServers must be an object`,
             path: location,
         });
         return {};
@@ -190,12 +201,12 @@ function loadMcp(root, diagnostics) {
     const servers = {};
     for (const [name, value] of Object.entries(parsed.mcpServers)) {
         if (isRecord(value) && value.type === "stdio")
-            throw new PluginError("plugin.mcp-stdio", stdioMcpRefusal(name), diagnostics);
+            throw new PluginError(`${prefix}.mcp-stdio`, stdioMcpRefusal(name), diagnostics);
         const server = validateServer(name, value);
         if (typeof server === "string") {
             diagnostics.push({
                 severity: "warning",
-                code: "plugin.mcp-server-skipped",
+                code: `${prefix}.mcp-server-skipped`,
                 message: `Skipped invalid MCP server '${name}': ${server}`,
                 path: location,
             });

package/dist/plugins/plugin.d.ts

@@ -5,7 +5,7 @@ export interface PluginPart extends PartDeclaration {
 }
 /**
  * Read an Agent Plugin package as one part of an agent, for `.plugin()`. Each part it skips
- * (an invalid MCP server or skill) is a process warning, so building or registering the agent
+ * (an invalid MCP server or skill) is a process warning, so building or saving its manifest
  * says why the agent has less than the package declares. A stdio MCP server throws: Nylorun
  * accepts remote servers only.
  */

package/dist/plugins/plugin.js

@@ -2,7 +2,7 @@ import { skillsDeclaration } from "../skills/skills.js";
 import { loadPlugin, } from "./load.js";
 /**
  * Read an Agent Plugin package as one part of an agent, for `.plugin()`. Each part it skips
- * (an invalid MCP server or skill) is a process warning, so building or registering the agent
+ * (an invalid MCP server or skill) is a process warning, so building or saving its manifest
  * says why the agent has less than the package declares. A stdio MCP server throws: Nylorun
  * accepts remote servers only.
  */

package/dist/reads.d.ts

@@ -2,9 +2,11 @@
 import { type SessionListItem, type SessionPage } from "@nylorun/core/contracts";
 import type { Transport } from "./http.js";
 export type SessionPageOptions = {
+    /** The Agent the sessions run on. */
     agentId?: string;
+    /** The agent manifest's name their Agents were made from. */
+    manifest?: string;
     status?: SessionListItem["status"];
-    environmentId?: string;
     ownerUserId?: string;
     limit?: number;
     cursor?: string;

package/dist/session-client.d.ts

@@ -2,11 +2,12 @@
  * The Runtime API client classes, with no Node-only imports. `client.ts` adds `createClient`,
  * 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 MessagePart, type SessionCommand } from "@nylorun/core/contracts";
+import type { JsonValue, SandboxToolName } from "@nylorun/core/define";
+import { type SessionItemsResponse, type SessionSummary, type SubjectScope, type MessageDelivery, type MessagePart, type SessionCommand } from "@nylorun/core/contracts";
 import { SessionsReadClient } from "./reads.js";
 import { AccessClient } from "./access.js";
-import { EnvironmentsClient } from "./environments.js";
+import { AgentInstancesClient } from "./agents.js";
+import { AgentManifestsClient } from "./agent-manifests.js";
 import { ArtifactsClient } from "./artifacts.js";
 import { FilesClient } from "./files.js";
 import { Transport, type Destination } from "./http.js";
@@ -14,12 +15,6 @@ import { Transport, type Destination } from "./http.js";
 export type SessionSandbox = {
     readonly [K in SandboxToolName]: (args: Record<string, unknown>) => Promise<unknown>;
 };
-export interface AgentSource {
-    readonly id: string;
-    readonly manifest: AgentManifest | WorkflowManifest;
-    build?(): BuiltAgent | BuiltWorkflow;
-    getBinding?: BuiltAgent["getBinding"] | BuiltWorkflow["getBinding"];
-}
 export interface SessionView {
     id: string;
     agentId: string;
@@ -31,17 +26,16 @@ export interface SessionView {
 }
 /** `AgentsClient.createSession`'s options. */
 export interface CreateSessionOptions {
+    /** The session's id, which the app chooses. Default: a new UUID. */
     id?: string;
-    agentId: string;
+    /**
+     * The Agent the session runs on (`client.agents`): its manifest version, its sandbox and its
+     * vault's credentials. Fixed once the session exists.
+     */
+    agent: string;
     ownerUserId: string;
     info?: Record<string, unknown>;
     requestId?: string;
-    /**
-     * 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.
-     */
-    environment?: string;
 }
 export interface ActAsOptions {
     /** What the subject may do; the Runtime grants nothing else. Default `["sessions:own"]`. */
@@ -62,11 +56,16 @@ export declare class AgentsClient {
     /** The public keys that verify the tokens the Tenant signs. */
     get access(): AccessClient;
     /**
-     * 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`.
+     * Agent manifests (protocol 16): `save` a manifest's next version (a v8 document, what
+     * `composeManifest` read, or a built agent with its runtime section), `plan` a save, read
+     * their versions.
      */
-    get environments(): EnvironmentsClient;
+    get agentManifests(): AgentManifestsClient;
+    /**
+     * Agents (protocol 16): `put` one by id from a saved manifest (create or find), write its
+     * `secrets`, `list` them, `stop`, `reset`, `fork` or `delete` one. Sessions run on them.
+     */
+    get agents(): AgentInstancesClient;
     /** 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. */
@@ -76,32 +75,12 @@ export declare class AgentsClient {
         signal?: AbortSignal;
     }): Promise<readonly string[]>;
     get sessions(): SessionsReadClient;
-    listAgents(options?: {
-        signal?: AbortSignal;
-    }): Promise<ListAgentsResponse | {
-        agents: (ListPublicAgentsResponse["agents"][number] & {
-            manifest?: never;
-        })[];
-    }>;
     listSessions(options?: {
         agentId?: string;
         signal?: AbortSignal;
     }): Promise<{
         sessions: SessionSummary[];
     }>;
-    /**
-     * 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
-     * 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;
 }
@@ -110,6 +89,14 @@ export type CommandOptions = {
     requestId?: string;
     signal?: AbortSignal;
 };
+/**
+ * A message's options. `delivery` says what a message to a busy session does (protocol 17):
+ * `queue` (the default) waits for the running turn to end, `reject` is refused with
+ * `409 session_busy`.
+ */
+export type MessageOptions = CommandOptions & {
+    delivery?: MessageDelivery;
+};
 export declare class SessionClient {
     private readonly transport;
     readonly id: string;
@@ -119,44 +106,75 @@ export declare class SessionClient {
     inspect(signal?: AbortSignal): Promise<SessionView>;
     /** Pending waits / interactions from the session inspect view. */
     pending(signal?: AbortSignal): Promise<{}>;
+    /** A message answers `queued` when it waits for the running turn (protocol 17). */
     command(command: SessionCommand, signal?: AbortSignal): Promise<{
         status: "accepted";
         turnId: string | null;
         cursor: string | null;
         requestId: string;
+    } | {
+        status: "queued";
+        queuedMessageId: string;
+        position: number;
+        cursor: string | null;
+        requestId: string;
     }>;
     /**
      * Start a turn. Strings become `message.content`; any other JSON value becomes
      * `message.data` (workflows.md §5).
      */
-    input(value: string | JsonValue, options: CommandOptions): Promise<{
+    input(value: string | JsonValue, options: MessageOptions): Promise<{
         status: "accepted";
         turnId: string | null;
         cursor: string | null;
         requestId: string;
+    } | {
+        status: "queued";
+        queuedMessageId: string;
+        position: number;
+        cursor: string | null;
+        requestId: string;
     }>;
     /**
      * Start a turn with text and file parts (protocol 6): a file part names an artifact (upload
      * it with `client.artifacts.upload`), at a version or its latest, and the model reads it, an
      * image as an image and a text file as text.
      */
-    inputParts(parts: readonly MessagePart[], options: CommandOptions): Promise<{
+    inputParts(parts: readonly MessagePart[], options: MessageOptions): Promise<{
         status: "accepted";
         turnId: string | null;
         cursor: string | null;
         requestId: string;
+    } | {
+        status: "queued";
+        queuedMessageId: string;
+        position: number;
+        cursor: string | null;
+        requestId: string;
     }>;
     approve(interactionId: string, approved: boolean, options: CommandOptions): Promise<{
         status: "accepted";
         turnId: string | null;
         cursor: string | null;
         requestId: string;
+    } | {
+        status: "queued";
+        queuedMessageId: string;
+        position: number;
+        cursor: string | null;
+        requestId: string;
     }>;
     respond(interactionId: string, value: JsonValue, options: CommandOptions): Promise<{
         status: "accepted";
         turnId: string | null;
         cursor: string | null;
         requestId: string;
+    } | {
+        status: "queued";
+        queuedMessageId: string;
+        position: number;
+        cursor: string | null;
+        requestId: string;
     }>;
     cancel(options: CommandOptions & {
         reason?: string;
@@ -165,14 +183,23 @@ export declare class SessionClient {
         turnId: string | null;
         cursor: string | null;
         requestId: string;
+    } | {
+        status: "queued";
+        queuedMessageId: string;
+        position: number;
+        cursor: string | null;
+        requestId: string;
     }>;
     manifest(options?: {
         signal?: AbortSignal;
     }): Promise<{
         sessionId: string;
         agentId: string;
+        definition: {
+            name: string;
+            version: number;
+        } | null;
         manifestHash: string;
-        implementationVersion: string;
         manifest: Record<string, unknown>;
     }>;
     usage(options?: {
@@ -194,6 +221,15 @@ export declare class SessionClient {
         unpricedCalls: number;
         unreportedCalls: number;
         unknownQualityCalls: number;
+        costSplit: {
+            input: number;
+            cacheRead: number;
+            cacheWrite: number;
+            output: number;
+        };
+        splitCalls: number;
+        modelTimeMs: number;
+        timedCalls: number;
     }>;
     modelCalls(options?: {
         turnId?: string;
@@ -206,10 +242,12 @@ export declare class SessionClient {
             effectId: string;
             sessionId: string;
             turnId: string;
-            agentId: string;
+            manifestName: string;
             provider: string | null;
             model: string | null;
             at: string;
+            startedAt: string | null;
+            endedAt: string | null;
             outcome: "completed" | "failed";
             usage: {
                 inputTokens: number;
@@ -222,13 +260,19 @@ export declare class SessionClient {
                 duplicate: boolean;
                 tokensReported: boolean | null;
                 costKnown: boolean | null;
+                costSplit: {
+                    input: number;
+                    cacheRead: number;
+                    cacheWrite: number;
+                    output: number;
+                } | null;
             } | null;
         }[];
         nextCursor: string | null;
         asOf: string;
     }>;
     /**
-     * The session's tool calls (R5, Host feature `tool-calls`), in the order they were first sent:
+     * The session's tool calls (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?: {
@@ -242,7 +286,7 @@ export declare class SessionClient {
             turnId: string;
             callId: string | null;
             toolName: string | null;
-            kind: "harness" | "http" | "mcp" | "sandbox" | null;
+            kind: "harness" | "http" | "mcp" | "runtime" | "sandbox" | null;
             server: string | null;
             tool: string | null;
             skill: string | null;
@@ -265,7 +309,7 @@ export declare class SessionClient {
         asOf: string;
     }>;
     /**
-     * A turn's trace (R7, Host feature `traces`): its spans as OTLP/HTTP JSON (`resourceSpans`), as
+     * A turn's trace (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.
      */
@@ -350,7 +394,7 @@ export declare class SessionClient {
         };
         evidence: "asserted" | "attested" | "claimed" | "measured" | "observed";
         principal?: {
-            kind: "application" | "core" | "flow-host" | "subject";
+            kind: "application" | "core" | "flow-host" | "subject" | "trigger";
             id: string;
         } | undefined;
         trace?: {
@@ -374,5 +418,7 @@ 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 { EnvironmentManifestsClient, EnvironmentSecretsClient, EnvironmentsClient, environmentFiles, environmentManifest, } from "./environments.js";
-export type { EnvironmentFileBytes, EnvironmentInput, EnvironmentManifestInput, EnvironmentSecretInput, ForSessionOptions, SessionEnvironmentHandle, } from "./environments.js";
+export { AgentInstancesClient, AgentMemoriesClient, AgentSecretsClient, runtimeFiles } from "./agents.js";
+export type { AgentFilter, AgentInput, AgentSecretInput, RuntimeFileBytes } from "./agents.js";
+export { AgentManifestsClient, ManifestGapsError, agentManifest, requirementGaps } from "./agent-manifests.js";
+export type { AgentManifestDocument, AgentManifestFromAgent, AgentManifestInput, AgentManifestSaveOptions, AgentSource, ComposedManifest, DefinitionFiles, } from "./agent-manifests.js";