langflower 0.0.10 → 0.1.1

package/vendor/common-nodes/dist/tools/inventory-tool-round.js

@@ -1,91 +0,0 @@
-import { isBuiltinToolId, } from '@langflower/tools/create-project-harness';
-import { formatPermissionDeniedText } from '@langflower/tools/permission';
-const TOOL_LOG_PREVIEW = 400;
-export const previewToolLogText = (text) => {
-    const trimmed = text.trim();
-    if (trimmed.length <= TOOL_LOG_PREVIEW) {
-        return trimmed;
-    }
-    return `${trimmed.slice(0, TOOL_LOG_PREVIEW - 1)}…`;
-};
-export const toChatToolDefinitions = (tools) => tools.map((tool) => ({
-    type: 'function',
-    function: {
-        name: tool.toolId.length > 0 ? tool.toolId : tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema,
-    },
-}));
-export const parseToolArgs = (raw) => {
-    if (raw.trim().length === 0) {
-        return {};
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed !== null &&
-            typeof parsed === 'object' &&
-            !Array.isArray(parsed)) {
-            return parsed;
-        }
-        return { value: parsed };
-    }
-    catch {
-        return { __raw: raw };
-    }
-};
-const findToolHandle = (tools, toolId) => tools.find((tool) => tool.toolId === toolId ||
-    (tool.toolId.length === 0 && tool.name === toolId));
-/**
- * Invoke an inventory ToolHandle.
- * Builtins: OpenCode-style permission via harness authorize (also gated inside
- * harness.invoke for EC wraps). Wired domain/custom/MCP handles: authoring the
- * edge is consent — no permission.ask.
- */
-export const invokeInventoryTool = async (harness, tools, call, toolCtx, options) => {
-    const handle = findToolHandle(tools, call.name);
-    if (handle === undefined) {
-        const notInAllowlistText = options?.notInAllowlistText ??
-            ((toolName) => `Tool «${toolName}» is not in the enabled allowlist.`);
-        return {
-            ok: false,
-            text: notInAllowlistText(call.name),
-        };
-    }
-    if (toolCtx === undefined) {
-        return {
-            ok: false,
-            text: 'No tool handler context available to invoke tools.',
-        };
-    }
-    const args = parseToolArgs(call.arguments);
-    const toolId = handle.toolId.length > 0 ? handle.toolId : handle.name;
-    const ctx = options?.signal === undefined
-        ? toolCtx
-        : { ...toolCtx, signal: options.signal };
-    if (isBuiltinToolId(toolId)) {
-        const authorize = ctx.authorize ?? harness?.authorize;
-        if (authorize === undefined) {
-            return {
-                ok: false,
-                text: `Permission gate unavailable for tool «${toolId}».`,
-            };
-        }
-        const access = await authorize({ toolId, args });
-        if (access === 'deny') {
-            return {
-                ok: false,
-                text: formatPermissionDeniedText(toolId, ''),
-            };
-        }
-    }
-    try {
-        const text = await handle.invoke(args, ctx);
-        return { ok: true, text };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            text: error instanceof Error ? error.message : String(error),
-        };
-    }
-};

package/vendor/common-nodes/dist/tools/merge-tool-inventory.d.ts

@@ -1,10 +0,0 @@
-import type { BuiltinToolRegistration } from '@langflower/node-definitions';
-import { type ToolRegistration } from './tool-registration.js';
-/**
- * Merge harness builtins with wired registrations, then apply `enabledToolIds`.
- * Builtins win on `toolId` collision (they are invokable via `ctx.harness`).
- * Wired values may be single regs or arrays (domain packs) — flattened first.
- * `enabledToolIds === undefined` → all; `[]` → none.
- */
-export declare const mergeToolInventory: (builtins: readonly BuiltinToolRegistration[], wired: readonly unknown[], enabledToolIds: readonly string[] | undefined) => readonly ToolRegistration[];
-//# sourceMappingURL=merge-tool-inventory.d.ts.map

package/vendor/common-nodes/dist/tools/merge-tool-inventory.js

