@nylorun/agents 0.7.0-beta → 0.9.0-beta

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

@@ -0,0 +1,20 @@
+import { Agent as CoreAgent, AgentBuilder as CoreAgentBuilder } from "@nylorun/core/define";
+import type { AgentOptions, ToolSchemaSource } from "@nylorun/core/define";
+import { type SkillsOptions } from "./skills/index.js";
+/**
+ * The agent builder with the capabilities that read files: `.skills()` and `.plugin()`.
+ * `@nylorun/agents/define` exports the portable builder from core, without them.
+ */
+export declare class AgentBuilder<Info = unknown, Schema extends ToolSchemaSource | undefined = undefined, Id extends string = string> extends CoreAgentBuilder<Info, Schema, Id> {
+    /** Load an Agent Skills folder. */
+    skills(directory: string, options?: SkillsOptions): this;
+    /** Attach an Agent Plugin package. */
+    plugin(directory: string): this;
+    output<S extends ToolSchemaSource>(schema: S): AgentBuilder<Info, S, Id>;
+}
+export declare function Agent<Info = unknown, Schema extends ToolSchemaSource | undefined = undefined, const Id extends string = string>(options: AgentOptions<Schema> & {
+    readonly id: Id;
+}): AgentBuilder<Info, Schema, Id>;
+export declare namespace Agent {
+    const from: typeof CoreAgent.from;
+}

package/dist/builder.js

@@ -0,0 +1,26 @@
+import { Agent as CoreAgent, AgentBuilder as CoreAgentBuilder, } from "@nylorun/core/define";
+import { skills } from "./skills/index.js";
+import { plugin } from "./plugins/plugin.js";
+/**
+ * The agent builder with the capabilities that read files: `.skills()` and `.plugin()`.
+ * `@nylorun/agents/define` exports the portable builder from core, without them.
+ */
+export class AgentBuilder extends CoreAgentBuilder {
+    /** Load an Agent Skills folder. */
+    skills(directory, options) {
+        return this.capability(skills(directory, options));
+    }
+    /** Attach an Agent Plugin package. */
+    plugin(directory) {
+        return this.capability(plugin(directory));
+    }
+    output(schema) {
+        return super.output(schema);
+    }
+}
+export function Agent(options) {
+    return new AgentBuilder(options);
+}
+(function (Agent) {
+    Agent.from = CoreAgent.from;
+})(Agent || (Agent = {}));

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";
@@ -37,9 +38,15 @@ function declarationsOf(agent) {
         return [];
     const found = (binding.declarations ?? []).map((item) => ({ key: item.id, item }));
     for (const tool of binding.tools ?? []) {
-        const child = delegateOf(tool)?.agent;
+        const delegate = delegateOf(tool);
+        const child = delegate?.agent;
         for (const item of child?.getBinding().declarations ?? [])
             found.push({ key: `${child.id}/${item.id}`, item });
+        // A flow agent used as a tool: its agents' declarations, keyed `<flow>/<agent>/<capability>`.
+        const flow = delegate?.workflow;
+        for (const leaf of Object.values(flow?.getBinding().agents ?? {}))
+            for (const item of leaf.declarations ?? [])
+                found.push({ key: `${flow.id}/${leaf.manifest.id}/${item.id}`, item });
     }
     return found;
 }
