@nylorun/agents 0.6.0-beta → 0.8.0-beta

package/dist/ag-ui/history.js

@@ -0,0 +1,60 @@
+import { parseTranscriptEvent } from "@nylorun/core/contracts";
+import { outputText, toolResultOf } from "./translate.js";
+export function messagesFromEvents(items) {
+    const messages = [];
+    const results = new Set();
+    let sawAssistant = false;
+    for (const raw of items) {
+        if (raw.type === "command.message") {
+            const p = (raw.payload ?? {});
+            messages.push({
+                // The handler sends the client's message id as the idempotency key.
+                id: p.idempotencyKey ?? raw.eventId,
+                role: "user",
+                content: typeof p.content === "string" ? p.content : JSON.stringify(p.data),
+            });
+            sawAssistant = false;
+            continue;
+        }
+        const event = parseTranscriptEvent(raw);
+        if (!event)
+            continue;
+        const result = toolResultOf(event);
+        if (result) {
+            if (results.has(result.callId))
+                continue;
+            results.add(result.callId);
+            messages.push({
+                id: `${result.callId}:result`,
+                role: "tool",
+                toolCallId: result.callId,
+                content: result.content,
+            });
+            continue;
+        }
+        if (event.type === "message.assistant" && !event.payload.agent) {
+            const p = event.payload;
+            sawAssistant = true;
+            const message = { id: p.invocationId, role: "assistant" };
+            if (p.text)
+                message.content = p.text;
+            if (p.toolCalls.length)
+                message.toolCalls = p.toolCalls.map((call) => ({
+                    id: call.callId,
+                    type: "function",
+                    function: { name: call.name, arguments: JSON.stringify(call.input ?? {}) },
+                }));
+            messages.push(message);
+        }
+        else if (event.type === "turn.completed" && !sawAssistant) {
+            const output = event.payload.output;
+            if (output !== undefined && output !== null && outputText(output))
+                messages.push({
+                    id: raw.eventId,
+                    role: "assistant",
+                    content: outputText(output),
+                });
+        }
+    }
+    return messages;
+}

package/dist/ag-ui/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `@nylorun/agents/ag-ui`: serve the Tenant's agents to AG-UI clients from the app's own
+ * server. The only entry point that loads `@ag-ui/core`.
+ */
+export { createAgUiHandler } from "./handler.js";
+export type { AgUiHandler, AgUiHandlerOptions, AgUiSessionOptions, } from "./handler.js";
+export { toNodeListener } from "./node.js";

package/dist/ag-ui/index.js

@@ -0,0 +1,6 @@
+/**
+ * `@nylorun/agents/ag-ui`: serve the Tenant's agents to AG-UI clients from the app's own
+ * server. The only entry point that loads `@ag-ui/core`.
+ */
+export { createAgUiHandler } from "./handler.js";
+export { toNodeListener } from "./node.js";

package/dist/ag-ui/node.d.ts

@@ -0,0 +1,5 @@
+/** `node:http` and Express adapter for a fetch-style handler. */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function toNodeListener(handler: {
+    readonly fetch: (request: Request) => Promise<Response>;
+}): (req: IncomingMessage, res: ServerResponse) => void;

package/dist/ag-ui/node.js

