langflower 0.0.10 → 0.1.0

package/vendor/common-nodes/dist/primitives/boolean/node.js

@@ -4,7 +4,13 @@ export const booleanNode = defineReactiveNode({
     type: 'common-boolean',
     displayName: 'Boolean',
     category: 'Primitives',
-    description: 'Emits a **boolean literal** from the inline `value` field.',
+    description: `
+Put a constant true/false on the canvas.
+
+Typical uses:
+- Drive IF, Gate, or Assert without another node
+- A toggle you can flip while authoring
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value$ = makeInput('value', {

package/vendor/common-nodes/dist/primitives/number/node.js

@@ -4,7 +4,13 @@ export const numberNode = defineReactiveNode({
     type: 'common-number',
     displayName: 'Number',
     category: 'Primitives',
-    description: 'Emits a **number literal** from the inline `value` field.',
+    description: `
+Put a constant number on the canvas and wire it onward.
+
+Typical uses:
+- A Repeat **count** or Delay milliseconds
+- A threshold for Compare or Loop
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value$ = makeInput('value', {

package/vendor/common-nodes/dist/primitives/string/node.js

@@ -4,7 +4,13 @@ export const stringNode = defineReactiveNode({
     type: 'common-string',
     displayName: 'String',
     category: 'Primitives',
-    description: 'Emits a **string literal** from the inline `value` field.',
+    description: `
+Put a short constant string on the canvas and wire it onward.
+
+Typical uses:
+- A file path for Read File
+- A short label or prompt fragment
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value$ = makeInput('value', {

package/vendor/common-nodes/dist/primitives/string-multiline/node.d.ts

@@ -0,0 +1,17 @@
+/** Multiline string literal — inline `value` textarea, no wire required. */
+export declare const stringMultilineNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").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;
+};

package/vendor/common-nodes/dist/primitives/string-multiline/node.js

@@ -0,0 +1,31 @@
+import { defineReactiveNode } from '@langflower/node-sdk';
+/** Multiline string literal — inline `value` textarea, no wire required. */
+export const stringMultilineNode = defineReactiveNode({
+    type: 'common-string-multiline',
+    displayName: 'String (multiline)',
+    category: 'Primitives',
+    description: `
+Paste longer text on the node — several lines, not a single field.
+
+Typical uses:
+- A prompt or email draft
+- CSV or log text to feed into Split (paced)
+`.trim(),
+    uiSchema: [],
+    bind(_ctx, { makeInput, configureOutput }) {
+        const value$ = makeInput('value', {
+            name: 'value',
+            wireType: 'string',
+            inline: 'text-multiline',
+            defaultValue: '',
+        });
+        return {
+            inputs: [value$],
+            outputs: [
+                configureOutput('value', value$, {
+                    wireType: 'string',
+                }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/text/append-file/node.js

@@ -1,4 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, map, mergeMap, throwError } from 'rxjs';
 import { getRunHostServices } from '../../ai/features/run-host-services.js';
@@ -10,7 +10,13 @@ export const appendFileNode = defineReactiveNode({
     type: 'common-append-file',
     displayName: 'Append File',
     category: 'Text',
-    description: 'Appends `content` to a project-relative file. When the file is non-empty, inserts `delimiter` before the new content.',
+    description: `
+Add **content** to the end of a project file. If the file already has text, **delimiter** is inserted first.
+
+Typical uses:
+- Append a log line
+- Grow a notes file across loop iterations
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const pathInput = makeInput('path', {
@@ -37,7 +43,9 @@ export const appendFileNode = defineReactiveNode({
             delimiter: String(rawDelimiter ?? ''),
             content: String(rawContent ?? ''),
             ec,
-        })).pipeValue(mergeMap(({ path: filePath, delimiter: fileDelimiter, content: fileContent, ec, }) => {
+        }))
+            .pipe(withLoading())
+            .pipeValue(mergeMap(({ path: filePath, delimiter: fileDelimiter, content: fileContent, ec, }) => {
             if (filePath.length === 0) {
                 return throwError(() => new Error('Append File requires a non-empty path.'));
             }

package/vendor/common-nodes/dist/text/concat/node.js

@@ -4,7 +4,11 @@ export const concatNode = defineReactiveNode({
     type: 'common-concat',
     displayName: 'Concat',
     category: 'Text',
-    description: 'Joins wired string `value` slots with a `separator` into one string. Emits only when every wired `value` slot has a new event (`multi: zip`). In `separator`, `\\n` is replaced with a line break.',
+    description: `
+Join several strings with a **separator**. Emits only when every wired string has a fresh value.
+
+Type \`\\n\` in the separator for a line break.
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput, combineInputs }) {
         const separator$ = makeInput('separator', {

package/vendor/common-nodes/dist/text/read-file/node.js

@@ -1,4 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, mergeMap, throwError } from 'rxjs';
 import { getRunHostServices } from '../../ai/features/run-host-services.js';
@@ -10,7 +10,11 @@ export const readFileNode = defineReactiveNode({
     type: 'common-read-file',
     displayName: 'Read File',
     category: 'Text',
-    description: 'Reads a project-relative file into `content`. Absolute paths are rejected. Emit on `update` to re-read.',
+    description: `
+Read a file inside the project into **content**. Absolute paths are refused.
+
+Pulse **update** to read the same path again after it changes on disk.
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const pathInput = makeInput('path', {
@@ -28,7 +32,9 @@ export const readFileNode = defineReactiveNode({
         const content$ = combineInputs([pathInput, update, ctx], ([rawPath, _update, ec]) => ({
             path: String(rawPath ?? '').trim(),
             ec,
-        })).pipeValue(mergeMap(({ path: filePath, ec }) => {
+        }))
+            .pipe(withLoading())
+            .pipeValue(mergeMap(({ path: filePath, ec }) => {
             if (filePath.length === 0) {
                 return throwError(() => new Error('Read File requires a non-empty path.'));
             }

package/vendor/common-nodes/dist/text/split-paced/node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Splits `text` on `divider` and emits one non-empty chunk per pace slot:
+ * first ASAP, later on `trigger`. After the last chunk, the next slot emits
+ * `finish: true`. Use for CSV / logs line-by-line; not the one-shot Split array.
+ */
+export declare const splitPacedNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").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;
+};

package/vendor/common-nodes/dist/text/split-paced/node.js

@@ -0,0 +1,93 @@
+import { defineReactiveNode } from '@langflower/node-sdk';
+import { asapScheduler, filter, map, observeOn, of, startWith, switchMap, take, } from 'rxjs';
+const remainingChunks = (text, divider, startFrom) => {
+    const splitDivider = divider.replaceAll('\\n', '\n');
+    const from = Math.max(0, Math.floor(Number(startFrom) || 0));
+    const pieces = String(text)
+        .split(splitDivider)
+        .map((piece) => piece.replace(/\r$/, ''))
+        .filter((piece) => piece.length > 0);
+    return pieces.slice(from).map((chunk, offset) => ({
+        text: chunk,
+        index: from + offset,
+    }));
+};
+/**
+ * Splits `text` on `divider` and emits one non-empty chunk per pace slot:
+ * first ASAP, later on `trigger`. After the last chunk, the next slot emits
+ * `finish: true`. Use for CSV / logs line-by-line; not the one-shot Split array.
+ */
+export const splitPacedNode = defineReactiveNode({
+    type: 'common-split-paced',
+    displayName: 'Split (paced)',
+    category: 'Text',
+    description: `
+Walk a large text one piece at a time — CSV rows, log lines, paragraphs.
+
+The first piece starts immediately. Pulse **trigger** for the next. After the last piece, **finish** fires so you can stop the loop.
+
+Skip ahead with **start from**. Empty pieces are ignored. In **divider**, type \`\\n\` for a line break.
+`.trim(),
+    uiSchema: [],
+    bind(_ctx, { makeInput, configureOutput, combineInputs }) {
+        const text = makeInput('text', {
+            name: 'text',
+            wireType: 'string',
+            inline: 'text-multiline',
+            required: true,
+            defaultValue: '',
+        });
+        const divider = makeInput('divider', {
+            name: 'divider',
+            wireType: 'string',
+            inline: 'text',
+            defaultValue: '\\n',
+            description: '`\\n` is replaced with a line break.',
+        });
+        const startFrom = makeInput('startFrom', {
+            name: 'start from',
+            wireType: 'number',
+            inline: { type: 'number', min: 0, step: 1 },
+            defaultValue: 0,
+        });
+        const trigger = makeInput('trigger', {
+            name: 'trigger',
+            dynamic: true,
+            required: true,
+        });
+        const session$ = combineInputs([text, divider, startFrom], ([rawText, rawDivider, rawStart]) => remainingChunks(String(rawText ?? ''), String(rawDivider ?? ''), Number(rawStart))).pipeValue(switchMap((chunks) => {
+            const n = chunks.length;
+            if (n <= 0) {
+                return of({ kind: 'finish' });
+            }
+            return trigger.value$.pipe(startWith(undefined), take(n + 1), observeOn(asapScheduler), map((_, slot) => {
+                const chunk = chunks[slot];
+                return slot < n && chunk !== undefined
+                    ? {
+                        kind: 'chunk',
+                        text: chunk.text,
+                        index: chunk.index,
+                    }
+                    : { kind: 'finish' };
+            }));
+        }));
+        const textOut$ = session$.pipeValue(filter((e) => e.kind === 'chunk'), map((e) => e.text));
+        const indexOut$ = session$.pipeValue(filter((e) => e.kind === 'chunk'), map((e) => e.index));
+        const finishOut$ = session$.pipeValue(filter((e) => e.kind === 'finish'), map(() => true));
+        return {
+            inputs: [text, divider, startFrom, trigger],
+            outputs: [
+                configureOutput('text', textOut$, {
+                    wireType: 'string',
+                }),
+                configureOutput('index', indexOut$, {
+                    wireType: 'number',
+                }),
+                configureOutput('finish', finishOut$, {
+                    wireType: 'boolean',
+                    feed: { role: 'none' },
+                }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/text/write-file/node.js

@@ -1,4 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, map, mergeMap, throwError } from 'rxjs';
 import { getRunHostServices } from '../../ai/features/run-host-services.js';
@@ -9,7 +9,13 @@ export const writeFileNode = defineReactiveNode({
     type: 'common-write-file',
     displayName: 'Write File',
     category: 'Text',
-    description: 'Writes `content` to a project-relative `path` (creates parents). Absolute paths are rejected.',
+    description: `
+Write **content** to a file inside the project (creates folders if needed). Absolute paths are refused.
+
+Typical uses:
+- Save an LLM draft
+- Persist a generated config
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const pathInput = makeInput('path', {
@@ -29,7 +35,9 @@ export const writeFileNode = defineReactiveNode({
             path: String(rawPath ?? '').trim(),
             content: String(rawContent ?? ''),
             ec,
-        })).pipeValue(mergeMap(({ path: filePath, content: fileContent, ec }) => {
+        }))
+            .pipe(withLoading())
+            .pipeValue(mergeMap(({ path: filePath, content: fileContent, ec }) => {
             if (filePath.length === 0) {
                 return throwError(() => new Error('Write File requires a non-empty path.'));
             }

package/vendor/common-nodes/dist/tools/tool-collection/node.js

@@ -19,8 +19,11 @@ export const toolCollectionNode = defineReactiveNode({
     type: 'common-tool-collection',
     displayName: 'Tool collection',
     category: 'Tools',
-    description: 'Merges many `tools` wires into one `ToolHandle[]`. ' +
-        'Duplicate toolId last-wins. Optional — agents still accept multi combine.',
+    description: `
+Combine several tool wires into one before an agent. Duplicate names: the last wire wins.
+
+Optional — you can still plug many tool packs straight into the agent.
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const tools = makeInput('tools', {

package/vendor/common-nodes/package.json

@@ -28,6 +28,10 @@
 		"./ai/openai/list-provider-models": {
 			"types": "./dist/ai/features/openai/list-provider-models.d.ts",
 			"import": "./dist/ai/features/openai/list-provider-models.js"
+		},
+		"./embeddings/create-embedding": {
+			"types": "./dist/embeddings/create-embedding.d.ts",
+			"import": "./dist/embeddings/create-embedding.js"
 		}
 	},
 	"dependencies": {

package/vendor/node-sdk/dist/node-factory/define-embed/embed-handle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Canvas capability for batch embeddings. Parallel to {@link ToolHandle}
+ * but **not** agent inventory: `embedTexts` returns float vectors, never
+ * LLM-facing strings.
+ *
+ * Wire: provider `embed` out → consumer `embed` in, both
+ * {@link EMBED_HANDLE_WIRE_TYPE}. Live closure (not JSON-serializable).
+ */
+export declare const EMBED_HANDLE_WIRE_TYPE = "embed-handle";
+export type EmbedTextRole = 'document' | 'query';
+export type EmbedTextsOptions = {
+    readonly role?: EmbedTextRole;
+    readonly signal?: AbortSignal;
+};
+export type EmbedHandle = {
+    /** Vector size for this bound model; packs MUST reject a mismatch. */
+    readonly dim: number;
+    readonly embedTexts: (texts: readonly string[], options?: EmbedTextsOptions) => Promise<readonly Float32Array[]>;
+};
+/**
+ * Duck-type guard for {@link EmbedHandle} on `defineNode` `execute` inputs
+ * (`Record<string, unknown>`). Requires a positive finite `dim` (emit only
+ * once dim is set) and an `embedTexts` function.
+ */
+export declare const isEmbedHandle: (value: unknown) => value is EmbedHandle;

package/vendor/node-sdk/dist/node-factory/define-embed/embed-handle.js

@@ -0,0 +1,25 @@
+/**
+ * Canvas capability for batch embeddings. Parallel to {@link ToolHandle}
+ * but **not** agent inventory: `embedTexts` returns float vectors, never
+ * LLM-facing strings.
+ *
+ * Wire: provider `embed` out → consumer `embed` in, both
+ * {@link EMBED_HANDLE_WIRE_TYPE}. Live closure (not JSON-serializable).
+ */
+export const EMBED_HANDLE_WIRE_TYPE = 'embed-handle';
+const isRecord = (value) => typeof value === 'object' && value !== null;
+/**
+ * Duck-type guard for {@link EmbedHandle} on `defineNode` `execute` inputs
+ * (`Record<string, unknown>`). Requires a positive finite `dim` (emit only
+ * once dim is set) and an `embedTexts` function.
+ */
+export const isEmbedHandle = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const dim = value['dim'];
+    return (typeof dim === 'number' &&
+        Number.isFinite(dim) &&
+        dim > 0 &&
+        typeof value['embedTexts'] === 'function');
+};

package/vendor/node-sdk/dist/node-factory/define-mcp/mcp-handle.d.ts

@@ -12,3 +12,4 @@ export type McpHandle = {
     /** Tools listed+bound at connect (`tools/list`; system MCP may filter). */
     readonly tools: readonly ToolHandle[];
 };
+//# sourceMappingURL=mcp-handle.d.ts.map

package/vendor/node-sdk/dist/node-factory/define-mcp/mcp-handle.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=mcp-handle.js.map

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

@@ -30,5 +30,7 @@ export type DefineNodeConfig<UI extends readonly UISchemaConstItem[] = readonly
 /**
  * Simple authoring factory: sync/Promise `execute` without RxJS.
  * Adapter over {@link defineReactiveNode} (one reactive runtime path).
+ * Stamps `{ pending: true }` on outputs before each `execute` via
+ * {@link withLoading} — authors do not call it.
  */
 export declare const defineNode: <const UI extends readonly UISchemaConstItem[]>(config: DefineNodeConfig<UI>) => ReactiveNodeDefinition;

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

@@ -1,4 +1,5 @@
 import { from, mergeMap, of, throwError } from 'rxjs';
+import { withLoading, } from '../define-reactive-node/io-helpers.js';
 import { defineReactiveNode, } from '../define-reactive-node/define-reactive-node.js';
 const inputParamsFromMeta = (portId, meta) => {
     const params = {
@@ -21,6 +22,8 @@ const inputParamsFromMeta = (portId, meta) => {
 /**
  * Simple authoring factory: sync/Promise `execute` without RxJS.
  * Adapter over {@link defineReactiveNode} (one reactive runtime path).
+ * Stamps `{ pending: true }` on outputs before each `execute` via
+ * {@link withLoading} — authors do not call it.
  */
 export const defineNode = (config) => {
     const inputEntries = Object.entries(config.inputs ?? {});
@@ -56,7 +59,7 @@ export const defineNode = (config) => {
                 }
                 return { ec, inputs };
             });
-            const result$ = combined$.pipeValue(mergeMap(({ ec, inputs }) => from(Promise.resolve(config.execute(ec, inputs)).then((outputs) => outputs, (error) => {
+            const result$ = combined$.pipe(withLoading()).pipeValue(mergeMap(({ ec, inputs }) => from(Promise.resolve(config.execute(ec, inputs)).then((outputs) => outputs, (error) => {
                 throw error instanceof Error
                     ? error
                     : new Error(String(error));

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

@@ -4,11 +4,13 @@ import type { DefinedReactiveNodeConfig, ExecutionContext, ReactiveNodeInstance
 import type { UISchemaConstItem } from './ui-schema-inference.js';
 export type { CtxError } from './ctx-error.js';
 export type { HitlButtonControl, HitlControl, HitlFileControl, HitlFileValue, HitlInputConfig, HitlPayloadTemplate, HitlTextareaControl, HitlTextValue, HitlUploadedFile, } from './hitl-config.js';
-export { configureOutput, DEFAULT_MULTILINE_MIN_HEIGHT_PX, InlineConfig, InlineSelectOption, InlineTextMultilineConfig, InputConfig, InputParams, InputPortMeta, makeInput, OutputConfig, OutputParams, OutputPortMeta, resolveMultilineInlineLayout, ResolvedMultilineInlineLayout, } from './io-helpers.js';
+export { withLoading, configureOutput, DEFAULT_MULTILINE_MIN_HEIGHT_PX, InlineConfig, InlineSelectOption, InlineTextMultilineConfig, InputConfig, InputParams, InputPortMeta, makeInput, OutputConfig, OutputParams, OutputPortMeta, resolveMultilineInlineLayout, ResolvedMultilineInlineLayout, } from './io-helpers.js';
 export type { FeedPortMeta, FeedRole } from './io-helpers.js';
 export type { InputPortMode, MetaFromStatefulObservable, PortMeta, WireType, } from './port-meta.js';
 export type { ToolHandle, ToolHandler, ToolHandlerContext, } from '../define-tool-registrations/tool-handle.js';
 export { TOOL_HANDLE_WIRE_TYPE } from '../define-tool-registrations/tool-handle.js';
+export type { EmbedHandle, EmbedTextRole, EmbedTextsOptions, } from '../define-embed/embed-handle.js';
+export { EMBED_HANDLE_WIRE_TYPE, isEmbedHandle, } from '../define-embed/embed-handle.js';
 export type { DefinedReactiveNodeConfig, ExecutionContext, ReactiveNodeInstance, } from './types.js';
 export declare const contextSymbol: unique symbol;
 /**

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

@@ -1,7 +1,8 @@
 import { combineStatefulObservables, statefulConnection, } from '@rx-evo/stateful-observable';
 import { configureOutput, makeInput } from './io-helpers.js';
-export { configureOutput, DEFAULT_MULTILINE_MIN_HEIGHT_PX, makeInput, resolveMultilineInlineLayout, } from './io-helpers.js';
+export { withLoading, configureOutput, DEFAULT_MULTILINE_MIN_HEIGHT_PX, makeInput, resolveMultilineInlineLayout, } from './io-helpers.js';
 export { TOOL_HANDLE_WIRE_TYPE } from '../define-tool-registrations/tool-handle.js';
+export { EMBED_HANDLE_WIRE_TYPE, isEmbedHandle, } from '../define-embed/embed-handle.js';
 export const contextSymbol = Symbol('node context');
 const bindHelpers = {
     makeInput,

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

@@ -1,6 +1,7 @@
 import type { FeedPortMeta, MetaFromStatefulObservable, PortMeta } from './port-meta.js';
 export type { FeedPortMeta, FeedRole } from './port-meta.js';
 import { StatefulObservable } from '@rx-evo/stateful-observable';
+import { type OperatorFunction } from 'rxjs';
 import type { HitlInputConfig } from './hitl-config.js';
 /** One choice for the `select` / `multiselect` / `radio` inline kinds. */
 export type InlineSelectOption = {
@@ -63,6 +64,10 @@ export type InputParams<T> = {
     readonly defaultValue?: T;
     /** On-node editor kind — unset means no on-node control at all. */
     readonly inline?: InlineConfig;
+    /**
+     * Hidden wire port — no canvas handle. With editable `inline`, still a
+     * visible on-node / inspector field (Chat Input `message`).
+     */
     readonly hidden?: boolean;
     readonly dynamic?: boolean;
     readonly hitl?: HitlInputConfig;
@@ -127,3 +132,13 @@ export declare function configureOutput<T>(portId: string, stream: StatefulObser
 export type OutputConfig = ReturnType<typeof configureOutput>;
 /** Serializable descriptor for one output port — `OutputConfig['meta']`. */
 export type OutputPortMeta = MetaFromStatefulObservable<OutputConfig>;
+/**
+ * Stamp `{ pending: true }` on each new success, then re-emit that success.
+ * Use on the raw SO stream **before** async `pipeValue` work:
+ *
+ * `combineInputs(...).pipe(withLoading()).pipeValue(concatMap(delay))`
+ *
+ * `pipeValue` + `delay` / `from(Promise)` does **not** create loading.
+ * Do not wrap token/chunk streams (re-pends every emit through demux).
+ */
+export declare const withLoading: <T>() => OperatorFunction<T, T>;

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

@@ -1,4 +1,5 @@
-import { statefulConnection, } from '@rx-evo/stateful-observable';
+import { isSuccess, statefulConnection, } from '@rx-evo/stateful-observable';
+import { concat, concatMap, of } from 'rxjs';
 /** Default floor for canvas/inspector multiline textareas (px). */
 export const DEFAULT_MULTILINE_MIN_HEIGHT_PX = 100;
 /** Resolve multiline layout; `null` when `config` is not text-multiline. */
@@ -86,3 +87,18 @@ export function configureOutput(portId, stream, meta) {
         },
     });
 }
+const LOADING = {
+    state: Symbol.for('@rx-evo/stateful-observable/loading'),
+};
+/**
+ * Stamp `{ pending: true }` on each new success, then re-emit that success.
+ * Use on the raw SO stream **before** async `pipeValue` work:
+ *
+ * `combineInputs(...).pipe(withLoading()).pipeValue(concatMap(delay))`
+ *
+ * `pipeValue` + `delay` / `from(Promise)` does **not** create loading.
+ * Do not wrap token/chunk streams (re-pends every emit through demux).
+ */
+export const withLoading = () => concatMap((response) => isSuccess(response)
+    ? concat(of(LOADING), of(response))
+    : of(response));

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

@@ -12,13 +12,26 @@ export type WireType = string & {
     __brand: 'RuntimeWireType';
 };
 export type InputPortMode = 'single' | 'merge' | 'combine' | 'zip' | 'bypass';
-export type FeedRole = 'none' | 'reasoning' | 'draft' | 'tool' | 'shell' | 'result' | 'recovery';
+/**
+ * Sidebar work-log role stamped on a port's `feed.role`.
+ *
+ * - `none` — omit from the work log
+ * - `reasoning` — technical growing stream; caption Reasoning (LLM thinking)
+ * - `progress` — same layout as reasoning; caption PROGRESS (ingest/crawl/job logs)
+ * - `draft` — markdown draft bubble
+ * - `tool` / `shell` — tool/shell rows (growing when streaming)
+ * - `result` — conversation bubble; one row per emit (not for multi-emit logs)
+ * - `recovery` — amber recovery banner
+ */
+export type FeedRole = 'none' | 'reasoning' | 'progress' | 'draft' | 'tool' | 'shell' | 'result' | 'recovery';
 /**
  * Feed projection metadata shared by input and output port contracts.
  *
- * `streaming: true` keeps the visit open (chunks / interleaved streams).
- * Omit it so the frame closes the visit; same-node frames while last still
- * append to that visit.
+ * `streaming: true` keeps the visit open and appends chunks on growing
+ * roles (`reasoning`, `progress`, `draft`, `tool`, `shell`). Omit
+ * `streaming` so the frame closes the visit.
+ *
+ * Progress logs use `{ role: 'progress', streaming: true }`.
  */
 export type FeedPortMeta = {
     readonly role?: FeedRole;

package/vendor/node-sdk/dist/node-factory/define-reactive-node/test/samples/delay-node.js

@@ -1,5 +1,5 @@
 import { concatMap, delay, of } from 'rxjs';
-import { defineReactiveNode } from '../../define-reactive-node.js';
+import { defineReactiveNode, withLoading } from '../../define-reactive-node.js';
 /** Pass-through with async delay on `value` input. */
 export const delaySampleNode = defineReactiveNode({
     type: 'sample-delay',
@@ -12,7 +12,9 @@ export const delaySampleNode = defineReactiveNode({
         const output$ = combineInputs([value, ctx], ([inputValue, ec]) => {
             const delayMs = Math.max(0, Number(ec.params?.delayMs ?? 50));
             return { inputValue, delayMs };
-        }).pipeValue(concatMap(({ inputValue, delayMs }) => of(inputValue).pipe(delay(delayMs))));
+        })
+            .pipe(withLoading())
+            .pipeValue(concatMap(({ inputValue, delayMs }) => of(inputValue).pipe(delay(delayMs))));
         return {
             inputs: [value],
             outputs: [

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

@@ -52,9 +52,10 @@ export type DefinedReactiveNodeConfig<UI extends readonly UISchemaConstItem[] =
      */
     readonly paletteSecondary?: boolean;
     /**
-     * Optional markdown for the palette detail popover footer
-     * (`renderMarkdown`). Omitted → no description block. Copied onto the
-     * definition / `PaletteNodeDefinition` when set.
+     * Optional markdown for the palette detail popover and inspector.
+     * Omitted → no description block. Copied onto the definition /
+     * `PaletteNodeDefinition` when set. Write user-facing use cases, not
+     * author internals.
      */
     readonly description?: string;
     /**

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

@@ -0,0 +1,30 @@
+import type { ReactiveNodeDefinition, ReactiveNodeInstance } from '../node-factory/define-reactive-node/define-reactive-node.js';
+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 = {
+    readonly projectDir?: string;
+    readonly runId?: string;
+    readonly nodeId?: string;
+    readonly params?: Readonly<Record<string, unknown>>;
+};
+export type CollectedPort<T> = {
+    readonly values: readonly T[];
+    readonly stop: () => void;
+};
+export type NodeHarness = {
+    readonly instance: HarnessInstance;
+    readonly send: (portId: string, value: unknown) => void;
+    readonly next: <T>(portId: string) => Promise<T>;
+    readonly collect: <T>(portId: string) => CollectedPort<T>;
+    readonly dispose: () => void;
+};
+/**
+ * Drive a {@link ReactiveNodeDefinition} in unit tests: seed context,
+ * `send` on input ports, `next` / `collect` on outputs.
+ *
+ * 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 {};