@@ -57,8 +64,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);
@@ -70,6 +106,22 @@ export class AgentsClient {
         return this.transport.json(`/v1/sessions${query}`, "GET", undefined, options.signal);
     }
     async saveAgent(agent, options) {
+        if (isBuiltWorkflow(agent) && agent.manifest.workflowSchemaVersion === 2) {
+            // A v2 workflow embeds its agents: one document, carrying their plugin roots.
+            const pluginRoots = {};
+            for (const binding of Object.values(agent.getBinding().agents)) {
+                const leaf = { id: binding.manifest.id, manifest: binding.manifest, getBinding: () => binding };
+                assertNoMiddlewareClosures(leaf);
+                for (const [key, root] of Object.entries(pluginRootsOf(leaf) ?? {}))
+                    pluginRoots[`${leaf.id}/${key}`] = root;
+            }
+            return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
+                requestId: options.requestId ?? id(),
+                manifest: agent.manifest,
+                implementationVersion: options.implementationVersion,
+                ...(Object.keys(pluginRoots).length === 0 ? {} : { pluginRoots }),
+            });
+        }
         if (isBuiltWorkflow(agent)) {
             for (const binding of Object.values(agent.getBinding().agents)) {
                 await this.saveAgent({

package/dist/executor.js

@@ -1,5 +1,5 @@
 import { AgentManifestSchema, ActionSchema, ActionClaimResponseSchema, } from "@nylorun/core/contracts";
-import { agentFrom, isBuiltWorkflow, } from "@nylorun/core/define";
+import { agentFrom, delegateOf, hashManifest, isFlowDelegate, isBuiltWorkflow, } from "@nylorun/core/define";
 import { AgentsClient, assertNoMiddlewareClosures, } from "./client.js";
 import { resolveConnection } from "./connection.js";
 import { deriveExecutorToken } from "./derived-credentials.js";
@@ -12,39 +12,87 @@ function implementationVersionOf(options) {
         env("NYLORUN_IMPLEMENTATION_VERSION") ??
         "dev");
 }
+/** Agents embedded in a v2 workflow: served here, but saved only as part of the workflow. */
+const embeddedAgents = new WeakMap();
 function buildAgents(options) {
     const agents = new Map();
-    const addAgent = (built) => {
+    const embedded = new Set();
+    /**
+     * Agents embedded in another definition (a v2 flow's agents, a flow agent used as a
+     * tool) may be reached from more than one place; the same definition is served once.
+     */
+    const sameAsServed = (id, manifest) => {
+        const served = agents.get(id);
+        if (!served)
+            return false;
+        if (hashManifest(served.manifest) === hashManifest(manifest))
+            return true;
+        throw new Error(`Duplicate connected agent ${id}`);
+    };
+    const addAgent = (built, shared = false) => {
         assertNoMiddlewareClosures(built);
         AgentManifestSchema.parse(built.manifest);
-        if (agents.has(built.id))
-            throw new Error(`Duplicate connected agent ${built.id}`);
+        if (shared ? sameAsServed(built.id, built.manifest) : agents.has(built.id)) {
+            if (!shared)
+                throw new Error(`Duplicate connected agent ${built.id}`);
+            return;
+        }
         agents.set(built.id, built);
+        for (const tool of built.getBinding().tools) {
+            const delegate = delegateOf(tool);
+            if (!delegate || !isFlowDelegate(delegate))
+                continue;
+            // A flow agent used as a tool runs in its own linked session: serve its code too.
+            if (!delegate.workflow)
+                throw new Error(`Flow agent '${delegate.manifest.id}' is used as a tool by '${built.id}' but has no local implementation`);
+            addWorkflow(delegate.workflow, true);
+            embedded.add(delegate.workflow.id);
+        }
+    };
+    const addWorkflow = (workflow, shared = false) => {
+        if (shared ? sameAsServed(workflow.id, workflow.manifest) : agents.has(workflow.id)) {
+            if (!shared)
+                throw new Error(`Duplicate connected agent ${workflow.id}`);
+            return;
+        }
+        agents.set(workflow.id, workflow);
+        const v2 = workflow.manifest.workflowSchemaVersion === 2;
+        for (const binding of Object.values(workflow.getBinding().agents)) {
+            addAgent(agentFrom(binding.manifest, binding.implementations), v2);
+            if (v2)
+                embedded.add(binding.manifest.id);
+        }
     };
     for (const source of options.agents) {
         if (isBuiltWorkflow(source)) {
-            if (agents.has(source.id))
-                throw new Error(`Duplicate connected agent ${source.id}`);
-            agents.set(source.id, source);
-            for (const binding of Object.values(source.getBinding().agents))
-                addAgent(agentFrom(binding.manifest, binding.implementations));
+            addWorkflow(source);
             continue;
         }
         const built = source.build?.() ?? source;
         if (isBuiltWorkflow(built)) {
-            if (agents.has(built.id))
-                throw new Error(`Duplicate connected agent ${built.id}`);
-            agents.set(built.id, built);
-            for (const binding of Object.values(built.getBinding().agents))
-                addAgent(agentFrom(binding.manifest, binding.implementations));
+            addWorkflow(built);
             continue;
         }
         addAgent(built);
     }
     if (!agents.size)
         throw new Error("connectAgents requires at least one agent");
+    // A definition passed in directly is saved on its own, even if another one embeds it.
+    for (const source of options.agents)
+        embedded.delete(source.id);
+    embeddedAgents.set(agents, embedded);
     return agents;
 }
+/**
+ * The manifest hash an executor serves for a workflow's flow actions. A run is pinned to
+ * one workflow manifest, and its stage keys may shift between deploys, so flow actions
+ * for another hash are left for the executor that serves it.
+ */
+function flowManifestHash(agent) {
+    return isBuiltWorkflow(agent) && agent.manifest.workflowSchemaVersion === 2
+        ? hashManifest(agent.manifest)
+        : undefined;
+}
 function connectExecutorMode(options, runtime, agents) {
     const transport = new Transport(runtime, "executor");
     const version = implementationVersionOf(options);
@@ -65,6 +113,7 @@ function connectExecutorMode(options, runtime, agents) {
         }
         catch { }
     };
+    const skipped = new Set();
     let discovering = false, dirty = false;
     const discover = async () => {
         dirty = true;
@@ -86,6 +135,14 @@ function connectExecutorMode(options, runtime, agents) {
                     const agent = agents.get(action.agentId);
                     if (!agent || action.status !== "pending" || active.has(action.actionId))
                         continue;
+                    const served = flowManifestHash(agent);
+                    if (served !== undefined && "key" in action && action.manifestHash !== served) {
+                        if (!skipped.has(action.actionId)) {
+                            skipped.add(action.actionId);
+                            report(new Error(`Skipped action ${action.actionId}: it belongs to manifest ${action.manifestHash} of '${action.agentId}', and this executor serves ${served}`));
+                        }
+                        continue;
+                    }
                     const work = new AbortController();
                     active.set(action.actionId, work);
                     let delivered = false;
@@ -264,14 +321,21 @@ function connectApplicationMode(options, application, agents) {
     });
     void ready.catch(() => { });
     const boot = (async () => {
+        const embedded = embeddedAgents.get(agents) ?? new Set();
         for (const agent of agents.values()) {
+            if (embedded.has(agent.id))
+                continue;
             await application.saveAgent(agent, { implementationVersion: version });
         }
-        const registrations = [...agents.values()].map((agent) => ({
-            agentId: agent.id,
-            token: deriveExecutorToken(application.transport.key, application.transport.tenant, agent.id),
-            implementationVersion: version,
-        }));
+        const registrations = [...agents.values()].map((agent) => {
+            const manifestHash = flowManifestHash(agent);
+            return {
+                agentId: agent.id,
+                token: deriveExecutorToken(application.transport.key, application.transport.tenant, agent.id),
+                implementationVersion: version,
+                ...(manifestHash === undefined ? {} : { manifestHash }),
+            };
+        });
         await application.transport.json("/v1/executors", "PUT", {
             executors: registrations,
         });

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,13 @@
-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 { Agent, AgentBuilder } from "./builder.js";
+export { AgentBuildError, AgentLifecycleError, Loop, Chain, Switch, Parallel, Map, VerdictSchema, isVerdict, withInstructions, withoutTools, WorkflowBuildError, isBuiltWorkflow, capability, CapabilityBuilder, flow, tool, defineSchema, ToolError, } from "@nylorun/core/define";
+export type { FlowAgentBuilder, Flow, Named, StageArgs, NestedStageArgs, CapabilityIdentity, } 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";
@@ -22,7 +25,7 @@ export type { StdioLaunch } from "./plugins/launch.js";
 export { skills, loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, formatSkillCatalog, SKILLS_USAGE, } from "./skills/index.js";
 export type { SkillsCapability, SkillsOptions, SkillDiagnostic, } from "./skills/index.js";
 export { mcp, McpError } from "./mcp/index.js";
-export type { McpCapability, McpOptions } from "./mcp/index.js";
+export type { McpCapability, McpOptions, McpServerSpec } from "./mcp/index.js";
 export { sandbox, SandboxError } from "./sandbox/index.js";
 export type { SandboxCapability, SandboxCapabilityOptions, SandboxOptions, ActionSandbox, ActionSandboxToolResult, CreateActionSandboxOptions, } from "./sandbox/index.js";
 export { createActionSandbox, definitionDeclaresSandbox, isActionSandboxTool, } from "./sandbox/index.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 // 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 { Agent, AgentBuilder, AgentBuildError, AgentLifecycleError, Loop, Chain, Switch, Parallel, Map, VerdictSchema, isVerdict, withInstructions, withoutTools, WorkflowBuildError, isBuiltWorkflow, capability, tool, defineSchema, ToolError, } from "@nylorun/core/define";
+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 } from "./builder.js";
+export { AgentBuildError, AgentLifecycleError, Loop, Chain, Switch, Parallel, Map, VerdictSchema, isVerdict, withInstructions, withoutTools, WorkflowBuildError, isBuiltWorkflow, capability, CapabilityBuilder, flow, 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";