@@ -0,0 +1,51 @@
+import { Readable } from "node:stream";
+export function toNodeListener(handler) {
+    return (req, res) => {
+        void (async () => {
+            // A closed connection aborts the request, which stops the read, never the turn.
+            const controller = new AbortController();
+            res.on("close", () => controller.abort());
+            const host = req.headers.host ?? "localhost";
+            const url = new URL(req.url ?? "/", `http://${host}`);
+            const headers = new Headers();
+            for (const [name, value] of Object.entries(req.headers)) {
+                if (value === undefined)
+                    continue;
+                for (const item of Array.isArray(value) ? value : [value])
+                    headers.append(name, item);
+            }
+            const hasBody = req.method !== "GET" && req.method !== "HEAD";
+            const request = new Request(url, {
+                method: req.method,
+                headers,
+                signal: controller.signal,
+                ...(hasBody
+                    ? {
+                        body: Readable.toWeb(req),
+                        duplex: "half",
+                    }
+                    : {}),
+            });
+            let response;
+            try {
+                response = await handler.fetch(request);
+            }
+            catch {
+                response = new Response(JSON.stringify({ error: "Internal error" }), {
+                    status: 500,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            res.writeHead(response.status, Object.fromEntries(response.headers));
+            if (!response.body) {
+                res.end();
+                return;
+            }
+            res.flushHeaders();
+            const body = Readable.fromWeb(response.body);
+            body.on("error", () => res.destroy());
+            res.on("close", () => body.destroy());
+            body.pipe(res);
+        })();
+    };
+}

package/dist/ag-ui/sse.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AG-UI over server-sent events: one `data:` line of JSON per event. The last AG-UI event
+ * made from a Runtime event carries that event's cursor as `id:`, so a client that resumes
+ * from `Last-Event-ID` never lands inside a group.
+ */
+import type { BaseEvent } from "@ag-ui/core";
+export declare const SSE_CONTENT_TYPE = "text/event-stream";
+export declare function sseFrame(event: BaseEvent, id?: string): string;
+export declare const SSE_HEARTBEAT = ": keep-alive\n\n";

package/dist/ag-ui/sse.js

@@ -0,0 +1,7 @@
+export const SSE_CONTENT_TYPE = "text/event-stream";
+export function sseFrame(event, id) {
+    // Cursors are opaque base64; a line break would end the field early.
+    const idLine = id && !/[\r\n]/.test(id) ? `id: ${id}\n` : "";
+    return `${idLine}data: ${JSON.stringify(event)}\n\n`;
+}
+export const SSE_HEARTBEAT = ": keep-alive\n\n";

package/dist/ag-ui/translate.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Runtime transcript events → AG-UI 1.0 events for one run. Ids: an assistant message is its
+ * model call's `invocationId`, a tool call is the model's `callId`, a tool result is
+ * `<callId>:result`, so live runs and `messagesFromEvents` agree.
+ */
+import { type BaseEvent } from "@ag-ui/core";
+import { type LiveEvent, type TranscriptEvent } from "@nylorun/core/contracts";
+/** The text a tool result shows; `undefined` while there is no result yet. */
+export declare function toolResultText(result: unknown): string | undefined;
+export declare function outputText(output: unknown): string;
+/** One Runtime event's result for a run: AG-UI events, and whether the run ended. */
+export interface Step {
+    readonly events: BaseEvent[];
+    readonly finished: boolean;
+}
+/** A tool result from any of the three places a call can end. */
+export declare function toolResultOf(event: TranscriptEvent): {
+    callId: string;
+    content: string;
+} | undefined;
+export declare class RunTranslator {
+    private readonly threadId;
+    private readonly runId;
+    /** Tool invocation → the model's call id, for interrupts that name the invocation. */
+    private readonly callIds;
+    private readonly closed;
+    private sawAssistant;
+    /**
+     * `reattached`: the run continues from a cursor, so earlier assistant messages already
+     * reached the client and a workflow's output is not repeated as text.
+     */
+    constructor(threadId: string, runId: string, options?: {
+        reattached?: boolean;
+    });
+    translate(raw: LiveEvent): Step;
+    started(): BaseEvent;
+    private finished;
+}

package/dist/ag-ui/translate.js

@@ -0,0 +1,222 @@
+/**
+ * Runtime transcript events → AG-UI 1.0 events for one run. Ids: an assistant message is its
+ * model call's `invocationId`, a tool call is the model's `callId`, a tool result is
+ * `<callId>:result`, so live runs and `messagesFromEvents` agree.
+ */
+import { EventType } from "@ag-ui/core";
+import { parseTranscriptEvent, } from "@nylorun/core/contracts";
+/** The text a tool result shows; `undefined` while there is no result yet. */
+export function toolResultText(result) {
+    const value = result;
+    switch (value?.kind) {
+        case "completed":
+            return outputText(value.output ?? null);
+        case "failed":
+            return JSON.stringify({ error: value.code, message: value.message });
+        case "denied":
+            return JSON.stringify({ denied: true, reason: value.reason });
+        default:
+            // interaction-required and deferred: the call is still open.
+            return undefined;
+    }
+}
+export function outputText(output) {
+    return typeof output === "string" ? output : JSON.stringify(output);
+}
+const none = { events: [], finished: false };
+/** A tool result from any of the three places a call can end. */
+export function toolResultOf(event) {
+    switch (event.type) {
+        case "action.completed": {
+            const p = event.payload;
+            if (p.kind !== "tool" || !p.callId || p.agent)
+                return undefined;
+            const content = toolResultText(p.result);
+            return content === undefined ? undefined : { callId: p.callId, content };
+        }
+        case "tool.completed": {
+            const p = event.payload;
+            if (p.agent)
+                return undefined;
+            return {
+                callId: p.callId,
+                content: p.error !== undefined
+                    ? JSON.stringify({ error: p.error.code, message: p.error.message })
+                    : outputText(p.output ?? null),
+            };
+        }
+        case "delegation.completed": {
+            // An agent used as a tool: its own work stays inside it; the parent sees the result.
+            const p = event.payload;
+            if (!p.callId)
+                return undefined;
+            const content = toolResultText(p.outcome);
+            return content === undefined ? undefined : { callId: p.callId, content };
+        }
+        default:
+            return undefined;
+    }
+}
+export class RunTranslator {
+    threadId;
+    runId;
+    /** Tool invocation → the model's call id, for interrupts that name the invocation. */
+    callIds = new Map();
+    closed = new Set();
+    sawAssistant;
+    /**
+     * `reattached`: the run continues from a cursor, so earlier assistant messages already
+     * reached the client and a workflow's output is not repeated as text.
+     */
+    constructor(threadId, runId, options = {}) {
+        this.threadId = threadId;
+        this.runId = runId;
+        this.sawAssistant = options.reattached ?? false;
+    }
+    translate(raw) {
+        const event = parseTranscriptEvent(raw);
+        if (!event)
+            return none;
+        if (event.type === "action.pending" || event.type === "action.completed") {
+            const { callId, invocationId } = event.payload;
+            if (callId && invocationId)
+                this.callIds.set(invocationId, callId);
+        }
+        const result = toolResultOf(event);
+        if (result) {
+            if (this.closed.has(result.callId))
+                return none;
+            this.closed.add(result.callId);
+            return {
+                events: [
+                    {
+                        type: EventType.TOOL_CALL_RESULT,
+                        messageId: `${result.callId}:result`,
+                        toolCallId: result.callId,
+                        content: result.content,
+                        role: "tool",
+                    },
+                ],
+                finished: false,
+            };
+        }
+        switch (event.type) {
+            case "message.assistant": {
+                const p = event.payload;
+                if (p.agent)
+                    return none;
+                this.sawAssistant = true;
+                return { events: assistantEvents(p), finished: false };
+            }
+            case "turn.completed": {
+                const p = event.payload;
+                // Workflows finish without a model step of their own: show their output.
+                const text = this.sawAssistant || p.output === undefined || p.output === null
+                    ? []
+                    : textEvents(raw.eventId, outputText(p.output));
+                return {
+                    events: [...text, this.finished({ type: "success" }, p.output)],
+                    finished: true,
+                };
+            }
+            case "turn.paused": {
+                const interrupts = event.payload.interactions.map((w) => {
+                    const interaction = w.interaction;
+                    const toolCallId = this.callIds.get(w.invocationId);
+                    return {
+                        id: interaction.id,
+                        reason: interaction.kind === "approval" ? "tool_approval" : "input_required",
+                        ...(typeof interaction.prompt === "string"
+                            ? { message: interaction.prompt }
+                            : {}),
+                        ...(toolCallId ? { toolCallId } : {}),
+                        ...(interaction.kind === "approval"
+                            ? {
+                                responseSchema: {
+                                    type: "object",
+                                    properties: { approved: { type: "boolean" } },
+                                    required: ["approved"],
+                                },
+                            }
+                            : {}),
+                        metadata: { nylorun: { kind: interaction.kind } },
+                    };
+                });
+                return {
+                    events: [this.finished({ type: "interrupt", interrupts })],
+                    finished: true,
+                };
+            }
+            case "turn.cancelled":
+                return { events: [this.finished({ type: "cancelled" })], finished: true };
+            case "turn.failed": {
+                const p = event.payload;
+                return {
+                    events: [
+                        {
+                            type: EventType.RUN_ERROR,
+                            message: p.error?.message ?? p.message ?? "The agent failed",
+                            code: p.error?.code ?? "turn.failed",
+                        },
+                    ],
+                    finished: true,
+                };
+            }
+            case "effect.uncertain":
+            case "action.uncertain":
+                // The Runtime cannot tell whether a side effect happened; the run goes on.
+                return {
+                    events: [
+                        {
+                            type: EventType.CUSTOM,
+                            name: "nylorun.uncertain",
+                            value: event.payload,
+                        },
+                    ],
+                    finished: false,
+                };
+            default:
+                return none;
+        }
+    }
+    started() {
+        return {
+            type: EventType.RUN_STARTED,
+            threadId: this.threadId,
+            runId: this.runId,
+        };
+    }
+    finished(outcome, result) {
+        return {
+            type: EventType.RUN_FINISHED,
+            threadId: this.threadId,
+            runId: this.runId,
+            outcome,
+            ...(result === undefined ? {} : { result }),
+        };
+    }
+}
+function textEvents(messageId, text) {
+    if (!text)
+        return [];
+    return [
+        { type: EventType.TEXT_MESSAGE_START, messageId, role: "assistant" },
+        { type: EventType.TEXT_MESSAGE_CONTENT, messageId, delta: text },
+        { type: EventType.TEXT_MESSAGE_END, messageId },
+    ];
+}
+function assistantEvents(p) {
+    const events = textEvents(p.invocationId, p.text);
+    for (const call of p.toolCalls)
+        events.push({
+            type: EventType.TOOL_CALL_START,
+            toolCallId: call.callId,
+            toolCallName: call.name,
+            parentMessageId: p.invocationId,
+        }, {
+            type: EventType.TOOL_CALL_ARGS,
+            toolCallId: call.callId,
+            delta: JSON.stringify(call.input ?? {}),
+        }, { type: EventType.TOOL_CALL_END, toolCallId: call.callId });
+    return events;
+}

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import type { AgentManifest, BuiltAgent, BuiltWorkflow, JsonValue, SandboxToolName, WorkflowManifest } from "@nylorun/core/define";
-import { type CredentialInfo, type CredentialSelection, type SessionCommand, type VaultInfo } from "@nylorun/core/contracts";
+import { type SubjectScope, type CredentialInfo, type CredentialSelection, type SessionCommand, type VaultInfo } from "@nylorun/core/contracts";
 import { Transport, type Destination } from "./http.js";
 /** Application-principal access to a session's sandbox built-ins (workflows.md §8). */
 export type SessionSandbox = {
@@ -22,9 +22,26 @@ export interface SessionView {
     waits?: unknown;
     [key: string]: unknown;
 }
+export interface ActAsOptions {
+    /** What the subject may do; the Runtime grants nothing else. Default `["sessions:own"]`. */
+    scopes?: readonly SubjectScope[];
+}
 export declare class AgentsClient {
     readonly transport: Transport;
+    /** The subject this client acts for (`as`), or `undefined` for the principal itself. */
+    readonly subject: string | undefined;
     constructor(destination?: Destination);
+    /**
+     * 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
+     * themselves and hold the key; nothing is minted, cached or refreshed.
+     */
+    as(subject: string, options?: ActAsOptions): AgentsClient;
+    /** The Runtime's protocol features, including optional ones such as `transcript-events`. */
+    hostFeatures(options?: {
+        signal?: AbortSignal;
+    }): Promise<readonly string[]>;
     listAgents(options?: {
         signal?: AbortSignal;
     }): Promise<{

package/dist/client.js

@@ -1,5 +1,6 @@
 import { SANDBOX_TOOL_NAMES, delegateOf, isBuiltWorkflow, isSandboxToolName, } from "@nylorun/core/define";
-import { LiveEventSchema, SessionItemsResponseSchema, } from "@nylorun/core/contracts";
+import { SCOPES_HEADER, SUBJECT_HEADER } from "@nylorun/core/compatibility";
+import { LiveEventSchema, SessionItemsResponseSchema, parseSubjectHeaders, } from "@nylorun/core/contracts";
 import { resolveConnection } from "./connection.js";
 import { Transport, id, segment } from "./http.js";
 import { observeSSE } from "./sse.js";
@@ -57,8 +58,37 @@ export function assertNoMiddlewareClosures(agent) {
 }
 export class AgentsClient {
     transport;
+    /** The subject this client acts for (`as`), or `undefined` for the principal itself. */
+    subject;
     constructor(destination = {}) {
         this.transport = new Transport(destination);
+        this.subject = undefined;
+    }
+    /**
+     * 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
+     * themselves and hold the key; nothing is minted, cached or refreshed.
+     */
+    as(subject, options = {}) {
+        if (this.subject !== undefined)
+            throw new Error(`This client already acts for ${this.subject}`);
+        const scopes = [...(options.scopes ?? ["sessions:own"])].join(" ");
+        const parsed = parseSubjectHeaders(subject, scopes);
+        if (!parsed.ok)
+            throw new TypeError(parsed.message);
+        const client = Object.create(AgentsClient.prototype);
+        return Object.assign(client, {
+            transport: this.transport.withHeaders({
+                [SUBJECT_HEADER]: subject,
+                [SCOPES_HEADER]: [...parsed.scopes].join(" "),
+            }),
+            subject,
+        });
+    }
+    /** The Runtime's protocol features, including optional ones such as `transcript-events`. */
+    hostFeatures(options = {}) {
+        return this.transport.hostFeatures(options.signal);
     }
     listAgents(options = {}) {
         return this.transport.json("/v1/agents", "GET", undefined, options.signal);

package/dist/connection.js

@@ -10,7 +10,9 @@ export class ConnectionError extends Error {
     }
 }
 function missing(tried) {
-    throw new ConnectionError(`connection_missing: no Runtime connection found (tried ${tried.join(", ")})`);
+    throw new ConnectionError(`connection_missing: no Runtime connection found (tried ${tried.join(", ")}). ` +
+        `Start the local stack with "npx nylorun up" and link this project with "npx @nylorun/cli tenant create", ` +
+        `or set NYLORUN_RUNTIME_URL, NYLORUN_TENANT and NYLORUN_SERVER_KEY.`);
 }
 function stripTrailingSlash(url) {
     return url.replace(/\/$/, "");

package/dist/http.d.ts

@@ -26,11 +26,20 @@ export declare class Transport {
     readonly key: string;
     readonly tenant: string;
     readonly fetcher: typeof fetch;
-    private compatible;
+    /** Sent on every request, e.g. `Nylorun-Subject` and `Nylorun-Scopes` (`withHeaders`). */
+    readonly headers: Readonly<Record<string, string>>;
+    private readonly check;
     constructor(options?: Destination, role?: "server" | "executor");
+    /**
+     * The same destination with `headers` added to every request. The copy shares this
+     * transport's compatibility check, so a copy made per request does not repeat `/health`.
+     */
+    withHeaders(headers: Readonly<Record<string, string>>): Transport;
     /** Clears the cached Host compatibility result (used after a 426). */
     clearCompatibilityCache(): void;
     private ensureCompatible;
+    /** The Host's protocol features, including optional ones, from its `/health`. */
+    hostFeatures(signal?: AbortSignal): Promise<readonly string[]>;
     private authHeaders;
     request(path: string, init?: RequestInit, options?: {
         retried426?: boolean;

package/dist/http.js

@@ -57,7 +57,9 @@ export class Transport {
     key;
     tenant;
     fetcher;
-    compatible = false;
+    /** Sent on every request, e.g. `Nylorun-Subject` and `Nylorun-Scopes` (`withHeaders`). */
+    headers = {};
+    check = { compatible: false, features: [] };
     constructor(options = {}, role = "server") {
         const url = options.url ?? env("NYLORUN_RUNTIME_URL");
         const key = options.key ??
@@ -75,12 +77,22 @@ export class Transport {
         this.tenant = tenant;
         this.fetcher = options.fetch ?? globalThis.fetch;
     }
+    /**
+     * The same destination with `headers` added to every request. The copy shares this
+     * transport's compatibility check, so a copy made per request does not repeat `/health`.
+     */
+    withHeaders(headers) {
+        const copy = Object.create(Transport.prototype);
+        return Object.assign(copy, this, {
+            headers: Object.freeze({ ...this.headers, ...headers }),
+        });
+    }
     /** Clears the cached Host compatibility result (used after a 426). */
     clearCompatibilityCache() {
-        this.compatible = false;
+        this.check.compatible = false;
     }
     async ensureCompatible(signal) {
-        if (this.compatible)
+        if (this.check.compatible)
             return;
         const response = await this.fetcher(`${this.url}/health`, {
             method: "GET",
@@ -110,10 +122,18 @@ export class Transport {
         const result = checkCompatibility({ version: PROTOCOL_VERSION, required: [...PROTOCOL_FEATURES] }, protocol);
         if (!result.ok)
             throw new IncompatibleRuntimeError(result);
-        this.compatible = true;
+        this.check.features = [...protocol.features];
+        this.check.compatible = true;
+    }
+    /** The Host's protocol features, including optional ones, from its `/health`. */
+    async hostFeatures(signal) {
+        await this.ensureCompatible(signal);
+        return this.check.features;
     }
     authHeaders(init = {}) {
         const headers = new Headers(init.headers);
+        for (const [name, value] of Object.entries(this.headers))
+            headers.set(name, value);
         headers.set("Authorization", `Bearer ${this.key}`);
         headers.set(TENANT_HEADER, this.tenant);
         headers.set(PROTOCOL_HEADER, String(PROTOCOL_VERSION));

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, TENANT_HEADER, PROTOCOL_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
+export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, TENANT_HEADER, PROTOCOL_HEADER, SUBJECT_HEADER, SCOPES_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
 export type { ProtocolFeature, ProtocolRange, Compatibility, ErrorCode, } from "@nylorun/core/compatibility";
 export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, Loop, Chain, Switch, Parallel, Map, VerdictSchema, isVerdict, withInstructions, withoutTools, WorkflowBuildError, isBuiltWorkflow, capability, tool, defineSchema, ToolError, } from "@nylorun/core/define";
 export type { AgentOptions, AgentManifest, BuiltAgent, BuiltWorkflow, LoopOptions, LoopDecideArgs, LoopVerifyArgs, LoopDecision, ChainOptions, SwitchOptions, ParallelOptions, MapOptions, Verdict, WorkflowBinding, WorkflowManifest, ToolDefinition, ToolExecutionContext, ToolOutcome, Patch, Decision, TurnDecision, HookScope, BeforeHook, AfterHook, JsonValue, JsonObject, } from "@nylorun/core/define";
-export type { LiveEvent, SessionCommand, Action, ActionOutcome, CredentialInfo, CredentialSelection, VaultInfo, } from "@nylorun/core/contracts";
+export type { LiveEvent, SessionCommand, Action, ActionOutcome, CredentialInfo, CredentialSelection, VaultInfo, SubjectScope, } from "@nylorun/core/contracts";
+export { SUBJECT_SCOPES } from "@nylorun/core/contracts";
 export { AgentsClient, SessionClient, createClient } from "./client.js";
-export type { AgentSource, SessionView, CommandOptions, SessionSandbox, } from "./client.js";
+export type { ActAsOptions, AgentSource, SessionView, CommandOptions, SessionSandbox, } from "./client.js";
 export { connectAgents } from "./executor.js";
 export type { ConnectOptions, AgentConnection } from "./executor.js";
 export type { ExecuteActionOptions, ExecutableDefinition, } from "./execute-action.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 // Definition authoring and wire contracts are the only harness runtime imports.
-export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, TENANT_HEADER, PROTOCOL_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
+export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, TENANT_HEADER, PROTOCOL_HEADER, SUBJECT_HEADER, SCOPES_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
 export { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, Loop, Chain, Switch, Parallel, Map, VerdictSchema, isVerdict, withInstructions, withoutTools, WorkflowBuildError, isBuiltWorkflow, capability, tool, defineSchema, ToolError, } from "@nylorun/core/define";
+export { SUBJECT_SCOPES } from "@nylorun/core/contracts";
 export { AgentsClient, SessionClient, createClient } from "./client.js";
 export { connectAgents } from "./executor.js";
 export { resolveConnection, ConnectionError } from "./connection.js";

package/dist/sandbox/sandbox.d.ts

@@ -17,8 +17,7 @@ export declare class SandboxError extends Error {
  * Give the agent an isolated Linux machine with a persistent `/workspace`.
  *
  * Adds the built-in `bash`, `read`, `write`, `edit`, `grep` and `glob` tools. They run in the
- * Nylorun Runtime, which picks the backend (a microsandbox VM where available). Agent code
- * declares requirements only.
+ * Nylorun Runtime, which picks the backend. Agent code declares requirements only.
  *
  * ```ts
  * Agent({ id: "analyst", instructions: "..." }).use(sandbox())

package/dist/sandbox/sandbox.js

@@ -11,8 +11,7 @@ export class SandboxError extends Error {
  * Give the agent an isolated Linux machine with a persistent `/workspace`.
  *
  * Adds the built-in `bash`, `read`, `write`, `edit`, `grep` and `glob` tools. They run in the
- * Nylorun Runtime, which picks the backend (a microsandbox VM where available). Agent code
- * declares requirements only.
+ * Nylorun Runtime, which picks the backend. Agent code declares requirements only.
  *
  * ```ts
  * Agent({ id: "analyst", instructions: "..." }).use(sandbox())