langflower 0.0.1

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

@@ -0,0 +1,389 @@
+/**
+ * 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 declare const subAgentNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [{
+        readonly field: "name";
+        readonly type: "string";
+        readonly label: "Name";
+        readonly default: "Sub-Agent";
+    }, {
+        readonly field: "description";
+        readonly type: "string";
+        readonly label: "Description";
+        readonly default: "";
+    }, {
+        readonly field: "skillIds";
+        readonly type: "tool-id-list";
+        readonly label: "Skills";
+        readonly optionsSource: "langflower.skills";
+    }, {
+        readonly field: "rolePreset";
+        readonly type: "select";
+        readonly label: "Role preset";
+        readonly default: "custom";
+        readonly options: readonly [{
+            readonly value: "custom";
+            readonly title: "Custom";
+        }, {
+            readonly value: "plan";
+            readonly title: "Plan";
+        }, {
+            readonly value: "coder";
+            readonly title: "Coder";
+        }, {
+            readonly value: "explorer";
+            readonly title: "Explorer";
+        }];
+    }, {
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }, {
+        readonly field: "skillId";
+        readonly type: "select";
+        readonly label: "Skill";
+        readonly optionsSource: "langflower.skills";
+    }, {
+        readonly field: "includeAgentsMd";
+        readonly type: "boolean";
+        readonly label: "Include root AGENTS.md";
+        readonly default: false;
+    }, {
+        readonly field: "enabledToolIds";
+        readonly type: "tool-id-list";
+        readonly label: "Enabled tools";
+        readonly optionsSource: "node.wiredTools";
+    }, {
+        readonly field: "enabledMcpIds";
+        readonly type: "tool-id-list";
+        readonly label: "Enabled MCP";
+        readonly optionsSource: "langflower.mcpServers";
+    }, {
+        readonly field: "maxIterations";
+        readonly type: "number";
+        readonly label: "Tool-loop max iterations (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: number;
+        readonly step: 1;
+    }, {
+        readonly field: "maxFeedbackTurns";
+        readonly type: "number";
+        readonly label: "Max feedback turns (0 = unlimited)";
+        readonly default: 0;
+        readonly min: 0;
+        readonly max: 64;
+        readonly step: 1;
+    }, {
+        readonly field: "contextSize";
+        readonly type: "number";
+        readonly label: "Context size (approx tokens)";
+        readonly default: 32768;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "compactOnError";
+        readonly type: "boolean";
+        readonly label: "Compact on context error";
+        readonly default: false;
+    }, {
+        readonly field: "streamIdleTimeoutMs";
+        readonly type: "number";
+        readonly label: "Stream idle timeout (ms, 0 disables)";
+        readonly default: 90000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "toolTimeoutMs";
+        readonly type: "number";
+        readonly label: "Tool timeout (ms, 0 disables)";
+        readonly default: 60000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "subagentTimeoutMs";
+        readonly type: "number";
+        readonly label: "Sub-Agent timeout (ms, 0 disables)";
+        readonly default: 300000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "maxTransientRetries";
+        readonly type: "number";
+        readonly label: "Transient provider retries";
+        readonly default: 2;
+        readonly min: 0;
+        readonly max: 32;
+        readonly step: 1;
+    }];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [{
+        readonly field: "name";
+        readonly type: "string";
+        readonly label: "Name";
+        readonly default: "Sub-Agent";
+    }, {
+        readonly field: "description";
+        readonly type: "string";
+        readonly label: "Description";
+        readonly default: "";
+    }, {
+        readonly field: "skillIds";
+        readonly type: "tool-id-list";
+        readonly label: "Skills";
+        readonly optionsSource: "langflower.skills";
+    }, {
+        readonly field: "rolePreset";
+        readonly type: "select";
+        readonly label: "Role preset";
+        readonly default: "custom";
+        readonly options: readonly [{
+            readonly value: "custom";
+            readonly title: "Custom";
+        }, {
+            readonly value: "plan";
+            readonly title: "Plan";
+        }, {
+            readonly value: "coder";
+            readonly title: "Coder";
+        }, {
+            readonly value: "explorer";
+            readonly title: "Explorer";
+        }];
+    }, {
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }, {
+        readonly field: "skillId";
+        readonly type: "select";
+        readonly label: "Skill";
+        readonly optionsSource: "langflower.skills";
+    }, {
+        readonly field: "includeAgentsMd";
+        readonly type: "boolean";
+        readonly label: "Include root AGENTS.md";
+        readonly default: false;
+    }, {
+        readonly field: "enabledToolIds";
+        readonly type: "tool-id-list";
+        readonly label: "Enabled tools";
+        readonly optionsSource: "node.wiredTools";
+    }, {
+        readonly field: "enabledMcpIds";
+        readonly type: "tool-id-list";
+        readonly label: "Enabled MCP";
+        readonly optionsSource: "langflower.mcpServers";
+    }, {
+        readonly field: "maxIterations";
+        readonly type: "number";
+        readonly label: "Tool-loop max iterations (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: number;
+        readonly step: 1;
+    }, {
+        readonly field: "maxFeedbackTurns";
+        readonly type: "number";
+        readonly label: "Max feedback turns (0 = unlimited)";
+        readonly default: 0;
+        readonly min: 0;
+        readonly max: 64;
+        readonly step: 1;
+    }, {
+        readonly field: "contextSize";
+        readonly type: "number";
+        readonly label: "Context size (approx tokens)";
+        readonly default: 32768;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "compactOnError";
+        readonly type: "boolean";
+        readonly label: "Compact on context error";
+        readonly default: false;
+    }, {
+        readonly field: "streamIdleTimeoutMs";
+        readonly type: "number";
+        readonly label: "Stream idle timeout (ms, 0 disables)";
+        readonly default: 90000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "toolTimeoutMs";
+        readonly type: "number";
+        readonly label: "Tool timeout (ms, 0 disables)";
+        readonly default: 60000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "subagentTimeoutMs";
+        readonly type: "number";
+        readonly label: "Sub-Agent timeout (ms, 0 disables)";
+        readonly default: 300000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "maxTransientRetries";
+        readonly type: "number";
+        readonly label: "Transient provider retries";
+        readonly default: 2;
+        readonly min: 0;
+        readonly max: 32;
+        readonly step: 1;
+    }], import("@langflower/node-sdk/llm").LlmExecutionCaps>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (({
+        readonly wireType: string;
+    } | {
+        readonly inferTypeFrom: import("@langflower/node-sdk").InputParams<unknown> | import("@rx-evo/stateful-observable").StatefulObservable<unknown, unknown, import("@langflower/node-sdk").PortMeta>;
+    }) & import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [{
+        readonly field: "name";
+        readonly type: "string";
+        readonly label: "Name";
+        readonly default: "Sub-Agent";
+    }, {
+        readonly field: "description";
+        readonly type: "string";
+        readonly label: "Description";
+        readonly default: "";
+    }, {
+        readonly field: "skillIds";
+        readonly type: "tool-id-list";
+        readonly label: "Skills";
+        readonly optionsSource: "langflower.skills";
+    }, {
+        readonly field: "rolePreset";
+        readonly type: "select";
+        readonly label: "Role preset";
+        readonly default: "custom";
+        readonly options: readonly [{
+            readonly value: "custom";
+            readonly title: "Custom";
+        }, {
+            readonly value: "plan";
+            readonly title: "Plan";
+        }, {
+            readonly value: "coder";
+            readonly title: "Coder";
+        }, {
+            readonly value: "explorer";
+            readonly title: "Explorer";
+        }];
+    }, {
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }, {
+        readonly field: "skillId";
+        readonly type: "select";
+        readonly label: "Skill";
+        readonly optionsSource: "langflower.skills";
+    }, {
+        readonly field: "includeAgentsMd";
+        readonly type: "boolean";
+        readonly label: "Include root AGENTS.md";
+        readonly default: false;
+    }, {
+        readonly field: "enabledToolIds";
+        readonly type: "tool-id-list";
+        readonly label: "Enabled tools";
+        readonly optionsSource: "node.wiredTools";
+    }, {
+        readonly field: "enabledMcpIds";
+        readonly type: "tool-id-list";
+        readonly label: "Enabled MCP";
+        readonly optionsSource: "langflower.mcpServers";
+    }, {
+        readonly field: "maxIterations";
+        readonly type: "number";
+        readonly label: "Tool-loop max iterations (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: number;
+        readonly step: 1;
+    }, {
+        readonly field: "maxFeedbackTurns";
+        readonly type: "number";
+        readonly label: "Max feedback turns (0 = unlimited)";
+        readonly default: 0;
+        readonly min: 0;
+        readonly max: 64;
+        readonly step: 1;
+    }, {
+        readonly field: "contextSize";
+        readonly type: "number";
+        readonly label: "Context size (approx tokens)";
+        readonly default: 32768;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "compactOnError";
+        readonly type: "boolean";
+        readonly label: "Compact on context error";
+        readonly default: false;
+    }, {
+        readonly field: "streamIdleTimeoutMs";
+        readonly type: "number";
+        readonly label: "Stream idle timeout (ms, 0 disables)";
+        readonly default: 90000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "toolTimeoutMs";
+        readonly type: "number";
+        readonly label: "Tool timeout (ms, 0 disables)";
+        readonly default: 60000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "subagentTimeoutMs";
+        readonly type: "number";
+        readonly label: "Sub-Agent timeout (ms, 0 disables)";
+        readonly default: 300000;
+        readonly min: 0;
+        readonly step: 1;
+    }, {
+        readonly field: "maxTransientRetries";
+        readonly type: "number";
+        readonly label: "Transient provider retries";
+        readonly default: 2;
+        readonly min: 0;
+        readonly max: 32;
+        readonly step: 1;
+    }], import("@langflower/node-sdk/llm").LlmExecutionCaps>;
+    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/ai/sub-agent/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/ai/sub-agent/node.ts"],"names":[],"mappings":"AA4NA;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgQvB,CAAC"}

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

@@ -0,0 +1,289 @@
+import { defineLlmNode, isSteerControlPayload } 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 { 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.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),
+                providerId: String(ec.params.providerId ?? ''),
+                model: String(ec.params.model ?? ''),
+                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,
+                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 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,
+                    feed: { role: 'result' },
+                }),
+            ],
+            inventoryOutputs: {
+                toolLog$,
+                subagent$: nestedSubagent$,
+            },
+        };
+    },
+});
+//# sourceMappingURL=node.js.map