@@ -1,26 +0,0 @@
-import { filterEnabledRegistrations } from './filter-enabled-registrations.js';
-import { flattenToolRegistrations, toolRegistrationId, } from './tool-registration.js';
-/**
- * Merge harness builtins with wired registrations, then apply `enabledToolIds`.
- * Builtins win on `toolId` collision (they are invokable via `ctx.harness`).
- * Wired values may be single regs or arrays (domain packs) — flattened first.
- * `enabledToolIds === undefined` → all; `[]` → none.
- */
-export const mergeToolInventory = (builtins, wired, enabledToolIds) => {
-    const flatWired = flattenToolRegistrations(wired);
-    const byId = new Map();
-    for (const registration of flatWired) {
-        byId.set(registration.toolId, registration);
-    }
-    for (const builtin of builtins) {
-        byId.set(builtin.toolId, {
-            kind: 'harness',
-            toolId: builtin.toolId,
-            name: builtin.name,
-            description: builtin.description,
-            inputSchema: builtin.inputSchema,
-        });
-    }
-    return filterEnabledRegistrations([...byId.values()], enabledToolIds, toolRegistrationId);
-};
-//# sourceMappingURL=merge-tool-inventory.js.map

package/vendor/common-nodes/dist/tools/run-internal-tool-loop.d.ts

@@ -1,55 +0,0 @@
-import type { ToolHandle } from '@langflower/node-sdk';
-import { type SteerControlPayload } from '@langflower/node-sdk/llm';
-import type { Harness } from '@langflower/tools/create-project-harness';
-import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
-import type { ChatCompletionMessage, CreateChatCompletionStream } from '../ai/chat-completion-stream.js';
-import { type Observable as RxObservable } from 'rxjs';
-import type { SubAgentRegistration, SubAgentSpawnPayload } from '../ai/sub-agent-protocol.js';
-import type { LlmCompactionConfig } from '../ai/openai/normalize-compaction-params.js';
-export type ToolLoopChunk = {
-    readonly kind: 'reasoning';
-    readonly text: string;
-} | {
-    readonly kind: 'draftResponse';
-    readonly text: string;
-} | {
-    readonly kind: 'toolLog';
-    readonly text: string;
-} | {
-    readonly kind: 'response';
-    readonly text: string;
-} | {
-    readonly kind: 'historySync';
-    readonly messages: readonly ChatCompletionMessage[];
-} | {
-    readonly kind: 'subagentSpawn';
-    readonly payload: SubAgentSpawnPayload;
-};
-/**
- * Internal tool-call loop: complete → invoke ToolHandle.invoke → append
- * results → re-complete. Optional `spawn_subagent` orchestrator control tool
- * (Review-style) emits a graph spawn and waits for a correlated result.
- */
-export declare const runInternalToolLoop: (args: {
-    readonly factory: CreateChatCompletionStream;
-    readonly providerId: string;
-    readonly model: string;
-    readonly messages: readonly ChatCompletionMessage[];
-    readonly tools: readonly ToolHandle[];
-    readonly harness?: Harness;
-    readonly toolCtx?: ToolHandlerContext;
-    readonly maxIterations: number;
-    readonly subagentRegistrations?: readonly SubAgentRegistration[];
-    readonly compaction?: LlmCompactionConfig;
-    /**
-     * Agent-node router: resolve when `subagentResult` arrives for `callId`.
-     * Teardown via Observable unsubscribe aborts the wait (AbortSignal).
-     */
-    readonly waitForSubagentResult?: (callId: string, signal: AbortSignal) => Promise<string>;
-    /**
-     * ADR-032 soft Pause / Steer — inventory `steerControl` value stream.
-     * Optional: loops without it behave as before (hard cancel only).
-     */
-    readonly steerControl$?: RxObservable<SteerControlPayload>;
-}) => RxObservable<ToolLoopChunk>;
-//# sourceMappingURL=run-internal-tool-loop.d.ts.map

package/vendor/common-nodes/dist/tools/run-internal-tool-loop.js

