langflower 0.0.8 → 0.0.10

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

@@ -0,0 +1,417 @@
+import { defineLlmNode, isSteerControlPayload, toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
+import { TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { randomUUID } from 'node:crypto';
+import { catchError, concat, filter, firstValueFrom, map, mergeMap, of, Subject, switchMap, take, tap, timeout, TimeoutError, } from 'rxjs';
+import { llmPanelUiSchema } from '../../features/ui-schema/llm-panel-ui-schema.js';
+import { llmCompactionUiSchema } from '../../features/ui-schema/llm-compaction-ui-schema.js';
+import { llmRecoveryUiSchema } from '../../features/ui-schema/llm-recovery-ui-schema.js';
+import { AGENT_MAX_ITERATIONS_CAP, DEFAULT_AGENT_MAX_ITERATIONS, normalizeMaxIterations, } from '../../features/prompt/normalize-max-iterations.js';
+import { appendToolInventory, demuxByKind, } from '../../features/llm-session/llm-session-shell.js';
+import { runAgentLoop, } from '../../features/llm-loop/run-agent-loop.js';
+import { collectAgentToolHandles } from '../../../tools/collect-agent-tool-handles.js';
+import { parseLlmRolePreset, resolveEffectiveSkillId, } from '../../features/llm-role-preset.js';
+import { resolveChatProviderModel } from '../../features/prompt/resolve-chat-provider-model.js';
+import { getRunHostServices } from '../../features/run-host-services.js';
+import { buildEffectiveSystemPrompt } from '../../features/prompt/build-effective-system-prompt.js';
+import { normalizeCompactionConfig } from '../../features/openai/normalize-compaction-params.js';
+import { normalizeLlmRecoveryPolicy } from '../../features/llm-loop/normalize-llm-recovery-policy.js';
+import { createScriptedFactory, parseScriptedTurns, } from '../../features/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 formatSpecialistHandleName = (displayName) => `${displayName}(subagent)`;
+const slugToolId = (name, nodeId) => {
+    const slug = (raw) => raw
+        .replace(/[^a-zA-Z0-9_-]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .slice(0, 64);
+    const fromName = slug(name.trim());
+    if (fromName.length > 0) {
+        return fromName;
+    }
+    const fromNode = slug(nodeId);
+    return fromNode.length > 0 ? fromNode : 'subagent';
+};
+const formatSpawnUserContent = (task, skillId) => {
+    if (skillId.length === 0) {
+        return task;
+    }
+    return `[skill:${skillId}]\n${task}`;
+};
+const buildSpecialistDescription = (name, description, skillIds) => {
+    const parts = [
+        `${name} is a canvas Sub-Agent — a separate specialist agent, not a regular tool (not files, shell, or MCP).`,
+        'Call this tool to delegate a task; the specialist runs its own model and tools and returns a text result.',
+        'Do not try to do this specialist work yourself when this tool is the right owner.',
+    ];
+    if (description.trim().length > 0) {
+        parts.push(description.trim());
+    }
+    if (skillIds.length > 0) {
+        parts.push(`Skills: ${skillIds.join(', ')}.`);
+    }
+    parts.push('Required argument: task — the assignment for this Sub-Agent.');
+    return parts.join(' ');
+};
+const buildSpecialistInputSchema = (skillIds) => {
+    const properties = {
+        task: {
+            type: 'string',
+            description: 'Task to delegate to this Sub-Agent specialist',
+        },
+    };
+    if (skillIds.length > 0) {
+        properties.skillId = {
+            type: 'string',
+            enum: [...skillIds],
+            description: 'Optional skill announced by this Sub-Agent Inspector selector',
+        };
+    }
+    return {
+        type: 'object',
+        properties,
+        required: ['task'],
+    };
+};
+const resolveTurnFactory = (context) => {
+    if (context.scriptedTurns !== undefined) {
+        return createScriptedFactory(context.scriptedTurns);
+    }
+    return context.factory;
+};
+const chatConfigError = (providerId, model, scripted) => {
+    if (scripted) {
+        return undefined;
+    }
+    if (providerId.trim().length === 0) {
+        return 'Error: Provider is required for Sub-Agent chat';
+    }
+    if (model.trim().length === 0) {
+        return 'Error: Model is required for Sub-Agent chat';
+    }
+    return undefined;
+};
+const EMPTY_INVOKE_RESULT = 'Error: Sub-Agent returned no content';
+const finalizeInvokeText = (responseText, lastDraft, lastReasoning) => {
+    if (responseText.trim().length > 0) {
+        return responseText;
+    }
+    if (lastDraft.trim().length > 0) {
+        return lastDraft;
+    }
+    if (lastReasoning.trim().length > 0) {
+        return lastReasoning;
+    }
+    return EMPTY_INVOKE_RESULT;
+};
+const seedInvokeHistory = (history, context) => {
+    const system = {
+        role: 'system',
+        content: appendToolInventory(context.effectiveSystemPrompt, context.tools),
+    };
+    if (history.length === 0) {
+        return [system];
+    }
+    if (history[0]?.role === 'system') {
+        return [system, ...history.slice(1)];
+    }
+    return [system, ...history];
+};
+const reduceInvokeHistory = (history, chunk) => {
+    if (chunk.kind === 'historySync') {
+        return [...chunk.messages];
+    }
+    if (chunk.kind === 'invokeDone' && chunk.text.trim().length > 0) {
+        return [...history, { role: 'assistant', content: chunk.text }];
+    }
+    return history;
+};
+const runSubAgentTurn = (context, turn, history) => {
+    const fail = (text) => of({ kind: 'response', text }, {
+        kind: 'invokeDone',
+        requestId: turn.requestId,
+        text,
+    });
+    const scripted = context.scriptedTurns !== undefined;
+    const factory = resolveTurnFactory(context);
+    if (factory === undefined) {
+        return fail('Error: Sub-Agent chat is only available during server workflow runs');
+    }
+    const configError = chatConfigError(context.providerId, context.model, scripted);
+    if (configError !== undefined) {
+        return fail(configError);
+    }
+    const userContent = formatSpawnUserContent(turn.task, turn.skillId);
+    let lastDraft = '';
+    let lastReasoning = '';
+    return concat(of({
+        kind: 'historySync',
+        messages: [
+            ...history,
+            {
+                role: 'user',
+                content: userContent,
+            },
+        ],
+    }), runAgentLoop({
+        factory,
+        providerId: scripted
+            ? context.providerId.trim() || 'scripted'
+            : context.providerId,
+        model: scripted
+            ? context.model.trim() || 'scripted'
+            : context.model,
+        messages: [...history, { role: 'user', content: userContent }],
+        tools: context.tools,
+        toolCtx: context.toolCtx,
+        maxIterations: context.maxIterations,
+        compaction: context.compaction,
+        recovery: context.recovery,
+        ...(context.requestPermission !== undefined
+            ? { requestPermission: context.requestPermission }
+            : {}),
+        ...(context.steerControl$ !== undefined
+            ? { steerControl$: context.steerControl$ }
+            : {}),
+    }).pipe(mergeMap((chunk) => {
+        if (chunk.kind === 'reasoning' && chunk.text.length > 0) {
+            lastReasoning += chunk.text;
+        }
+        if (chunk.kind === 'draftResponse' && chunk.text.length > 0) {
+            lastDraft += chunk.text;
+        }
+        if (chunk.kind !== 'response') {
+            return of(chunk);
+        }
+        const text = finalizeInvokeText(chunk.text, lastDraft, lastReasoning);
+        return of({ kind: 'response', text }, {
+            kind: 'invokeDone',
+            requestId: turn.requestId,
+            text,
+        });
+    }), catchError((error) => {
+        const text = error instanceof Error
+            ? `Error: ${error.message}`
+            : 'Error: Sub-Agent turn failed.';
+        return fail(text);
+    })));
+};
+const parseInvokeTurn = (raw, skillIds) => {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return {
+            ok: false,
+            text: 'Error: Sub-Agent invoke payload is invalid.',
+        };
+    }
+    const record = raw;
+    const requestId = typeof record.requestId === 'string' && record.requestId.length > 0
+        ? record.requestId
+        : randomUUID();
+    const task = typeof record.task === 'string' ? record.task.trim() : '';
+    const skillId = typeof record.skillId === 'string' ? record.skillId.trim() : '';
+    if (task.length === 0) {
+        return {
+            ok: false,
+            text: 'Error: Sub-Agent requires a non-empty task.',
+        };
+    }
+    if (skillId.length > 0 && !skillIds.includes(skillId)) {
+        return {
+            ok: false,
+            text: `Error: Skill «${skillId}» is not announced by this Sub-Agent.`,
+        };
+    }
+    return { ok: true, turn: { requestId, task, skillId } };
+};
+/**
+ * Sub-Agent: ordinary OpenAI-compatible agent that announces one ToolHandle
+ * on `subagent-registration`. Parent invoke runs this node's in-node loop.
+ * @see docs/ADR.md ADR-021
+ */
+export const subAgentNode = defineLlmNode({
+    type: 'common-sub-agent',
+    displayName: 'Sub-Agent',
+    category: 'AI',
+    description: 'OpenAI-compatible specialist agent. Wire `tools` into a parent agent; invoke runs this node in-graph.',
+    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, steerControl } = inventory;
+        const systemPrompt = makeInput('systemPrompt', {
+            name: 'systemPrompt',
+            wireType: 'string',
+            inline: 'text-multiline',
+            defaultValue: '',
+        });
+        const chunks$ = new Subject();
+        let latestContext;
+        let history = [];
+        let invokeTail = Promise.resolve();
+        const context$ = combineInputs([systemPrompt, tools, ctx], ([systemPromptValue, toolList, 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 ?? '';
+            const name = String(ec.params.name ?? 'Sub-Agent').trim();
+            const inspectorDescription = String(ec.params.description ?? '');
+            return {
+                prompt: '',
+                tools: collectAgentToolHandles({
+                    toolHandles: ec.toolHandles,
+                    toolsPort: toolList,
+                }),
+                ...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,
+                displayName: name.length > 0 ? name : 'Sub-Agent',
+                inspectorDescription,
+                skillIds: normalizeSkillIds(ec.params.skillIds),
+            };
+        });
+        // Inner chunks stay values. `statefulObservable({ input: chunks$ })`
+        // re-emits loading on every token; pipeValue fans it to all demux ports.
+        const cycle$ = context$.pipeValue(switchMap(() => chunks$));
+        const enqueueInvoke = (announced, args, _toolCtx) => {
+            const context = latestContext ?? announced;
+            const parsed = parseInvokeTurn({ ...args, requestId: randomUUID() }, announced.skillIds);
+            if (!parsed.ok) {
+                return Promise.resolve(parsed.text);
+            }
+            const run = () => {
+                history = seedInvokeHistory(history, context);
+                const timeoutMs = context.recovery.subagentTimeoutMs;
+                let done$ = runSubAgentTurn(context, parsed.turn, history).pipe(tap((chunk) => {
+                    history = reduceInvokeHistory(history, chunk);
+                    chunks$.next(chunk);
+                }), filter((chunk) => chunk.kind === 'invokeDone'), map((chunk) => chunk.text), take(1));
+                if (timeoutMs > 0) {
+                    done$ = done$.pipe(timeout({ first: timeoutMs }), catchError((error) => of(error instanceof TimeoutError
+                        ? `Error: Sub-Agent timed out after ${timeoutMs}ms.`
+                        : error instanceof Error
+                            ? `Error: ${error.message}`
+                            : 'Error: Sub-Agent turn failed.')));
+                }
+                return firstValueFrom(done$, {
+                    defaultValue: EMPTY_INVOKE_RESULT,
+                });
+            };
+            const next = invokeTail.then(run, run);
+            invokeTail = next.then(() => undefined, () => undefined);
+            return next;
+        };
+        const specialistTools$ = context$.pipeValue(tap((context) => {
+            latestContext = context;
+        }), map((context) => {
+            const handleName = formatSpecialistHandleName(context.displayName);
+            return [
+                {
+                    toolId: slugToolId(handleName, context.nodeId),
+                    name: handleName,
+                    description: buildSpecialistDescription(handleName, context.inspectorDescription, context.skillIds),
+                    inputSchema: buildSpecialistInputSchema(context.skillIds),
+                    invoke: (args, toolCtx) => enqueueInvoke(context, args, toolCtx),
+                },
+            ];
+        }));
+        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));
+        return {
+            inputs: [systemPrompt],
+            outputs: [
+                configureOutput('subagent-registration', specialistTools$, {
+                    name: 'subagent-registration',
+                    wireType: TOOL_HANDLE_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' },
+                }),
+            ],
+            inventoryOutputs: {
+                toolLog$,
+                recovery$,
+            },
+        };
+    },
+});

