langflower 0.0.10 → 0.1.1

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

@@ -1,417 +0,0 @@
-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/normalize-max-iterations.d.ts

@@ -1,13 +0,0 @@
-/**
- * Normalize Inspector / param `maxIterations`.
- * `0` = unlimited; invalid / negative → `fallback`; positive → floor + `maxCap`.
- */
-export declare const normalizeMaxIterations: (value: unknown, options: {
-    readonly fallback: number;
-    readonly maxCap: number;
-}) => number;
-/** Soft upper bound only — Inspector lets users raise freely. */
-export declare const AGENT_MAX_ITERATIONS_CAP: number;
-export declare const PATH_CHOICE_MAX_ITERATIONS_CAP: number;
-export declare const DEFAULT_AGENT_MAX_ITERATIONS = 100;
-export declare const DEFAULT_PATH_CHOICE_MAX_ITERATIONS = 5;

package/vendor/common-nodes/dist/ai/normalize-max-iterations.js

@@ -1,23 +0,0 @@
-/**
- * Normalize Inspector / param `maxIterations`.
- * `0` = unlimited; invalid / negative → `fallback`; positive → floor + `maxCap`.
- */
-export const normalizeMaxIterations = (value, options) => {
-    const n = typeof value === 'number' ? value : Number(value);
-    if (!Number.isFinite(n) || n < 0) {
-        return options.fallback;
-    }
-    if (n === 0) {
-        return 0;
-    }
-    const floored = Math.floor(n);
-    if (floored < 1) {
-        return options.fallback;
-    }
-    return Math.min(options.maxCap, floored);
-};
-/** Soft upper bound only — Inspector lets users raise freely. */
-export const AGENT_MAX_ITERATIONS_CAP = Number.MAX_SAFE_INTEGER;
-export const PATH_CHOICE_MAX_ITERATIONS_CAP = Number.MAX_SAFE_INTEGER;
-export const DEFAULT_AGENT_MAX_ITERATIONS = 100;
-export const DEFAULT_PATH_CHOICE_MAX_ITERATIONS = 5;

package/vendor/common-nodes/dist/ai/openai/context-length-error.d.ts

@@ -1,14 +0,0 @@
-/**
- * Typed context-window overflow from OpenAI-compatible chat.create.
- * Detected before the stream yields reasoning/draft chunks.
- */
-export declare class ContextLengthExceededError extends Error {
-    readonly code: "context_length_exceeded";
-    constructor(message?: string);
-}
-export declare const isContextLengthExceededError: (error: unknown) => error is ContextLengthExceededError;
-/**
- * Classify provider/SDK errors thrown while creating a chat completion stream.
- * Structured fields win; narrow message fallback covers LM Studio / vLLM.
- */
-export declare const classifyContextLengthError: (error: unknown) => ContextLengthExceededError | undefined;

package/vendor/common-nodes/dist/ai/openai/context-length-error.js

@@ -1,63 +0,0 @@
-/**
- * Typed context-window overflow from OpenAI-compatible chat.create.
- * Detected before the stream yields reasoning/draft chunks.
- */
-export class ContextLengthExceededError extends Error {
-    code = 'context_length_exceeded';
-    constructor(message = 'Context length exceeded') {
-        super(message);
-        this.name = 'ContextLengthExceededError';
-    }
-}
-export const isContextLengthExceededError = (error) => error instanceof ContextLengthExceededError;
-const CONTEXT_MESSAGE_RE = /context[_ ]length|maximum context|context window|too many tokens|n_ctx|max_model_len|prompt is too long|exceeds? (?:the )?(?:maximum|model) (?:context|token)/i;
-const readString = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
-const readNested = (record, key) => {
-    const nested = record[key];
-    return nested !== null && typeof nested === 'object'
-        ? nested
-        : undefined;
-};
-/**
- * Classify provider/SDK errors thrown while creating a chat completion stream.
- * Structured fields win; narrow message fallback covers LM Studio / vLLM.
- */
-export const classifyContextLengthError = (error) => {
-    if (error instanceof ContextLengthExceededError) {
-        return error;
-    }
-    if (error === null || typeof error !== 'object') {
-        return undefined;
-    }
-    const record = error;
-    const status = typeof record['status'] === 'number'
-        ? record['status']
-        : typeof record['statusCode'] === 'number'
-            ? record['statusCode']
-            : undefined;
-    const code = readString(record['code']) ??
-        readString(readNested(record, 'error')?.['code']);
-    const type = readString(record['type']) ??
-        readString(readNested(record, 'error')?.['type']);
-    const message = readString(record['message']) ??
-        readString(readNested(record, 'error')?.['message']) ??
-        (error instanceof Error ? error.message : undefined);
-    if (code === 'context_length_exceeded') {
-        return new ContextLengthExceededError(message ?? 'Context length exceeded');
-    }
-    if (type === 'invalid_request_error' &&
-        message !== undefined &&
-        CONTEXT_MESSAGE_RE.test(message)) {
-        return new ContextLengthExceededError(message);
-    }
-    if ((status === 400 || status === undefined) &&
-        message !== undefined &&
-        CONTEXT_MESSAGE_RE.test(message)) {
-        // Avoid false positives on rate-limit / auth wording.
-        if (/rate[_ ]?limit|unauthorized|authentication|invalid[_ ]api[_ ]key|timeout/i.test(message)) {
-            return undefined;
-        }
-        return new ContextLengthExceededError(message);
-    }
-    return undefined;
-};

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

@@ -1,19 +0,0 @@
-import type { ChatCompletionFinishReason, CreateChatCompletionStream } from '../chat-completion-stream.js';
-import { classifyContextLengthError, ContextLengthExceededError } from './context-length-error.js';
-export type { ChatCompletionAbortSignal, ChatCompletionFinishReason, ChatCompletionMessage, ChatCompletionStreamChunk, ChatCompletionToolCall, ChatCompletionToolDefinition, CreateChatCompletionStream, CreateChatCompletionStreamArgs, } from '../chat-completion-stream.js';
-export { ContextLengthExceededError, classifyContextLengthError };
-export { isContextLengthExceededError } from './context-length-error.js';
-export type OpenAiProviderCredentials = {
-    readonly apiKey?: string;
-    readonly baseURL?: string;
-};
-export declare const mapFinishReason: (value: string | null | undefined) => ChatCompletionFinishReason;
-/** LM Studio / DeepSeek-style CoT fields on OpenAI-compatible deltas. */
-export declare const reasoningTextFromDelta: (delta: unknown) => string;
-/**
- * Unbound OpenAI-compatible chat stream factory.
- * Caller supplies credential resolve (server injects secrets).
- */
-export declare const createChatCompletionStream: (deps: {
-    readonly resolveProvider: (providerId: string) => Promise<OpenAiProviderCredentials>;
-}) => CreateChatCompletionStream;