@@ -1,360 +0,0 @@
-import { isSteerControlContinue, isSteerControlPause, } from '@langflower/node-sdk/llm';
-import { Observable, filter, take, } from 'rxjs';
-import { buildSpawnSubagentChatTool, invokeInventoryTool, previewToolLogText, runSpawnSubagentRound, SPAWN_SUBAGENT_TOOL, toChatToolDefinitions, } from './inventory-tool-round.js';
-import { prepareChatCompletion } from '../ai/openai/prepare-chat-completion.js';
-import { DISABLED_COMPACTION_CONFIG } from '../ai/openai/normalize-compaction-params.js';
-const isAbortError = (error) => {
-    if (error === undefined || error === null || typeof error !== 'object') {
-        return false;
-    }
-    const name = error.name;
-    return name === 'AbortError';
-};
-const waitForSteerContinue = async (steerControl$, hardSignal) => {
-    if (hardSignal.aborted) {
-        return null;
-    }
-    return await new Promise((resolve) => {
-        const onHardAbort = () => {
-            sub.unsubscribe();
-            resolve(null);
-        };
-        hardSignal.addEventListener('abort', onHardAbort, { once: true });
-        const sub = steerControl$
-            .pipe(filter(isSteerControlContinue), take(1))
-            .subscribe({
-            next: (value) => {
-                hardSignal.removeEventListener('abort', onHardAbort);
-                resolve(value);
-            },
-            error: () => {
-                hardSignal.removeEventListener('abort', onHardAbort);
-                resolve(null);
-            },
-            complete: () => {
-                hardSignal.removeEventListener('abort', onHardAbort);
-                resolve(null);
-            },
-        });
-    });
-};
-/** Append steered user text when present; returns whether the loop should retry. */
-const applySteerContinue = async (steerControl$, hardSignal, messages) => {
-    const cont = await waitForSteerContinue(steerControl$, hardSignal);
-    if (cont === null || hardSignal.aborted) {
-        return { ok: false };
-    }
-    if (cont.kind === 'steer' && cont.text.trim().length > 0) {
-        return {
-            ok: true,
-            messages: [
-                ...messages,
-                { role: 'user', content: cont.text.trim() },
-            ],
-        };
-    }
-    return { ok: true, messages };
-};
-/** Clear soft-pause flag, await Steer/Resume, then retry the tool-loop iteration. */
-const afterSoftPause = async (args) => {
-    args.clearSoftPause();
-    const steered = await applySteerContinue(args.steerControl$, args.hardSignal, args.messages);
-    if (!steered.ok) {
-        return { kind: 'abort' };
-    }
-    return { kind: 'retry', messages: steered.messages };
-};
-/**
- * Internal tool-call loop: complete → invoke ToolHandle.invoke → append
- * results → re-complete. Optional `spawn_subagent` orchestrator control tool
- * (Review-style) emits a graph spawn and waits for a correlated result.
- */
-export const runInternalToolLoop = (args) => new Observable((subscriber) => {
-    const hardAbort = new AbortController();
-    let streamAbort = new AbortController();
-    let softPauseRequested = false;
-    const clearSoftPause = () => {
-        softPauseRequested = false;
-    };
-    const subagentRegistrations = args.subagentRegistrations ?? [];
-    const chatTools = [
-        ...toChatToolDefinitions(args.tools),
-        ...(subagentRegistrations.length > 0
-            ? [buildSpawnSubagentChatTool(subagentRegistrations)]
-            : []),
-    ];
-    const compaction = args.compaction ?? DISABLED_COMPACTION_CONFIG;
-    const resetStreamAbort = () => {
-        streamAbort = new AbortController();
-        if (hardAbort.signal.aborted) {
-            streamAbort.abort();
-        }
-    };
-    hardAbort.signal.addEventListener('abort', () => {
-        streamAbort.abort();
-    });
-    const steerSub = args.steerControl$ === undefined
-        ? undefined
-        : args.steerControl$.subscribe((value) => {
-            if (isSteerControlPause(value) &&
-                !hardAbort.signal.aborted) {
-                softPauseRequested = true;
-                streamAbort.abort();
-            }
-        });
-    void (async () => {
-        let messages = [...args.messages];
-        let openSpawnCallId;
-        try {
-            for (let iteration = 0; iteration < args.maxIterations; iteration += 1) {
-                if (hardAbort.signal.aborted) {
-                    return;
-                }
-                resetStreamAbort();
-                const prepared = await prepareChatCompletion({
-                    factory: args.factory,
-                    providerId: args.providerId,
-                    model: args.model,
-                    messages,
-                    tools: chatTools,
-                    signal: streamAbort.signal,
-                    compaction,
-                });
-                if (!prepared.ok) {
-                    const prepareError = prepared.error;
-                    if (softPauseRequested &&
-                        !hardAbort.signal.aborted &&
-                        args.steerControl$ !== undefined) {
-                        const paused = await afterSoftPause({
-                            steerControl$: args.steerControl$,
-                            hardSignal: hardAbort.signal,
-                            messages,
-                            clearSoftPause,
-                        });
-                        if (paused.kind === 'abort') {
-                            return;
-                        }
-                        messages = [...paused.messages];
-                        iteration -= 1;
-                        continue;
-                    }
-                    if (isAbortError(prepareError) &&
-                        streamAbort.signal.aborted &&
-                        !hardAbort.signal.aborted) {
-                        return;
-                    }
-                    if (!hardAbort.signal.aborted) {
-                        subscriber.error(prepareError);
-                    }
-                    return;
-                }
-                messages = [...prepared.messages];
-                if (prepared.compaction !== undefined) {
-                    subscriber.next({
-                        kind: 'toolLog',
-                        text: `Compacted history (${prepared.compaction.reason}): ~${prepared.compaction.beforeTokens} → ~${prepared.compaction.afterTokens} approx tokens`,
-                    });
-                    subscriber.next({
-                        kind: 'historySync',
-                        messages: [...messages],
-                    });
-                }
-                const stream = prepared.stream;
-                let fullText = '';
-                let toolCalls;
-                let streamSoftPaused = false;
-                try {
-                    for await (const chunk of stream) {
-                        if (streamAbort.signal.aborted) {
-                            if (hardAbort.signal.aborted) {
-                                return;
-                            }
-                            if (softPauseRequested) {
-                                streamSoftPaused = true;
-                                break;
-                            }
-                            return;
-                        }
-                        if (chunk.kind === 'reasoning') {
-                            subscriber.next({
-                                kind: 'reasoning',
-                                text: chunk.text,
-                            });
-                        }
-                        else if (chunk.kind === 'draft') {
-                            fullText += chunk.text;
-                            subscriber.next({
-                                kind: 'draftResponse',
-                                text: chunk.text,
-                            });
-                        }
-                        else if (chunk.kind === 'done') {
-                            fullText =
-                                chunk.text.length > 0
-                                    ? chunk.text
-                                    : fullText;
-                            toolCalls = chunk.tool_calls;
-                        }
-                    }
-                }
-                catch (streamError) {
-                    // Provider streams throw when `signal` aborts (OpenAI SDK).
-                    // That must become soft Pause await, not Observable error —
-                    // otherwise Steer has nowhere to land.
-                    if (!hardAbort.signal.aborted &&
-                        args.steerControl$ !== undefined &&
-                        (softPauseRequested ||
-                            streamAbort.signal.aborted)) {
-                        streamSoftPaused = true;
-                    }
-                    else if (isAbortError(streamError) &&
-                        streamAbort.signal.aborted &&
-                        !hardAbort.signal.aborted) {
-                        return;
-                    }
-                    else if (!hardAbort.signal.aborted) {
-                        subscriber.error(streamError);
-                        return;
-                    }
-                    else {
-                        return;
-                    }
-                }
-                if (streamSoftPaused || softPauseRequested) {
-                    if (fullText.trim().length > 0 &&
-                        args.steerControl$ !== undefined) {
-                        messages = [
-                            ...messages,
-                            {
-                                role: 'assistant',
-                                content: fullText,
-                            },
-                        ];
-                    }
-                    if (args.steerControl$ === undefined ||
-                        hardAbort.signal.aborted) {
-                        clearSoftPause();
-                        return;
-                    }
-                    const paused = await afterSoftPause({
-                        steerControl$: args.steerControl$,
-                        hardSignal: hardAbort.signal,
-                        messages,
-                        clearSoftPause,
-                    });
-                    if (paused.kind === 'abort') {
-                        return;
-                    }
-                    messages = [...paused.messages];
-                    iteration -= 1;
-                    continue;
-                }
-                if (toolCalls !== undefined && toolCalls.length > 0) {
-                    messages = [
-                        ...messages,
-                        {
-                            role: 'assistant',
-                            content: fullText,
-                            tool_calls: toolCalls,
-                        },
-                    ];
-                    for (const call of toolCalls) {
-                        subscriber.next({
-                            kind: 'toolLog',
-                            text: `→ ${call.name}(${previewToolLogText(call.arguments)})`,
-                        });
-                        let resultText;
-                        if (call.name === SPAWN_SUBAGENT_TOOL) {
-                            const spawn = await runSpawnSubagentRound({
-                                call,
-                                registrations: subagentRegistrations,
-                                openSpawnCallId,
-                                ...(args.waitForSubagentResult !==
-                                    undefined
-                                    ? {
-                                        waitForSubagentResult: args.waitForSubagentResult,
-                                    }
-                                    : {}),
-                                signal: streamAbort.signal,
-                                onSpawn: (payload) => {
-                                    openSpawnCallId = payload.callId;
-                                    subscriber.next({
-                                        kind: 'subagentSpawn',
-                                        payload,
-                                    });
-                                },
-                                onWaiting: (callId) => {
-                                    subscriber.next({
-                                        kind: 'toolLog',
-                                        text: `… waiting for subagentResult callId=${callId}`,
-                                    });
-                                },
-                            });
-                            if (spawn.aborted) {
-                                if (softPauseRequested &&
-                                    !hardAbort.signal.aborted &&
-                                    args.steerControl$ !== undefined) {
-                                    const paused = await afterSoftPause({
-                                        steerControl$: args.steerControl$,
-                                        hardSignal: hardAbort.signal,
-                                        messages,
-                                        clearSoftPause,
-                                    });
-                                    if (paused.kind === 'abort') {
-                                        return;
-                                    }
-                                    messages = [...paused.messages];
-                                    iteration -= 1;
-                                    break;
-                                }
-                                return;
-                            }
-                            openSpawnCallId = undefined;
-                            resultText = spawn.resultText;
-                        }
-                        else {
-                            const result = await invokeInventoryTool(args.harness, args.tools, call, args.toolCtx);
-                            resultText = result.ok
-                                ? result.text
-                                : `Error: ${result.text}`;
-                        }
-                        subscriber.next({
-                            kind: 'toolLog',
-                            text: `← ${call.name}: ${previewToolLogText(resultText)}`,
-                        });
-                        messages = [
-                            ...messages,
-                            {
-                                role: 'tool',
-                                content: resultText,
-                                tool_call_id: call.id,
-                            },
-                        ];
-                    }
-                    continue;
-                }
-                subscriber.next({ kind: 'response', text: fullText });
-                subscriber.complete();
-                return;
-            }
-            const stopMessage = `Stopped after ${args.maxIterations} tool-loop iterations (maxIterations).`;
-            subscriber.next({ kind: 'toolLog', text: stopMessage });
-            subscriber.next({ kind: 'response', text: stopMessage });
-            subscriber.complete();
-        }
-        catch (error) {
-            if (hardAbort.signal.aborted) {
-                return;
-            }
-            subscriber.error(error);
-        }
-        finally {
-            steerSub?.unsubscribe();
-        }
-    })();
-    return () => {
-        hardAbort.abort();
-        steerSub?.unsubscribe();
-    };
-});
-//# sourceMappingURL=run-internal-tool-loop.js.map

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