package/vendor/common-nodes/dist/ai/openai/create-chat-completion-stream.js

@@ -124,6 +124,12 @@ export const createChatCompletionStream = (deps) => {
                 messages: toOpenAiMessages(args.messages),
                 stream: true,
                 ...(tools !== undefined ? { tools } : {}),
+                ...(args.frequency_penalty !== undefined
+                    ? { frequency_penalty: args.frequency_penalty }
+                    : {}),
+                ...(args.presence_penalty !== undefined
+                    ? { presence_penalty: args.presence_penalty }
+                    : {}),
             }, {
                 signal: args.signal,
             }));

package/vendor/common-nodes/dist/ai/openai/prepare-chat-completion.d.ts

@@ -25,4 +25,6 @@ export declare const prepareChatCompletion: (args: {
     readonly tools?: readonly ChatCompletionToolDefinition[];
     readonly signal?: AbortSignal;
     readonly compaction?: LlmCompactionConfig;
+    readonly frequency_penalty?: number;
+    readonly presence_penalty?: number;
 }) => Promise<PreparedChatCompletion>;

package/vendor/common-nodes/dist/ai/openai/prepare-chat-completion.js

@@ -7,6 +7,12 @@ const createMainStream = async (args) => args.factory({
     messages: args.messages,
     ...(args.tools.length > 0 ? { tools: args.tools } : {}),
     ...(args.signal !== undefined ? { signal: args.signal } : {}),
+    ...(args.frequency_penalty !== undefined
+        ? { frequency_penalty: args.frequency_penalty }
+        : {}),
+    ...(args.presence_penalty !== undefined
+        ? { presence_penalty: args.presence_penalty }
+        : {}),
 });
 /**
  * Proactive + compact-on-error gate before consuming a chat stream.
@@ -49,6 +55,12 @@ export const prepareChatCompletion = async (args) => {
             messages,
             tools,
             ...(args.signal !== undefined ? { signal: args.signal } : {}),
+            ...(args.frequency_penalty !== undefined
+                ? { frequency_penalty: args.frequency_penalty }
+                : {}),
+            ...(args.presence_penalty !== undefined
+                ? { presence_penalty: args.presence_penalty }
+                : {}),
         });
         return {
             ok: true,
@@ -96,6 +108,12 @@ export const prepareChatCompletion = async (args) => {
                 messages,
                 tools,
                 ...(args.signal !== undefined ? { signal: args.signal } : {}),
+                ...(args.frequency_penalty !== undefined
+                    ? { frequency_penalty: args.frequency_penalty }
+                    : {}),
+                ...(args.presence_penalty !== undefined
+                    ? { presence_penalty: args.presence_penalty }
+                    : {}),
             });
             return {
                 ok: true,