langflower 0.1.2 → 0.2.0

package/vendor/node-sdk/dist/node-factory/define-reactive-node/port-meta.d.ts

@@ -4,7 +4,7 @@ import type { StatefulObservable } from '@rx-evo/stateful-observable';
  *
  * Intentionally owned here (not imported from `@langflower/runtime`) so custom
  * node packs peer only on `@langflower/node-sdk` (+ rxjs /
- * stateful-observable). See [ADR-027](../../../../docs/ADR.md#adr-027--author-sdk-owns-port-types-no-production-runtime-dep).
+ * stateful-observable). See [ADR-027](../../../../docs/architecture/ADR.md#adr-027--author-sdk-owns-port-types-no-production-runtime-dep).
  * Structural parity with runtime is locked by `runtime-parity.types.test.ts`.
  */
 /** Same brand as runtime `RuntimeWireType` so bypass maps stay assignable. */
@@ -36,6 +36,11 @@ export type FeedRole = 'none' | 'reasoning' | 'progress' | 'draft' | 'tool' | 's
 export type FeedPortMeta = {
     readonly role?: FeedRole;
     readonly streaming?: boolean;
+    /**
+     * Runtime stamps this from the node-level `feedVisitBoundary` flag.
+     * Authors set `feedVisitBoundary` on the definition, not this field.
+     */
+    readonly closesPreviousVisit?: true;
 };
 /**
  * Typed metadata on every `statefulConnection` / `statefulObservable` `meta`.

package/vendor/node-sdk/dist/node-factory/define-reactive-node/types.d.ts

@@ -1,30 +1,30 @@
 import type { combineStatefulObservables, StatefulConnection, StatefulObservable } from '@rx-evo/stateful-observable';
+import type { CapsFor, LlmRequiredCapabilityId, NodeCapabilityId } from './capabilities.js';
 import type { ResolveSecret } from './resolve-secret.js';
-import type { ToolHandle } from '../define-tool-registrations/tool-handle.js';
 import type { CtxError } from './ctx-error.js';
 import { configureOutput, InputConfig, makeInput, OutputConfig } from './io-helpers.js';
 import type { PortMeta, WireType } from './port-meta.js';
-import type { AssertConstUISchema, ParamsFromUISchema, TypedUISchema, UISchemaConstItem } from './ui-schema-inference.js';
-/**
- * Identity + panel + keyed secret lookup. Host I/O (files/kb/crawl/…) is
- * owned by specialized common-nodes internally — not part of the author
- * ExecutionContext API. LLM inventory arrives via {@link LlmExecutionCaps}
- * (`toolHandles`). {@link resolveSecret} looks up one id (`lf_secret:ID` /
- * `env:ID`); authors cannot list the bag.
- */
-export type ExecutionContext<UI extends readonly UISchemaConstItem[] = readonly UISchemaConstItem[], Caps extends object = Record<string, never>> = {
+import type { AssertConstUISchema, ParamsFromUISchema, UISchemaConstItem } from './ui-schema-inference.js';
+type ExecutionContextHostFields<UI extends readonly UISchemaConstItem[] = readonly UISchemaConstItem[]> = {
     readonly projectDir: string;
     readonly runId: string;
     readonly nodeId: string;
     readonly params: ParamsFromUISchema<UI>;
-    readonly uiSchema: TypedUISchema<UI>;
+    readonly uiSchema: UI;
     readonly resolveSecret: ResolveSecret;
-    readonly amendInput?: (patch: Readonly<Record<string, unknown>>) => void;
-} & Caps;
-/** Caps for {@link defineLlmNode} — outside world via ToolHandle only. */
-export type LlmExecutionCaps = {
-    readonly toolHandles?: readonly ToolHandle[];
 };
+/**
+ * Identity + panel + keyed secret lookup. Host I/O (files/kb/crawl/…) is
+ * owned by specialized common-nodes internally — not part of the author
+ * ExecutionContext API. Declared capabilities arrive via {@link CapsFor}
+ * (`requires` on the definition). {@link resolveSecret} looks up one id
+ * (`lf_secret:ID` / `env:ID`); authors cannot list the bag.
+ * Do not restore `amendInput` or other host-mutation / I/O fields here —
+ * keyed by `assertExecutionContextHostKeys` below.
+ */
+export type ExecutionContext<UI extends readonly UISchemaConstItem[] = readonly UISchemaConstItem[], Caps extends object = Record<string, never>> = ExecutionContextHostFields<UI> & Caps;
+/** Caps for {@link defineLlmNode} — LLM set from {@link CapsFor}. */
+export type LlmExecutionCaps = CapsFor<readonly LlmRequiredCapabilityId[]>;
 type ReactiveNodeBindResult = {
     readonly inputs: InputConfig[];
     readonly outputs: OutputConfig[];
@@ -33,8 +33,9 @@ type ReactiveNodeBindResult = {
 export type DefinedReactiveNodeConfig<UI extends readonly UISchemaConstItem[] = readonly UISchemaConstItem[], Caps extends object = Record<string, never>> = {
     /**
      * Stable catalog / persisted workflow id (`WorkflowNodePersisted.type`).
-     * Server resolves the definition with `resolveDefinition({ type })` and
-     * keys the common-nodes catalog by this string.
+     * Server resolves the definition with
+     * `resolveDefinition({ type, params })` and keys the common-nodes
+     * catalog by `type`.
      */
     readonly type: string;
     /**
@@ -63,10 +64,21 @@ export type DefinedReactiveNodeConfig<UI extends readonly UISchemaConstItem[] =
      */
     readonly description?: string;
     /**
-     * Optional string copied onto the returned definition (and thus
-     * `PaletteNodeDefinition`). No current UI or runtime consumer reads it.
+     * Canvas box used when the node has no persisted width: the editor locks
+     * both axes instead of auto-sizing, so payload cannot grow the node.
+     * Omitted → canvas auto-sizes. Persisted operator resize always wins.
+     */
+    readonly defaultCanvasSize?: {
+        readonly width: number;
+        readonly height: number;
+    };
+    /**
+     * When `true`, the first work-log frame from this node **closes the
+     * previous visit**, so a delegating node gets its own feed card instead of
+     * continuing the caller's. Omitted/`false` → frames follow the normal
+     * `feed.streaming` visit rules. Used by `common-sub-agent`.
      */
-    readonly icon?: string;
+    readonly feedVisitBoundary?: boolean;
     /**
      * When `true` on the live instance, the first **value** emission on any
      * watched output schedules `RuntimeRunner.finishRun` (`done` → `idle`).
@@ -87,6 +99,12 @@ export type DefinedReactiveNodeConfig<UI extends readonly UISchemaConstItem[] =
      * `false`. Used by `common-chat-input`.
      */
     readonly chatEntry?: boolean;
+    /**
+     * Host capabilities this node needs. Copied onto
+     * {@link ReactiveNodeDefinition.requires} (default `[]`). `bind` sees
+     * {@link CapsFor} fields as non-optional.
+     */
+    readonly requires?: readonly NodeCapabilityId[];
     /**
      * Router bypass base port id → wire type. Runtime materializes each key
      * as a multi-input base; channel outputs (`ch`, `ch@1`, …) are slot views
@@ -122,8 +140,8 @@ export type ReactiveNodeInstance<UI extends readonly UISchemaConstItem[] = reado
     readonly bypassPorts: Record<string, WireType>;
     readonly stopsRun?: boolean;
     readonly chatEntry?: boolean;
+    readonly feedVisitBoundary?: boolean;
     readonly emitOncePerActivation?: boolean;
-    readonly skipExecutionTelemetry?: boolean;
     readonly ctxConnection: StatefulConnection<ExecutionContext<UI, Caps>, CtxError, PortMeta>;
 };
 export {};

package/vendor/node-sdk/dist/node-factory/define-reactive-node/types.js

@@ -1 +1,3 @@
+const assertExecutionContextHostKeys = true;
+void assertExecutionContextHostKeys;
 export {};

package/vendor/node-sdk/dist/node-factory/define-reactive-node/ui-schema-inference.d.ts

@@ -5,7 +5,7 @@ export type UISchemaConstItem = {
     readonly type: string;
     readonly label?: string;
     readonly default?: unknown;
-    readonly placement?: 'panel' | 'inline';
+    readonly placement?: 'panel';
     /** Number field constraints — same semantics as canvas inline `{ type: 'number' }`. */
     readonly min?: number;
     readonly max?: number;

package/vendor/node-sdk/dist/node-factory/define-tool-registrations/define-tool-registrations.d.ts

@@ -1,4 +1,13 @@
-import { type ToolHandler } from './tool-handle.js';
+import { type ToolHandle, type ToolHandler } from './tool-handle.js';
+type RegistrationTool = {
+    readonly toolId: string;
+    readonly name?: string;
+    readonly description: string;
+    readonly inputSchema: object;
+    readonly handler: ToolHandler;
+};
+/** Map domain registrations onto wire {@link ToolHandle}s. */
+export declare const toToolHandles: (tools: readonly RegistrationTool[]) => readonly ToolHandle[];
 /**
  * Purpose utility atop {@link defineReactiveNode}: emit a `tools` pack as
  * {@link ToolHandle}[]. Config still takes domain `handler`s; factory maps
@@ -21,27 +30,6 @@ export declare const defineToolRegistrations: (config: {
     readonly displayName: string;
     readonly category?: string;
     readonly description?: string;
-    readonly icon?: string;
-    readonly tools: readonly {
-        readonly toolId: string;
-        readonly name?: string;
-        readonly description: string;
-        readonly inputSchema: object;
-        readonly handler: ToolHandler;
-    }[];
-}) => {
-    readonly emitOncePerActivation: boolean;
-    readonly stopsRun: boolean;
-    readonly chatEntry: boolean;
-    readonly uiSchema: readonly [];
-    readonly bypassPorts: Record<string, import("../define-reactive-node/port-meta.js").WireType>;
-    readonly inputsConfigs: readonly [import("../define-reactive-node/io-helpers.js").InputPortMeta<import("../define-reactive-node/types.js").ExecutionContext<readonly [], Record<string, never>>>, ...import("../define-reactive-node/io-helpers.js").InputPortMeta<unknown>[]];
-    readonly outputsConfigs: (import("../define-reactive-node/io-helpers.js").OutputParams & import("../define-reactive-node/port-meta.js").PortMeta)[];
-    readonly getInstance: () => import("../define-reactive-node/types.js").ReactiveNodeInstance<readonly [], Record<string, never>>;
-    readonly paletteSecondary?: true;
-    readonly description?: string;
-    readonly type: string;
-    readonly displayName: string;
-    readonly category: string | undefined;
-    readonly icon: string | undefined;
-};
+    readonly tools: readonly RegistrationTool[];
+}) => import("../define-reactive-node/define-reactive-node.js").ReactiveNodeDefinition;
+export {};

package/vendor/node-sdk/dist/node-factory/define-tool-registrations/define-tool-registrations.js

@@ -2,6 +2,14 @@ import { statefulObservable } from '@rx-evo/stateful-observable';
 import { of } from 'rxjs';
 import { defineReactiveNode } from '../define-reactive-node/define-reactive-node.js';
 import { TOOL_HANDLE_WIRE_TYPE, } from './tool-handle.js';
+/** Map domain registrations onto wire {@link ToolHandle}s. */
+export const toToolHandles = (tools) => tools.map((tool) => ({
+    toolId: tool.toolId,
+    name: tool.name ?? tool.toolId,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    invoke: tool.handler,
+}));
 /**
  * Purpose utility atop {@link defineReactiveNode}: emit a `tools` pack as
  * {@link ToolHandle}[]. Config still takes domain `handler`s; factory maps
@@ -26,17 +34,10 @@ export const defineToolRegistrations = (config) => defineReactiveNode({
     ...(config.description !== undefined
         ? { description: config.description }
         : {}),
-    ...(config.icon !== undefined ? { icon: config.icon } : {}),
     uiSchema: [],
     bind(_ctx, { configureOutput }) {
         const tools$ = statefulObservable({
-            loader: () => of(config.tools.map((tool) => ({
-                toolId: tool.toolId,
-                name: tool.name ?? tool.toolId,
-                description: tool.description,
-                inputSchema: tool.inputSchema,
-                invoke: tool.handler,
-            }))),
+            loader: () => of(toToolHandles(config.tools)),
         });
         return {
             inputs: [],

package/vendor/node-sdk/dist/testing/create-node-harness.d.ts

@@ -2,7 +2,7 @@ import type { ReactiveNodeDefinition, ReactiveNodeInstance } from '../node-facto
 import { type UISchemaConstItem } from '../node-factory/define-reactive-node/ui-schema-inference.js';
 type HarnessUi = readonly UISchemaConstItem[];
 type HarnessInstance = ReactiveNodeInstance<HarnessUi, object>;
-export type NodeHarnessOptions = {
+type NodeHarnessBaseOptions = {
     readonly projectDir?: string;
     readonly runId?: string;
     readonly nodeId?: string;
@@ -12,6 +12,13 @@ export type NodeHarnessOptions = {
     /** Env map for `env:ID`. Omitted → `process.env`. */
     readonly env?: Readonly<Record<string, string | undefined>>;
 };
+export type NodeHarnessOptions<Caps extends object = Record<string, never>> = [
+    keyof Caps
+] extends [never] ? NodeHarnessBaseOptions & {
+    readonly caps?: Caps;
+} : NodeHarnessBaseOptions & {
+    readonly caps: Caps;
+};
 export type CollectedPort<T> = {
     readonly values: readonly T[];
     readonly stop: () => void;
@@ -30,5 +37,5 @@ export type NodeHarness = {
  * Subscribe with `next` or `collect` **before** `send` when the graph can
  * emit synchronously.
  */
-export declare const createNodeHarness: (definition: Pick<ReactiveNodeDefinition, "getInstance" | "uiSchema">, options?: NodeHarnessOptions) => NodeHarness;
+export declare const createNodeHarness: <Caps extends object = Record<string, never>>(definition: Pick<ReactiveNodeDefinition, "getInstance" | "uiSchema">, options?: NodeHarnessOptions<Caps>) => NodeHarness;
 export {};

package/vendor/node-sdk/dist/testing/create-node-harness.js

@@ -17,7 +17,7 @@ export const createNodeHarness = (definition, options) => {
         ...defaultParamsFromUiSchema(uiSchema),
         ...options?.params,
     };
-    instance.ctxConnection.connect(of({
+    const base = {
         projectDir: options?.projectDir ?? '/tmp',
         runId: options?.runId ?? 'test',
         nodeId: options?.nodeId ?? 'node-1',
@@ -27,7 +27,11 @@ export const createNodeHarness = (definition, options) => {
             secrets: options?.secrets ?? {},
             ...(options?.env !== undefined ? { env: options.env } : {}),
         }),
-    }));
+    };
+    const ctx = options !== undefined && options.caps !== undefined
+        ? { ...base, ...options.caps }
+        : base;
+    instance.ctxConnection.connect(of(ctx));
     const send = (portId, value) => {
         const input = instance.inputs[portId];
         if (input === undefined) {

package/vendor/node-sdk/package.json

@@ -1,7 +1,12 @@
 {
 	"name": "@langflower/node-sdk",
 	"version": "0.1.0",
+	"description": "Author SDK for Langflower nodes (defineNode / defineReactiveNode)",
+	"license": "MIT",
 	"type": "module",
+	"publishConfig": {
+		"access": "public"
+	},
 	"main": "./dist/node-factory/define-reactive-node/define-reactive-node.js",
 	"types": "./dist/node-factory/define-reactive-node/define-reactive-node.d.ts",
 	"exports": {

package/vendor/runtime/dist/bypass-ports.d.ts

@@ -16,17 +16,12 @@ export type BypassSlot = {
     readonly basePortId: string;
     readonly slotIndex: number;
 };
-/** Edge `fromPort` / `toPort` shape for a bypass slot. */
-export type BypassEdgePort = readonly [basePortId: string, slotIndex: number];
 export declare const bypassSlot: (basePortId: string, slotIndex: number) => BypassSlot;
-export declare const bypassSlotFromEdgePort: (port: readonly [string, number]) => BypassSlot;
-export declare const bypassEdgePort: (slot: BypassSlot) => BypassEdgePort;
 /**
  * Checkpoint / outputs-map / tap key for a bypass slot (`ch`, `ch@1`, …).
  * Resume and telemetry must look up snapshots with this id.
  */
 export declare const bypassOutputPortId: (basePortId: string, slotIndex: number) => string;
-export declare const bypassOutputPortIdFromSlot: (slot: BypassSlot) => string;
 /** Inverse of {@link bypassOutputPortId}. */
 export declare const parseBypassOutputPortId: (outputPortId: string) => BypassSlot;
 /**
@@ -34,7 +29,6 @@ export declare const parseBypassOutputPortId: (outputPortId: string) => BypassSl
  * materialized `ch@n` output id as the portId segment.
  */
 export declare const bypassSlotKey: (nodeId: NodeId, basePortId: string, slotIndex: number) => SlotKey;
-export declare const bypassSlotKeyFromEdgePort: (nodeId: NodeId, port: readonly [string, number]) => SlotKey;
 /**
  * Checkpoint / telemetry portId for a slot. Bypass bases use
  * {@link bypassOutputPortId}; regular ports keep `portId` (slot 0).

package/vendor/runtime/dist/bypass-ports.js

@@ -4,17 +4,11 @@ export const bypassSlot = (basePortId, slotIndex) => ({
     basePortId,
     slotIndex,
 });
-export const bypassSlotFromEdgePort = (port) => bypassSlot(port[0], port[1]);
-export const bypassEdgePort = (slot) => [
-    slot.basePortId,
-    slot.slotIndex,
-];
 /**
  * Checkpoint / outputs-map / tap key for a bypass slot (`ch`, `ch@1`, …).
  * Resume and telemetry must look up snapshots with this id.
  */
 export const bypassOutputPortId = (basePortId, slotIndex) => (slotIndex === 0 ? basePortId : `${basePortId}@${slotIndex}`);
-export const bypassOutputPortIdFromSlot = (slot) => bypassOutputPortId(slot.basePortId, slot.slotIndex);
 /** Inverse of {@link bypassOutputPortId}. */
 export const parseBypassOutputPortId = (outputPortId) => {
     const at = outputPortId.lastIndexOf('@');
@@ -31,7 +25,6 @@ export const parseBypassOutputPortId = (outputPortId) => {
  * materialized `ch@n` output id as the portId segment.
  */
 export const bypassSlotKey = (nodeId, basePortId, slotIndex) => slotKey(nodeId, basePortId, slotIndex);
-export const bypassSlotKeyFromEdgePort = (nodeId, port) => bypassSlotKey(nodeId, port[0], port[1]);
 /**
  * Checkpoint / telemetry portId for a slot. Bypass bases use
  * {@link bypassOutputPortId}; regular ports keep `portId` (slot 0).

package/vendor/runtime/dist/runtime-editor.d.ts

@@ -34,7 +34,7 @@ export declare class RuntimeEditor implements RuntimeEditorApi {
         nodes: RuntimeNode[];
         edges: RuntimeEdge[];
     };
-    getClusterByNodeId(nodeId: NodeId): GraphCluster;
+    getClusterByNodeId(nodeId: NodeId): GraphCluster | false;
     setLocked(locked: boolean): void;
     dispose(): void;
     private refreshClusters;

package/vendor/runtime/dist/runtime-editor.js

@@ -193,7 +193,7 @@ export class RuntimeEditor {
     }
     getClusterByNodeId(nodeId) {
         if (!this.nodes.has(nodeId)) {
-            throw new Error(`Node ${nodeId} not found`);
+            return false;
         }
         return resolveClusterForNode(this.allClusters, nodeId);
     }

package/vendor/runtime/dist/runtime-helpers.d.ts

@@ -16,4 +16,3 @@ export declare function detectGraphClusters(nodeIds: Iterable<NodeId>, edges: re
 export declare const clusterHasChatEntry: (cluster: GraphCluster, getNode: (nodeId: NodeId) => RuntimeNode | false) => boolean;
 export declare function resolveClusterForNode(clusters: readonly GraphCluster[], nodeId: NodeId): GraphCluster;
 export declare function collectClusterSlotKeys(nodes: ReadonlyMap<NodeId, RuntimeNode>, clusterNodeIds: ReadonlySet<NodeId>): SlotKey[];
-export declare function graphHasCycle(edges: readonly RuntimeEdge[]): boolean;

package/vendor/runtime/dist/runtime-helpers.js

@@ -126,36 +126,3 @@ export function collectClusterSlotKeys(nodes, clusterNodeIds) {
     }
     return keys;
 }
-export function graphHasCycle(edges) {
-    const adjacency = new Map();
-    for (const edge of edges) {
-        const next = adjacency.get(edge.fromNodeId) ?? [];
-        next.push(edge.toNodeId);
-        adjacency.set(edge.fromNodeId, next);
-    }
-    const visited = new Set();
-    const stack = new Set();
-    const visit = (nodeId) => {
-        if (stack.has(nodeId)) {
-            return true;
-        }
-        if (visited.has(nodeId)) {
-            return false;
-        }
-        visited.add(nodeId);
-        stack.add(nodeId);
-        for (const nextId of adjacency.get(nodeId) ?? []) {
-            if (visit(nextId)) {
-                return true;
-            }
-        }
-        stack.delete(nodeId);
-        return false;
-    };
-    for (const nodeId of adjacency.keys()) {
-        if (visit(nodeId)) {
-            return true;
-        }
-    }
-    return false;
-}

package/vendor/runtime/dist/runtime-runner.d.ts

@@ -34,6 +34,7 @@ export declare class RuntimeRunner implements RuntimeRunnerApi {
     private assertNotDisposed;
     private setStatus;
     private emitRunnerEvent;
+    private targetInputFeed;
     private emitPortEvent;
     private canPreparePushedInput;
     private isInputOccupiedByEdge;
@@ -48,8 +49,11 @@ export declare class RuntimeRunner implements RuntimeRunnerApi {
      * subscriber, which is what previously reordered events against downstream
      * `input-received`s. Must still be subscribed/connected somewhere
      * (downstream `connect`, or the end-node driver) to run.
+     * `tap` is telemetry only: `stopsRun` completion is a named subscribe
+     * after wrap in `wireScope`.
      */
     private tapOutputPort;
+    private scheduleFinishOnSuccessValue;
     /**
      * Returns `source` wrapped with a `tap` that emits `input-received`
      * telemetry for the target `(nodeId, portId, slotIndex)`. Like

package/vendor/runtime/dist/runtime-runner.js

@@ -1,5 +1,5 @@
 import { combineStatefulObservables, serializeResponse, statefulObservable, } from '@rx-evo/stateful-observable';
-import { BehaviorSubject, filter, merge, of, Subject, Subscription, tap, zip, } from 'rxjs';
+import { BehaviorSubject, filter, isObservable, merge, of, Subject, Subscription, tap, zip, } from 'rxjs';
 import { checkpointPortIdForSlot, getBypassConnection, isBypassPort, } from './bypass-ports.js';
 import { normalizePortErrorValue } from './normalize-port-error-value.js';
 import { edgePortSlotKey, parseSlotKey, slotKey, } from './port-meta.js';
@@ -73,8 +73,10 @@ export class RuntimeRunner {
         return this.runScope(scopeNodeIds, scopeEdgeIds, initialPayload, resolvedRunId);
     }
     startNode(nodeId, initialPayload, runId) {
-        // Composer: resolve cluster → start scoped run
         const cluster = this.editor.getClusterByNodeId(nodeId);
+        if (cluster === false) {
+            return false;
+        }
         return this.runScope(cluster.nodeIds, cluster.edgeIds, initialPayload, runId);
     }
     resume(options) {
@@ -128,11 +130,8 @@ export class RuntimeRunner {
             this.isInputOccupiedByEdge(cfg.nodeId, cfg.portId)) {
             return false;
         }
-        let cluster;
-        try {
-            cluster = this.editor.getClusterByNodeId(cfg.nodeId);
-        }
-        catch {
+        const cluster = this.editor.getClusterByNodeId(cfg.nodeId);
+        if (cluster === false) {
             return false;
         }
         const runId = this.runScope(cluster.nodeIds, cluster.edgeIds);
@@ -209,6 +208,10 @@ export class RuntimeRunner {
         }
         this.eventsSubject.next(event);
     }
+    targetInputFeed = (nodeId, portId) => {
+        const node = this.editor.getNode(nodeId);
+        return node === false ? undefined : node.inputs[portId]?.meta.feed;
+    };
     emitPortEvent(_runId, portDir, nodeId, portId, portIdx, raw, edgeIds, defaultFeed) {
         const dto = toResponseDto(raw);
         if (dto === null) {
@@ -217,7 +220,12 @@ export class RuntimeRunner {
         const response = 'error' in dto
             ? { error: normalizePortErrorValue(dto.error) }
             : dto;
-        const feed = defaultFeed ?? null;
+        const node = this.editor.getNode(nodeId);
+        const closesPreviousVisit = node !== false && node.feedVisitBoundary === true;
+        const portFeed = defaultFeed;
+        const feed = closesPreviousVisit === true
+            ? { ...(portFeed ?? {}), closesPreviousVisit: true }
+            : (portFeed ?? null);
         const portIdStr = typeof portId === 'string' ? portId : String(portId);
         this.emitRunnerEvent([
             portDir,
@@ -260,7 +268,7 @@ export class RuntimeRunner {
         if (existing !== undefined) {
             // Telemetry before deliver so HITL input-received precedes cascade
             // (output-emitted / downstream input-received) in the event log.
-            this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, []);
+            this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, [], node.inputs[cfg.portId]?.meta.feed);
             existing.source.next(cfg.payload);
             return run.runId;
         }
@@ -279,7 +287,7 @@ export class RuntimeRunner {
             connection,
         });
         run.pushedInputSources.set(key, { source });
-        this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, []);
+        this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, [], connection.meta.feed);
         source.next(cfg.payload);
         return run.runId;
     }
@@ -293,25 +301,16 @@ export class RuntimeRunner {
      * subscriber, which is what previously reordered events against downstream
      * `input-received`s. Must still be subscribed/connected somewhere
      * (downstream `connect`, or the end-node driver) to run.
+     * `tap` is telemetry only: `stopsRun` completion is a named subscribe
+     * after wrap in `wireScope`.
      */
     tapOutputPort(run, nodeId, portId, output, edgeIds) {
         if (typeof output.meta.portId !== 'string')
             return output;
-        const node = this.editor.getNode(nodeId);
         return output
             .pipe(tap({
             next: (response) => {
-                const emittedValue = this.emitPortEvent(run.runId, 'out', nodeId, portId, 0, response, edgeIds, output.meta.feed);
-                if (emittedValue &&
-                    node !== false &&
-                    node.stopsRun === true) {
-                    const finishRunId = run.runId;
-                    queueMicrotask(() => {
-                        if (this.activeRun?.runId === finishRunId) {
-                            this.finishRun(finishRunId);
-                        }
-                    });
-                }
+                this.emitPortEvent(run.runId, 'out', nodeId, portId, 0, response, edgeIds, output.meta.feed);
             },
         }), filter((response) => {
             const dto = toResponseDto(response);
@@ -319,6 +318,17 @@ export class RuntimeRunner {
         }))
             .with({ meta: output.meta });
     }
+    scheduleFinishOnSuccessValue(runId, response) {
+        const dto = toResponseDto(response);
+        if (dto === null || !('value' in dto)) {
+            return;
+        }
+        queueMicrotask(() => {
+            if (this.activeRun?.runId === runId) {
+                this.finishRun(runId);
+            }
+        });
+    }
     /**
      * Returns `source` wrapped with a `tap` that emits `input-received`
      * telemetry for the target `(nodeId, portId, slotIndex)`. Like
@@ -331,7 +341,7 @@ export class RuntimeRunner {
         return source
             .pipe(tap({
             next: (response) => {
-                this.emitPortEvent(run.runId, 'in', nodeId, portId, slotIndex, response, edgeIds);
+                this.emitPortEvent(run.runId, 'in', nodeId, portId, slotIndex, response, edgeIds, this.targetInputFeed(nodeId, portId));
             },
         }))
             .with({ meta: source.meta });
@@ -408,7 +418,7 @@ export class RuntimeRunner {
                 this.flushPendingWire();
             }
             catch {
-                // Status/lock already restored in pendingWire.
+                this.eventsSubject.next(['done', resolvedRunId]);
             }
         });
         return resolvedRunId;
@@ -451,10 +461,13 @@ export class RuntimeRunner {
                     (meta.mode === 'single' && seed.slotIndex !== 0)) {
                     throw new Error(`Unknown seed slot ${nodeId}.${String(seed.portId)}[${seed.slotIndex}]`);
                 }
-                connection.connect(of(seed.value).pipe(tap({
+                const source$ = isObservable(seed.value)
+                    ? seed.value
+                    : of(seed.value);
+                connection.connect(source$.pipe(tap({
                     next: (value) => {
                         if (typeof seed.portId !== 'symbol') {
-                            this.emitPortEvent(runId, 'in', nodeId, seed.portId, seed.slotIndex, value, []);
+                            this.emitPortEvent(runId, 'in', nodeId, seed.portId, seed.slotIndex, value, [], connection.meta.feed);
                         }
                     },
                 })));
@@ -492,7 +505,7 @@ export class RuntimeRunner {
                 }
                 connection.connect(of(defaultValue).pipe(tap({
                     next: (value) => {
-                        this.emitPortEvent(runId, 'in', nodeId, portId, 0, value, []);
+                        this.emitPortEvent(runId, 'in', nodeId, portId, 0, value, [], connection.meta.feed);
                     },
                 })));
                 wiredSlotKeys.add(key);
@@ -726,7 +739,7 @@ export class RuntimeRunner {
                         }).with({ meta });
             group.connection.connect(combined.pipe(tap({
                 next: (response) => {
-                    this.emitPortEvent(run.runId, 'in', group.nodeId, group.portId, 0, response, group.edges.map((entry) => entry.edge.edgeId));
+                    this.emitPortEvent(run.runId, 'in', group.nodeId, group.portId, 0, response, group.edges.map((entry) => entry.edge.edgeId), group.connection.meta.feed);
                 },
             })));
             wiredSlots.push({
@@ -734,18 +747,29 @@ export class RuntimeRunner {
                 connection: group.connection,
             });
         }
-        // Subscribe end-node outputs *before* defaults/seeds so multi-value
-        // shared streams (shareReplay bufferSize 1) still deliver every chunk
-        // to unwired ports such as LLM `reasoning` / `draftResponse`. Seeds
-        // must not emit while only edge-driven outputs are subscribed.
+        // Demand-pull unwired outputs *before* defaults/seeds so multi-value
+        // shared streams still deliver every chunk to ports such as LLM
+        // `reasoning` / `draftResponse`. Seeds must not emit while only
+        // edge-driven outputs are subscribed.
+        // `stopsRun` completion is this named edge (not `tap`): wired finish
+        // outputs also subscribe so teardown is not hidden in telemetry.
         for (const key of scopeOutputKeys) {
-            if ((outputEdgeIds.get(key) ?? []).length > 0) {
+            const watched = watchedByKey.get(key);
+            if (watched === undefined) {
                 continue;
             }
-            const watched = watchedByKey.get(key);
-            if (watched !== undefined) {
-                run.subscriptions.add(watched.subscribe(() => { }));
+            const { nodeId } = parseSlotKey(key);
+            const node = nodesById.get(nodeId);
+            const isUnwired = (outputEdgeIds.get(key) ?? []).length === 0;
+            const stopsRun = node?.stopsRun === true;
+            if (!isUnwired && !stopsRun) {
+                continue;
             }
+            run.subscriptions.add(watched.subscribe((response) => {
+                if (stopsRun) {
+                    this.scheduleFinishOnSuccessValue(run.runId, response);
+                }
+            }));
         }
         const defaultScopeNodeIds = completedNodeIds.size === 0
             ? scopeNodeIds

package/vendor/runtime/dist/runtime.d.ts

@@ -3,7 +3,6 @@ import { RuntimeRunner } from './runtime-runner.js';
 import type { RuntimeOptions } from './types.js';
 export { bypassOutputPortId, parseBypassOutputPortId } from './bypass-ports.js';
 export { RuntimeEditor } from './runtime-editor.js';
-export { graphHasCycle } from './runtime-helpers.js';
 export type { GraphCluster } from './runtime-helpers.js';
 export { RuntimeRunner } from './runtime-runner.js';
 export type { MetaFromStatefulObservable, NodeId, EdgeId, RunId, PortMeta, RuntimeEdge, RuntimeEditorApi, RuntimeFeedPortMeta, RuntimeFeedRole, PortTelemetry, RuntimeDoneTelemetry, RuntimeNode, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, SwapNodeResult, } from './types.js';

package/vendor/runtime/dist/runtime.js

@@ -2,7 +2,6 @@ import { RuntimeEditor } from './runtime-editor.js';
 import { RuntimeRunner } from './runtime-runner.js';
 export { bypassOutputPortId, parseBypassOutputPortId } from './bypass-ports.js';
 export { RuntimeEditor } from './runtime-editor.js';
-export { graphHasCycle } from './runtime-helpers.js';
 export { RuntimeRunner } from './runtime-runner.js';
 export { isPortErrorTelemetry, isPortPendingTelemetry, isPortTelemetry, isPortValueTelemetry, isRuntimeDone, } from './types.js';
 export class RuntimeFacade {