@nylorun/runtime 0.12.0-beta → 0.13.0-beta

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.13.0-beta
+
+### Minor Changes
+
+- 5278b4e: **Flow agents on workflow manifest v2.** A flow agent compiles to `workflowSchemaVersion: 2` and runs on the new `flow-2` engine; v1 workflows (`Chain`, `Switch`, `Parallel`, `Map`, `Loop`) keep running on `flow-1`, so in-flight runs finish as they began.
+
+  - **Manifest (core).** Any node may carry `id` and `input`; there are no slots. `chain` and `parallel` are bare collections, a Map is `{ map: { each } }` over its input, and a Loop has `max?` and `decide?`. The header adds `name`, `description`, `metadata`, `inputSchema` and `outputSchema`, and `agents` embeds every agent the flow runs, so one manifest hash covers the whole flow. `Agent.from(json, { nodes, agents })` rebuilds a flow agent. Path and key helpers (`leafPath`, `stageKey`, `forEachFlowNode`, `embeddedAgent`, …) are exported from `@nylorun/core/define`.
+  - **Paths (harness).** Linked agent sessions are named by the agent: its id, `[i]` per Map item, and a nested flow agent's id in front. Control stages add nothing, so wrapping a step in a Loop keeps its session. Functions are bound under stage keys (`route:on`, `@1.default.1:input`) and all receive `{ input, results, flowInput }`; `flowInput` works inside nested `flow()`. A Loop without `decide` retries with the verifier's feedback up to `max` and then fails with `loop.exhausted`. Nested flow agents run inline.
+  - **Runtime.** Leaves of a v2 workflow resolve from its embedded `agents` (with the workflow's plugin roots, keyed `<agent>/<capability>`) instead of the registry. `loop.iteration` is emitted only for a Loop's own agent turns.
+  - **Agents SDK.** `saveAgent(flowAgent)` PUTs one document; application mode registers the flow's executor with its manifest hash. An executor leaves `fn`, `verify` and tool actions of a v2 flow unclaimed when they belong to another manifest hash, because stage keys can shift between deploys; it reports each skipped action once through `onError`.
+  - **Studio.** Draws v2 manifests: agents and tools at their session paths, control stages at their stage keys, nested flow agents inline, and lights a Map's agent from its item sessions.
+  - Build diagnostics: `flow.duplicate-leaf`, `flow.duplicate-id`, `flow.agent-conflict`, `flow.v1-workflow`, `loop.invalid-verify`, `workflow.flow-agent-child`. Also fixes v1 flows passing an agent step's output to the next step still wrapped in the runtime's turn marker.
+
+- 426fd27: **Flow agents as subagents.** `.subagents(flowAgent)` lets a ReAct agent delegate to a flow agent. The flow's workflow manifest v2 is inlined in the delegating tool (`ToolManifest.agent` may be a workflow manifest), so it is saved with the parent and served by the parent's executor, plugin roots included (`<flow>/<agent>/<capability>`).
+
+  - **Engine (harness).** A call to a flow subagent is one durable `agent` effect (`role: "delegate"`) between the delegation's start and settle points; the flow's output is the tool result, and a failed flow is a failed tool result. Local `run()` refuses flow subagents, which need the Runtime.
+  - **Runtime.** The effect starts a linked flow session from the parent's pinned manifest, fresh per call, and settles when the flow's turn ends. Cancelling any session now cascades to the linked sessions it started, not only a workflow's.
+  - **Core.** `delegation.flow-unsupported` now only reports a workflow built with `Chain`, `Switch`, `Parallel`, `Map` or `Loop`. New helpers: `flowDelegatesOf`, `flowDelegateManifest`, `isFlowDelegate`; `delegatesOf` lists only the ReAct agents run in-process.
+
+### Patch Changes
+
+- Pin core to the tested release.
+- Pin harness to the tested release.
+- Updated dependencies [e537a82]
+- Updated dependencies [5278b4e]
+- Updated dependencies [426fd27]
+- Updated dependencies [8cda500]
+- Updated dependencies
+  - @nylorun/core@0.8.0-beta
+  - @nylorun/harness@0.20.0-beta
+
 ## 0.12.0-beta
 
 ### Minor Changes

package/dist/core/flow-host.js

@@ -61,6 +61,9 @@ export function deriveSessionId(workflowSessionId, path, ...parts) {
  * (path, turnId, iterations) so prior verdicts cannot leak across Loop iterations.
  */
 export function deriveAgentEffectSessionId(workflowSessionId, path, request) {
+    // A flow agent used as a tool starts fresh on every call, like any agent used as a tool.
+    if (request.context?.role === "delegate")
+        return deriveSessionId(workflowSessionId, path, "delegate", String(request.context.delegationId ?? request.turnId));
     if (request.context?.role === "verify-agent") {
         const iterations = request.iterations ?? "-";
         const iterParts = iterations !== "-" && iterations.length > 0 ? iterations.split(".") : [];

package/dist/tenant/commands.js

@@ -192,13 +192,13 @@ export async function command(ctx, id, input, scope) {
         else if (command.type === "cancel") {
             cancelledTurnId = s.activeTurnId;
             const workflowCancel = isWorkflowManifest(s.manifest);
-            const cascade = workflowCancel
-                ? await planCancelCascade({
-                    t,
-                    workflowSessionId: id,
-                    turnId: cancelledTurnId,
-                })
-                : null;
+            // Linked sessions this one started: a workflow's agents, or flow agents an agent
+            // uses as tools.
+            const cascade = await planCancelCascade({
+                t,
+                workflowSessionId: id,
+                turnId: cancelledTurnId,
+            });
             s.status = "cancelled";
             if (workflowCancel) {
                 await fenceWorkflowActions({
@@ -245,15 +245,13 @@ export async function command(ctx, id, input, scope) {
             s.error = undefined;
             // Cascade: cancel linked agent sessions deepest-first (after fencing this session), each
             // in its own transaction after this one commits (child sessions are never locked here).
-            if (cascade) {
-                for (const agentId of cascade.agentSessionIds) {
-                    const agent = await t.get("sessions", agentId);
-                    if (!agent ||
-                        !agent.activeTurnId ||
-                        ["idle", "completed", "failed", "cancelled"].includes(agent.status))
-                        continue;
-                    cascadeCancelIds.push(agentId);
-                }
+            for (const agentId of cascade.agentSessionIds) {
+                const agent = await t.get("sessions", agentId);
+                if (!agent ||
+                    !agent.activeTurnId ||
+                    ["idle", "completed", "failed", "cancelled"].includes(agent.status))
+                    continue;
+                cascadeCancelIds.push(agentId);
             }
         }
         else {

package/dist/tenant/effects.js

@@ -1,4 +1,5 @@
-import { countActiveFlowWork, deriveAgentEffectSessionId, isFlowEffect, isFlowToolEffect, linkedMessageKey, linkedTurnEnd, } from "../core/flow-host.js";
+import { embeddedAgent, flowDelegateManifest, hashManifest, isWorkflowManifestV2, } from "@nylorun/core/define";
+import { countActiveFlowWork, deriveAgentEffectSessionId, isFlowEffect, isFlowToolEffect, isWorkflowManifest, linkedMessageKey, linkedTurnEnd, } from "../core/flow-host.js";
 import { mayDispatchMore } from "../core/limits.js";
 import { canonical } from "../store/canonical.js";
 import { isOwnershipLost } from "../store/ownership.js";
@@ -10,7 +11,7 @@ import { sandboxCapabilityOf } from "../sandbox/manager.js";
 import { owningSandboxSessionId, sandboxSpecOf } from "../sandbox/share.js";
 import { loadSession, ownedSession, sandboxLookup, sessionOf, } from "./context.js";
 import { fail } from "./http.js";
-import { actionTarget, linkedAgentOutput, manifestFor, mcpToolOf, pinnedTool, } from "./session.js";
+import { actionTarget, linkedAgentOutput, manifestFor, mcpToolOf, pinnedTool, turnManifestOf, } from "./session.js";
 import { command } from "./commands.js";
 import { assistantMessage, toolCompleted, toolIds } from "./transcript.js";
 import { abortKind } from "./worker.js";
@@ -386,8 +387,7 @@ export async function resolveNewFlowEffect(ctx, request, signal, lease) {
         await ownedSession(t, lease, workflow.id);
         if (exists)
             return;
-        const definition = (await t.get("definitions", body.agentId)) ??
-            fail(404, "Definition not found");
+        const definition = await leafDefinition(t, workflow, body, request);
         const sandboxOwnerId = sandboxSpecOf(workflow.manifest) || workflow.sandboxOwnerId
             ? owningSandboxSessionId(workflow, await sandboxLookup(t, workflow.sandboxOwnerId))
             : undefined;
@@ -440,13 +440,15 @@ export async function resolveNewFlowEffect(ctx, request, signal, lease) {
     return store.tx(async (t) => {
         const s = await ownedSession(t, lease, request.sessionId);
         const agent = await sessionOf(t, agentSessionId);
-        await t.event(s.id, s.activeTurnId, "loop.iteration", {
-            path: String(request.context.loopPath ?? path.split("/")[0]),
-            n,
-            sessionId: agentSessionId,
-            turnId: accepted.turnId ?? undefined,
-            manifestHash: agent.checkpoint?.manifestHash,
-        });
+        // Only a Loop's own agent turns are iterations; a step elsewhere in the flow is not.
+        if (typeof request.context.loopPath === "string")
+            await t.event(s.id, s.activeTurnId, "loop.iteration", {
+                path: request.context.loopPath,
+                n,
+                sessionId: agentSessionId,
+                turnId: accepted.turnId ?? undefined,
+                manifestHash: agent.checkpoint?.manifestHash,
+            });
         await t.event(s.id, s.activeTurnId, "node.agent", {
             path,
             iterations,
@@ -562,3 +564,50 @@ export async function authorize(ctx, sessionId, request) {
     }
     return result;
 }
+/**
+ * The definition a flow leaf's session runs. A v2 workflow embeds its leaves, so they
+ * come from the workflow's own manifest and can't drift from it; v1 leaves come from the
+ * registry by id.
+ */
+async function leafDefinition(t, workflow, body, request) {
+    // A flow agent used as a tool: its manifest is inlined in the parent's pinned tool.
+    if (request.context.role === "delegate" && !isWorkflowManifest(workflow.manifest)) {
+        const flow = flowDelegateManifest(turnManifestOf(workflow), body.agentId);
+        if (!flow)
+            return fail(404, `Agent '${body.agentId}' is not a flow agent used as a tool`);
+        return {
+            manifest: flow,
+            manifestHash: hashManifest(flow),
+            implementationVersion: workflow.implementationVersion,
+            pluginRoots: leafPluginRoots(workflow.pluginRoots, body.agentId),
+        };
+    }
+    if (isWorkflowManifestV2(workflow.manifest)) {
+        const leaf = embeddedAgent(workflow.manifest, body.flow ?? [], body.agentId);
+        if (!leaf || isWorkflowManifestV2(leaf))
+            fail(404, `Agent '${body.agentId}' is not embedded in workflow '${workflow.manifest.id}'`);
+        const manifest = leaf;
+        return {
+            manifest,
+            manifestHash: hashManifest(manifest),
+            implementationVersion: workflow.implementationVersion,
+            pluginRoots: leafPluginRoots(workflow.pluginRoots, body.agentId),
+        };
+    }
+    const definition = await t.get("definitions", body.agentId);
+    if (!definition)
+        fail(404, "Definition not found");
+    return definition;
+}
+/**
+ * A v2 workflow keys its leaves' plugin roots `<agentId>/<capability>`, and an agent keys
+ * a flow agent it uses as a tool the same way (`<flowId>/<leafId>/<capability>`).
+ */
+function leafPluginRoots(roots, agentId) {
+    const own = {};
+    const prefix = `${agentId}/`;
+    for (const [key, root] of Object.entries(roots ?? {}))
+        if (key.startsWith(prefix))
+            own[key.slice(prefix.length)] = root;
+    return own;
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.12.0-beta";
+export declare const RUNTIME_VERSION = "0.13.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.12.0-beta";
+export const RUNTIME_VERSION = "0.13.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.12.0-beta",
+  "version": "0.13.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -58,8 +58,8 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@earendil-works/pi-ai": "0.87.0",
     "@hono/node-server": "^2.1.1",
-    "@nylorun/harness": "0.19.2-beta",
-    "@nylorun/core": "0.7.0-beta",
+    "@nylorun/harness": "0.20.0-beta",
+    "@nylorun/core": "0.8.0-beta",
     "@restatedev/restate-sdk": "1.16.9",
     "@s2-dev/streamstore": "0.27.0",
     "just-bash": "3.4.2",