@@ -1,20 +0,0 @@
-/**
- * Optional hub: combine many `tools` wires into one `ToolHandle[]`.
- * Duplicate `toolId` last-wins (later slot). Empty / unwired → `[]`.
- */
-export declare const toolCollectionNode: {
-    readonly emitOncePerActivation: boolean;
-    readonly stopsRun: boolean;
-    readonly chatEntry: boolean;
-    readonly uiSchema: readonly [];
-    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
-    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
-    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
-    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [], Record<string, never>>;
-    readonly paletteSecondary?: true;
-    readonly description?: string;
-    readonly type: string;
-    readonly displayName: string;
-    readonly category: string | undefined;
-    readonly icon: string | undefined;
-};

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

@@ -1,42 +0,0 @@
-import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
-import { map } from 'rxjs';
-import { flattenToolHandles } from '../collect-agent-tool-handles.js';
-const mergeToolHandlesLastWins = (wired) => {
-    const flattened = Array.isArray(wired)
-        ? flattenToolHandles(wired)
-        : flattenToolHandles(wired === undefined || wired === null ? [] : [wired]);
-    const byId = new Map();
-    for (const handle of flattened) {
-        byId.set(handle.toolId, handle);
-    }
-    return [...byId.values()];
-};
-/**
- * Optional hub: combine many `tools` wires into one `ToolHandle[]`.
- * Duplicate `toolId` last-wins (later slot). Empty / unwired → `[]`.
- */
-export const toolCollectionNode = defineReactiveNode({
-    type: 'common-tool-collection',
-    displayName: 'Tool collection',
-    category: 'Tools',
-    description: 'Merges many `tools` wires into one `ToolHandle[]`. ' +
-        'Duplicate toolId last-wins. Optional — agents still accept multi combine.',
-    uiSchema: [],
-    bind(_ctx, { makeInput, configureOutput }) {
-        const tools = makeInput('tools', {
-            name: 'tools',
-            wireType: TOOL_HANDLE_WIRE_TYPE,
-            multi: 'combine',
-            defaultValue: [],
-        });
-        const merged$ = tools.pipeValue(map((wired) => mergeToolHandlesLastWins(wired)));
-        return {
-            inputs: [tools],
-            outputs: [
-                configureOutput('tools', merged$, {
-                    wireType: TOOL_HANDLE_WIRE_TYPE,
-                }),
-            ],
-        };
-    },
-});

package/vendor/common-nodes/dist/tools/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/tools/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