langflower 0.1.0 → 0.1.2

package/vendor/common-nodes/dist/ai/sub-agent/node.js

@@ -1,302 +0,0 @@
-import { defineLlmNode, isSteerControlPayload, toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
-import { concat, EMPTY, filter, mergeMap, Observable, of, } from 'rxjs';
-import { llmPanelUiSchema } from '../llm-panel-ui-schema.js';
-import { llmCompactionUiSchema } from '../llm-compaction-ui-schema.js';
-import { llmRecoveryUiSchema } from '../llm-recovery-ui-schema.js';
-import { AGENT_MAX_ITERATIONS_CAP, DEFAULT_AGENT_MAX_ITERATIONS, normalizeMaxIterations, } from '../normalize-max-iterations.js';
-import { appendToolInventory, createLlmSessionCycle$, demuxByKind, } from '../llm-session-shell.js';
-import { runAgentLoop, } from '../llm-loop/run-agent-loop.js';
-import { waitForSubagentResult } from '../wait-for-subagent-result.js';
-import { flattenSubAgentRegistrations, isSubAgentSpawnPayload, SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from '../sub-agent-protocol.js';
-import { collectAgentToolHandles } from '../../tools/collect-agent-tool-handles.js';
-import { parseLlmRolePreset, resolveEffectiveSkillId, } from '../llm-role-preset.js';
-import { resolveChatProviderModel } from '../resolve-chat-provider-model.js';
-import { getRunHostServices } from '../run-host-services.js';
-import { buildEffectiveSystemPrompt } from '../build-effective-system-prompt.js';
-import { normalizeCompactionConfig } from '../openai/normalize-compaction-params.js';
-import { normalizeLlmRecoveryPolicy } from '../llm-loop/normalize-llm-recovery-policy.js';
-import { createScriptedFactory, parseScriptedTurns, } from '../scripted-chat-completion-stream.js';
-const normalizeSkillIds = (raw) => {
-    if (!Array.isArray(raw)) {
-        return [];
-    }
-    return raw
-        .map((entry) => String(entry ?? '').trim())
-        .filter((entry) => entry.length > 0);
-};
-const acceptSpawn = (raw, nodeId, skillIds) => {
-    if (!isSubAgentSpawnPayload(raw)) {
-        return null;
-    }
-    if (raw.nodeId !== nodeId) {
-        return null;
-    }
-    if (raw.skillId.length > 0 && !skillIds.includes(raw.skillId)) {
-        return null;
-    }
-    return raw;
-};
-const formatSpawnUserContent = (spawn) => {
-    if (spawn.skillId.length === 0) {
-        return spawn.task;
-    }
-    return `[skill:${spawn.skillId}]\n${spawn.task}`;
-};
-const resolveTurnFactory = (context) => {
-    if (context.scriptedTurns !== undefined) {
-        return createScriptedFactory(context.scriptedTurns);
-    }
-    return context.factory;
-};
-const requireChatConfig = (providerId, model, scripted) => {
-    if (scripted) {
-        return;
-    }
-    if (providerId.trim().length === 0) {
-        throw new Error('Provider is required for Sub-Agent chat');
-    }
-    if (model.trim().length === 0) {
-        throw new Error('Model is required for Sub-Agent chat');
-    }
-};
-const runSubAgentTurn = (context, spawn, history, subagentResult$) => {
-    const scripted = context.scriptedTurns !== undefined;
-    const factory = resolveTurnFactory(context);
-    if (factory === undefined) {
-        return new Observable((subscriber) => {
-            subscriber.error(new Error('Sub-Agent chat is only available during server workflow runs'));
-        });
-    }
-    requireChatConfig(context.providerId, context.model, scripted);
-    return concat(of({
-        kind: 'historySync',
-        messages: [
-            ...history,
-            {
-                role: 'user',
-                content: formatSpawnUserContent(spawn),
-            },
-        ],
-    }), runAgentLoop({
-        factory,
-        providerId: scripted
-            ? context.providerId.trim() || 'scripted'
-            : context.providerId,
-        model: scripted
-            ? context.model.trim() || 'scripted'
-            : context.model,
-        messages: [
-            ...history,
-            { role: 'user', content: formatSpawnUserContent(spawn) },
-        ],
-        tools: context.tools,
-        toolCtx: context.toolCtx,
-        maxIterations: context.maxIterations,
-        compaction: context.compaction,
-        recovery: context.recovery,
-        subagentRegistrations: context.subagentRegistrations,
-        ...(context.requestPermission !== undefined
-            ? { requestPermission: context.requestPermission }
-            : {}),
-        ...(context.steerControl$ !== undefined
-            ? { steerControl$: context.steerControl$ }
-            : {}),
-        ...(context.subagentRegistrations.length > 0
-            ? {
-                waitForSubagentResult: (callId, signal) => waitForSubagentResult(subagentResult$, callId, signal, context.recovery.subagentTimeoutMs),
-            }
-            : {}),
-    }).pipe(mergeMap((chunk) => {
-        if (chunk.kind !== 'response') {
-            return of(chunk);
-        }
-        return of(chunk, {
-            kind: 'subagentResult',
-            payload: {
-                callId: spawn.callId,
-                result: chunk.text,
-            },
-        });
-    })));
-};
-/**
- * Sub-Agent: ordinary OpenAI-compatible agent plus `registration` announce.
- * Parent spawn arrives on `task`; final text returns on `result` with callId.
- * @see docs/ADR.md ADR-021
- */
-export const subAgentNode = defineLlmNode({
-    type: 'common-sub-agent',
-    displayName: 'Sub-Agent',
-    category: 'AI',
-    description: 'OpenAI-compatible specialist agent that announces via registration and answers parent spawns on task → result.',
-    uiSchema: [
-        {
-            field: 'name',
-            type: 'string',
-            label: 'Name',
-            default: 'Sub-Agent',
-        },
-        {
-            field: 'description',
-            type: 'string',
-            label: 'Description',
-            default: '',
-        },
-        {
-            field: 'skillIds',
-            type: 'tool-id-list',
-            label: 'Skills',
-            optionsSource: 'langflower.skills',
-        },
-        ...llmPanelUiSchema,
-        ...llmCompactionUiSchema,
-        ...llmRecoveryUiSchema,
-    ],
-    bind(ctx, { makeInput, configureOutput, combineInputs }, inventory) {
-        const { tools, mcp, subagentRegistration, subagentResult, steerControl, } = inventory;
-        const systemPrompt = makeInput('systemPrompt', {
-            name: 'systemPrompt',
-            wireType: 'string',
-            inline: 'text-multiline',
-            defaultValue: '',
-        });
-        const task = makeInput('task', {
-            name: 'task',
-            wireType: SUBAGENT_SPAWN_WIRE_TYPE,
-            required: true,
-        });
-        const registration$ = combineInputs([ctx], ([ec]) => {
-            const skillIds = normalizeSkillIds(ec.params.skillIds);
-            const name = String(ec.params.name ?? 'Sub-Agent').trim();
-            const description = String(ec.params.description ?? '');
-            return {
-                targetNodeId: ec.nodeId,
-                name: name.length > 0 ? name : 'Sub-Agent',
-                description,
-                skills: skillIds.map((skillId) => ({
-                    skillId,
-                    description: skillId,
-                })),
-            };
-        });
-        const context$ = combineInputs([systemPrompt, tools, subagentRegistration, mcp, ctx], ([systemPromptValue, toolList, subagentList, mcpList, ec]) => {
-            const rolePreset = parseLlmRolePreset(ec.params.rolePreset);
-            const skillId = resolveEffectiveSkillId(rolePreset, ec.params.skillId);
-            const hostServices = getRunHostServices(ec);
-            const skillMarkdown = hostServices?.skillMarkdown ?? '';
-            const agentsMarkdown = hostServices?.agentsMarkdown ?? '';
-            return {
-                prompt: '',
-                tools: collectAgentToolHandles({
-                    toolHandles: ec.toolHandles,
-                    toolsPort: toolList,
-                    mcpHandles: ec.mcpHandles,
-                    mcpPort: mcpList,
-                }),
-                subagentRegistrations: flattenSubAgentRegistrations(subagentList),
-                ...resolveChatProviderModel(ec.params, hostServices),
-                skillId,
-                rolePreset,
-                skillMarkdown,
-                agentsMarkdown,
-                effectiveSystemPrompt: buildEffectiveSystemPrompt({
-                    rolePreset,
-                    systemPromptInput: String(systemPromptValue ?? ''),
-                    agentsMarkdown,
-                    skillMarkdown,
-                }),
-                toolCtx: {
-                    projectDir: ec.projectDir,
-                    runId: ec.runId,
-                    ...(hostServices?.authorize !== undefined
-                        ? { authorize: hostServices.authorize }
-                        : {}),
-                    ...(hostServices?.denyPaths !== undefined
-                        ? { denyPaths: hostServices.denyPaths }
-                        : {}),
-                    ...(hostServices?.allowedHosts !== undefined
-                        ? { allowedHosts: hostServices.allowedHosts }
-                        : {}),
-                },
-                maxIterations: normalizeMaxIterations(ec.params.maxIterations, {
-                    fallback: DEFAULT_AGENT_MAX_ITERATIONS,
-                    maxCap: AGENT_MAX_ITERATIONS_CAP,
-                }),
-                maxFeedbackTurns: 0,
-                ...(hostServices?.requestPermission !== undefined
-                    ? {
-                        requestPermission: hostServices.requestPermission,
-                    }
-                    : {}),
-                compaction: normalizeCompactionConfig(ec.params),
-                recovery: normalizeLlmRecoveryPolicy(ec.params),
-                steerControl$: steerControl.value$.pipe(filter(isSteerControlPayload)),
-                factory: hostServices?.createChatCompletionStream,
-                scriptedTurns: parseScriptedTurns(ec.params['scriptedToolTurns']),
-                nodeId: ec.nodeId,
-                skillIds: normalizeSkillIds(ec.params.skillIds),
-            };
-        });
-        const cycle$ = createLlmSessionCycle$(context$, task.value$, (context) => ({
-            history: [
-                {
-                    role: 'system',
-                    content: appendToolInventory(context.effectiveSystemPrompt, context.tools),
-                },
-            ],
-            trackAssistantHistory: true,
-            appendUserFeedbackToHistory: false,
-            session: undefined,
-        }), (context, turnPayload, history, _session) => {
-            const spawn = acceptSpawn(turnPayload, context.nodeId, context.skillIds);
-            if (spawn === null) {
-                return EMPTY;
-            }
-            return runSubAgentTurn(context, spawn, history, subagentResult.value$);
-        }, { primeTurn0: false });
-        const reasoning$ = cycle$.pipeValue(demuxByKind('reasoning', (chunk) => chunk
-            .text));
-        const draftResponse$ = cycle$.pipeValue(demuxByKind('draftResponse', (chunk) => chunk
-            .text));
-        const toolLog$ = cycle$.pipeValue(demuxByKind('toolLog', (chunk) => chunk.text));
-        const recovery$ = cycle$.pipeValue(demuxByKind('recoveryNotice', (chunk) => {
-            const notice = chunk;
-            return toLlmRecoveryPortValue(notice);
-        }));
-        const response$ = cycle$.pipeValue(demuxByKind('response', (chunk) => chunk
-            .text));
-        const result$ = cycle$.pipeValue(demuxByKind('subagentResult', (chunk) => chunk.payload));
-        const nestedSubagent$ = cycle$.pipeValue(demuxByKind('subagentSpawn', (chunk) => chunk
-            .payload));
-        return {
-            inputs: [systemPrompt, task],
-            outputs: [
-                configureOutput('registration', registration$, {
-                    wireType: SUBAGENT_REGISTRATION_WIRE_TYPE,
-                }),
-                configureOutput('reasoning', reasoning$, {
-                    wireType: 'string',
-                    feed: { role: 'reasoning', streaming: true },
-                }),
-                configureOutput('draftResponse', draftResponse$, {
-                    wireType: 'string',
-                    feed: { role: 'draft', streaming: true },
-                }),
-                configureOutput('response', response$, {
-                    wireType: 'string',
-                    feed: { role: 'result' },
-                }),
-                configureOutput('result', result$, {
-                    wireType: SUBAGENT_RESULT_WIRE_TYPE,
-                    // Protocol payload for parent wiring — not work-log content.
-                    feed: { role: 'none' },
-                }),
-            ],
-            inventoryOutputs: {
-                toolLog$,
-                recovery$,
-                subagent$: nestedSubagent$,
-            },
-        };
-    },
-});

package/vendor/common-nodes/dist/ai/sub-agent-protocol.d.ts

@@ -1,39 +0,0 @@
-/**
- * Sub-Agent registration / spawn / result wire contracts (ADR-021 L0).
- * Separate from `ToolHandle` — never part of agent tool inventory.
- *
- * Named wire types (not `json`) so RuntimeEditor connection checks reject
- * unrelated structured payloads. Custom nodes:
- * `import { SUBAGENT_RESULT_WIRE_TYPE, type SubAgentResultPayload } from
- * '@langflower/common-nodes/ai/sub-agent-protocol'`.
- */
-/** Wire type strings owned by `@langflower/node-sdk` (`defineLlmNode`). */
-export { SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from '@langflower/node-sdk/llm';
-type SubAgentSkillAnnounce = {
-    readonly skillId: string;
-    readonly description: string;
-};
-/** On Sub-Agent `registration` out → main `subagentRegistration` in (combine). */
-export type SubAgentRegistration = {
-    readonly targetNodeId: string;
-    readonly name: string;
-    readonly description: string;
-    readonly skills: readonly SubAgentSkillAnnounce[];
-};
-/** Main `subagent` out → Sub-Agent `task` in (fan-out; filter by nodeId). */
-export type SubAgentSpawnPayload = {
-    readonly callId: string;
-    readonly nodeId: string;
-    /** Empty string when the main agent chose no skill. */
-    readonly skillId: string;
-    readonly task: string;
-};
-/** Sub-Agent `result` out → main `subagentResult` in (merge; router by callId). */
-export type SubAgentResultPayload = {
-    readonly callId: string;
-    readonly result: string;
-};
-export declare const isSubAgentSpawnPayload: (value: unknown) => value is SubAgentSpawnPayload;
-export declare const isSubAgentResultPayload: (value: unknown) => value is SubAgentResultPayload;
-/** Flatten multi-wire combine values (single reg or arrays). */
-export declare const flattenSubAgentRegistrations: (wired: unknown) => readonly SubAgentRegistration[];

package/vendor/common-nodes/dist/ai/sub-agent-protocol.js

@@ -1,43 +0,0 @@
-/**
- * Sub-Agent registration / spawn / result wire contracts (ADR-021 L0).
- * Separate from `ToolHandle` — never part of agent tool inventory.
- *
- * Named wire types (not `json`) so RuntimeEditor connection checks reject
- * unrelated structured payloads. Custom nodes:
- * `import { SUBAGENT_RESULT_WIRE_TYPE, type SubAgentResultPayload } from
- * '@langflower/common-nodes/ai/sub-agent-protocol'`.
- */
-/** Wire type strings owned by `@langflower/node-sdk` (`defineLlmNode`). */
-export { SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from '@langflower/node-sdk/llm';
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const isSkillAnnounce = (value) => isRecord(value) &&
-    typeof value.skillId === 'string' &&
-    typeof value.description === 'string';
-const isSubAgentRegistration = (value) => isRecord(value) &&
-    typeof value.targetNodeId === 'string' &&
-    typeof value.name === 'string' &&
-    typeof value.description === 'string' &&
-    Array.isArray(value.skills) &&
-    value.skills.every(isSkillAnnounce);
-export const isSubAgentSpawnPayload = (value) => isRecord(value) &&
-    typeof value.callId === 'string' &&
-    typeof value.nodeId === 'string' &&
-    typeof value.skillId === 'string' &&
-    typeof value.task === 'string';
-export const isSubAgentResultPayload = (value) => isRecord(value) &&
-    typeof value.callId === 'string' &&
-    typeof value.result === 'string';
-/** Flatten multi-wire combine values (single reg or arrays). */
-export const flattenSubAgentRegistrations = (wired) => {
-    const root = wired ?? [];
-    const list = Array.isArray(root) ? root : [root];
-    return list.flatMap((item) => {
-        if (Array.isArray(item)) {
-            return item.filter(isSubAgentRegistration);
-        }
-        if (isSubAgentRegistration(item)) {
-            return [item];
-        }
-        return [];
-    });
-};

package/vendor/common-nodes/dist/ai/tool-handler-context.d.ts

@@ -1,4 +0,0 @@
-import type { ExecutionContext, ToolHandlerContext } from '@langflower/node-definitions';
-/** Build invoke context for registration.handler from run `ExecutionContext`. */
-export declare const toolHandlerContextFromEc: (ec: Pick<ExecutionContext<readonly never[]>, "projectDir" | "runId" | "harness" | "crawl" | "kb" | "memory" | "createEmbedding">) => ToolHandlerContext;
-//# sourceMappingURL=tool-handler-context.d.ts.map

package/vendor/common-nodes/dist/ai/tool-handler-context.js

@@ -1,16 +0,0 @@
-/** Build invoke context for registration.handler from run `ExecutionContext`. */
-export const toolHandlerContextFromEc = (ec) => ({
-    projectDir: ec.projectDir,
-    runId: ec.runId,
-    ...(ec.harness !== undefined ? { harness: ec.harness } : {}),
-    ...(ec.harness?.webFetch !== undefined
-        ? { webFetch: ec.harness.webFetch }
-        : {}),
-    ...(ec.crawl !== undefined ? { crawl: ec.crawl } : {}),
-    ...(ec.kb !== undefined ? { kb: ec.kb } : {}),
-    ...(ec.memory !== undefined ? { memory: ec.memory } : {}),
-    ...(ec.createEmbedding !== undefined
-        ? { embedTexts: ec.createEmbedding }
-        : {}),
-});
-//# sourceMappingURL=tool-handler-context.js.map

package/vendor/common-nodes/dist/ai/tool-registration.d.ts

@@ -1,6 +0,0 @@
-export type { ToolHandlerContext, ToolRegistration, } from '@langflower/node-definitions';
-import type { ToolRegistration } from '@langflower/node-definitions';
-export declare const toolRegistrationId: (registration: ToolRegistration) => string;
-/** Flatten multi-wire values that may be single regs or arrays (domain packs). */
-export declare const flattenToolRegistrations: (wired: readonly unknown[]) => readonly ToolRegistration[];
-//# sourceMappingURL=tool-registration.d.ts.map

package/vendor/common-nodes/dist/ai/tool-registration.js

@@ -1,33 +0,0 @@
-export const toolRegistrationId = (registration) => registration.toolId;
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const isToolRegistration = (value) => {
-    if (!isRecord(value)) {
-        return false;
-    }
-    const base = typeof value.toolId === 'string' &&
-        typeof value.name === 'string' &&
-        typeof value.description === 'string' &&
-        typeof value.inputSchema === 'object' &&
-        value.inputSchema !== null;
-    if (!base) {
-        return false;
-    }
-    if (value.kind === 'handler') {
-        return typeof value.handler === 'function';
-    }
-    if (value.kind === 'harness') {
-        return true;
-    }
-    return false;
-};
-/** Flatten multi-wire values that may be single regs or arrays (domain packs). */
-export const flattenToolRegistrations = (wired) => wired.flatMap((item) => {
-    if (Array.isArray(item)) {
-        return item.filter(isToolRegistration);
-    }
-    if (isToolRegistration(item)) {
-        return [item];
-    }
-    return [];
-});
-//# sourceMappingURL=tool-registration.js.map

package/vendor/common-nodes/dist/ai/wait-for-subagent-result.d.ts

@@ -1,6 +0,0 @@
-import { type Observable } from 'rxjs';
-/**
- * Agent-node internal router: first matching `subagentResult` for `callId`,
- * aborted when the tool-loop AbortSignal fires (turn Observable teardown).
- */
-export declare const waitForSubagentResult: (result$: Observable<unknown>, callId: string, signal: AbortSignal, timeoutMs?: number) => Promise<string>;

package/vendor/common-nodes/dist/ai/wait-for-subagent-result.js

@@ -1,30 +0,0 @@
-import { filter, firstValueFrom, fromEvent, map, take, takeUntil, timeout, } from 'rxjs';
-import { isSubAgentResultPayload, } from './sub-agent-protocol.js';
-const normalizeResult = (value) => {
-    if (isSubAgentResultPayload(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        try {
-            const parsed = JSON.parse(value);
-            return isSubAgentResultPayload(parsed) ? parsed : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-};
-const observeSubagentResult = (result$, callId, signal, timeoutMs = 0) => {
-    const matching$ = result$.pipe(map(normalizeResult), filter((payload) => payload !== null && payload.callId === callId), map((payload) => payload.result), take(1), takeUntil(fromEvent(signal, 'abort')));
-    return timeoutMs > 0
-        ? matching$.pipe(timeout({ first: timeoutMs }))
-        : matching$;
-};
-/**
- * Agent-node internal router: first matching `subagentResult` for `callId`,
- * aborted when the tool-loop AbortSignal fires (turn Observable teardown).
- */
-export const waitForSubagentResult = (result$, callId, signal, timeoutMs = 0) => signal.aborted
-    ? Promise.reject(new Error('Sub-Agent wait aborted'))
-    : firstValueFrom(observeSubagentResult(result$, callId, signal, timeoutMs));

package/vendor/common-nodes/dist/catalog.d.ts

@@ -1,6 +0,0 @@
-import type { ReactiveNodeDefinition } from '@langflower/node-sdk';
-export type CommonReactiveNodeCatalog = Record<string, ReactiveNodeDefinition>;
-export declare function getCommonReactiveNodeCatalog(): CommonReactiveNodeCatalog;
-export declare function getCommonReactiveNode(type: string): ReactiveNodeDefinition | undefined;
-export { COMMON_ROUTER_TYPE, DEFAULT_ROUTER_CHANNELS, } from './flow/router/router-constants.js';
-export { resolveWorkflowNodeDefinition, type ResolveWorkflowNodeInstance, } from './resolve-workflow-node-definition.js';

package/vendor/common-nodes/dist/catalog.js

@@ -1,95 +0,0 @@
-import { fakeLlmNode } from './ai/nodes/fake-llm/node.js';
-import { openAiLlmNode } from './ai/nodes/openai-llm/node.js';
-import { mcpHttpNode } from './mcp/mcp-http/node.js';
-import { mcpStdioNode } from './mcp/mcp-stdio/node.js';
-import { chatInputNode } from './hitl/chat-input/node.js';
-import { reviewNode } from './ai/nodes/review/node.js';
-import { critiqueNode } from './ai/nodes/critique/node.js';
-import { subAgentNode } from './ai/nodes/sub-agent/node.js';
-import { checkpointNode } from './flow/checkpoint/node.js';
-import { delayNode } from './flow/delay/node.js';
-import { loopNode } from './flow/loop/node.js';
-import { mergeNode } from './flow/merge/node.js';
-import { repeatNode } from './flow/repeat/node.js';
-import { routerNode } from './flow/router/node.js';
-import { hitlReviewGateNode } from './hitl/review-gate/node.js';
-import { assertNode } from './logic/assert/node.js';
-import { compareNode } from './logic/compare/node.js';
-import { gateNode } from './logic/gate/node.js';
-import { ifNode } from './logic/if/node.js';
-import { switchNode } from './logic/switch/node.js';
-import { finishNode } from './output/finish/node.js';
-import { previewNode } from './output/preview/node.js';
-import { booleanNode } from './primitives/boolean/node.js';
-import { numberNode } from './primitives/number/node.js';
-import { stringNode } from './primitives/string/node.js';
-import { stringMultilineNode } from './primitives/string-multiline/node.js';
-import { appendFileNode } from './text/append-file/node.js';
-import { concatNode } from './text/concat/node.js';
-import { readFileNode } from './text/read-file/node.js';
-import { splitPacedNode } from './text/split-paced/node.js';
-import { writeFileNode } from './text/write-file/node.js';
-import { crawlNode } from './crawl/crawl/node.js';
-import { crawlToolsNode } from './crawl/crawl-tools/node.js';
-import { extractLinksNode } from './crawl/extract-links/node.js';
-import { fetchUrlNode } from './crawl/fetch-url/node.js';
-import { savePageNode } from './crawl/save-page/node.js';
-import { memoryToolsNode } from './memory/memory-tools/node.js';
-import { langflowerToolsNode } from './langflower-tools/node.js';
-import { toolCollectionNode } from './tools/tool-collection/node.js';
-import { embedTextNode } from './embeddings/embed-text/node.js';
-import { embedSimilarityNode } from './embeddings/embed-similarity/node.js';
-import { embedProviderNode } from './embeddings/embed-provider/node.js';
-const COMMON_REACTIVE_NODES = [
-    booleanNode,
-    numberNode,
-    stringNode,
-    stringMultilineNode,
-    mergeNode,
-    delayNode,
-    checkpointNode,
-    loopNode,
-    repeatNode,
-    routerNode,
-    previewNode,
-    finishNode,
-    concatNode,
-    splitPacedNode,
-    readFileNode,
-    writeFileNode,
-    appendFileNode,
-    hitlReviewGateNode,
-    chatInputNode,
-    fakeLlmNode,
-    openAiLlmNode,
-    mcpStdioNode,
-    mcpHttpNode,
-    reviewNode,
-    critiqueNode,
-    subAgentNode,
-    assertNode,
-    ifNode,
-    gateNode,
-    compareNode,
-    switchNode,
-    memoryToolsNode,
-    langflowerToolsNode,
-    toolCollectionNode,
-    fetchUrlNode,
-    extractLinksNode,
-    savePageNode,
-    crawlNode,
-    crawlToolsNode,
-    embedTextNode,
-    embedSimilarityNode,
-    embedProviderNode,
-];
-const COMMON_REACTIVE_NODE_CATALOG = Object.fromEntries(COMMON_REACTIVE_NODES.map((node) => [node.type, node]));
-export function getCommonReactiveNodeCatalog() {
-    return COMMON_REACTIVE_NODE_CATALOG;
-}
-export function getCommonReactiveNode(type) {
-    return COMMON_REACTIVE_NODE_CATALOG[type];
-}
-export { COMMON_ROUTER_TYPE, DEFAULT_ROUTER_CHANNELS, } from './flow/router/router-constants.js';
-export { resolveWorkflowNodeDefinition, } from './resolve-workflow-node-definition.js';

package/vendor/common-nodes/dist/compile-custom-nodes/node.d.ts

@@ -1,21 +0,0 @@
-/**
- * Emits `compile_custom_nodes` for agent inventory. The handler calls the
- * server-injected compile hook (same composer as Custom → Update).
- */
-export declare const compileCustomNodesNode: {
-    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;
-};
-//# sourceMappingURL=node.d.ts.map

package/vendor/common-nodes/dist/compile-custom-nodes/node.js

@@ -1,45 +0,0 @@
-import { defineToolRegistrations } from '@langflower/node-sdk';
-import { getRunHostServices, } from '../ai/features/run-host-services.js';
-const MISSING_HOOK_TEXT = '{ ok: false }\ncompile_custom_nodes unavailable (no server hook)';
-const formatCompileCustomNodesResult = (result) => {
-    const lines = [`status: ${result.status}`];
-    if (result.nodeTypes.length > 0) {
-        lines.push(`nodeTypes: ${result.nodeTypes.join(', ')}`);
-    }
-    if (result.errors.length > 0) {
-        lines.push('errors:');
-        for (const error of result.errors) {
-            lines.push(`- ${error.packageName}: ${error.message}`);
-        }
-    }
-    return lines.join('\n');
-};
-/**
- * Emits `compile_custom_nodes` for agent inventory. The handler calls the
- * server-injected compile hook (same composer as Custom → Update).
- */
-export const compileCustomNodesNode = defineToolRegistrations({
-    type: 'common-compile-custom-nodes',
-    displayName: 'Compile Custom Nodes',
-    category: 'Tools',
-    description: 'Emits compile_custom_nodes so an agent can recompile project custom packs (same path as Custom → Update).',
-    tools: [
-        {
-            toolId: 'compile_custom_nodes',
-            description: 'Recompile `.langflower/nodes/` packs, hot-swap live custom instances, and refresh the Custom palette. No arguments. Pack failures also write COMPILATION_ERRORS.md.',
-            inputSchema: {
-                type: 'object',
-                properties: {},
-                additionalProperties: false,
-            },
-            handler: async (_args, ctx) => {
-                const compile = getRunHostServices(ctx)?.compileCustomNodes;
-                if (compile === undefined) {
-                    return MISSING_HOOK_TEXT;
-                }
-                return formatCompileCustomNodesResult(await compile());
-            },
-        },
-    ],
-});
-//# sourceMappingURL=node.js.map