langflower 0.1.0 → 0.1.2

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,45 +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: `
-Combine several tool wires into one before an agent. Duplicate names: the last wire wins.
-
-Optional — you can still plug many tool packs straight into the agent.
-`.trim(),
-    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

package/vendor/common-nodes/package.json

@@ -1,48 +0,0 @@
-{
-	"name": "@langflower/common-nodes",
-	"version": "0.1.0",
-	"type": "module",
-	"main": "./dist/catalog.js",
-	"types": "./dist/catalog.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/catalog.d.ts",
-			"import": "./dist/catalog.js"
-		},
-		"./test": {
-			"types": "./dist/test-nodes/test-index.d.ts",
-			"import": "./dist/test-nodes/test-index.js"
-		},
-		"./ai/llm-role-preset": {
-			"types": "./dist/ai/features/llm-role-preset.d.ts",
-			"import": "./dist/ai/features/llm-role-preset.js"
-		},
-		"./ai/run-host-services": {
-			"types": "./dist/ai/features/run-host-services.d.ts",
-			"import": "./dist/ai/features/run-host-services.js"
-		},
-		"./ai/openai/create-chat-completion-stream": {
-			"types": "./dist/ai/features/openai/create-chat-completion-stream.d.ts",
-			"import": "./dist/ai/features/openai/create-chat-completion-stream.js"
-		},
-		"./ai/openai/list-provider-models": {
-			"types": "./dist/ai/features/openai/list-provider-models.d.ts",
-			"import": "./dist/ai/features/openai/list-provider-models.js"
-		},
-		"./embeddings/create-embedding": {
-			"types": "./dist/embeddings/create-embedding.d.ts",
-			"import": "./dist/embeddings/create-embedding.js"
-		}
-	},
-	"dependencies": {
-		"@langflower/node-sdk": "file:../node-sdk",
-		"@langflower/runtime": "file:../runtime",
-		"@langflower/tools": "file:../tools",
-		"@rx-evo/stateful-observable": "^0.6.0",
-		"openai": "^4.104.0",
-		"rxjs": "^7.8.1"
-	},
-	"files": [
-		"dist"
-	]
-}

package/vendor/compiler/dist/bundle-pack.d.ts

@@ -1,18 +0,0 @@
-import type { CompileDiagnostic } from './compile-types.js';
-export type BundleEntryResult = {
-    readonly ok: true;
-    readonly outfile: string;
-} | {
-    readonly ok: false;
-    readonly diagnostics: readonly CompileDiagnostic[];
-};
-/**
- * Bundle one entry to ESM under the project cache. Author deps are bundled;
- * host SDK / rxjs / node builtins stay external (host peers rewritten to
- * absolute `file://` URLs from the Langflower install tree).
- */
-export declare const bundleEntry: (options: {
-    readonly entryPath: string;
-    readonly packDir: string;
-    readonly outfile: string;
-}) => Promise<BundleEntryResult>;

package/vendor/compiler/dist/bundle-pack.js

@@ -1,98 +0,0 @@
-import * as esbuild from 'esbuild';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { isHostPeerSpecifier, resolveHostPackageEntry, } from './resolve-host-types.js';
-const mapEsbuildErrors = (errors, packDir) => errors.map((error) => {
-    const location = error.location;
-    const file = location === null
-        ? undefined
-        : path.isAbsolute(location.file)
-            ? location.file
-            : path.join(packDir, location.file);
-    return {
-        ...(file !== undefined ? { file } : {}),
-        ...(location !== null
-            ? { line: location.line, column: location.column }
-            : {}),
-        message: error.text,
-    };
-});
-/**
- * Bundle one entry to ESM under the project cache. Author deps are bundled;
- * host SDK / rxjs / node builtins stay external (host peers rewritten to
- * absolute `file://` URLs from the Langflower install tree).
- */
-export const bundleEntry = async (options) => {
-    await fs.mkdir(path.dirname(options.outfile), { recursive: true });
-    try {
-        await esbuild.build({
-            entryPoints: [options.entryPath],
-            outfile: options.outfile,
-            bundle: true,
-            format: 'esm',
-            platform: 'node',
-            target: 'node22',
-            absWorkingDir: options.packDir,
-            logLevel: 'silent',
-            packages: 'bundle',
-            plugins: [
-                {
-                    name: 'langflower-externals',
-                    setup(build) {
-                        build.onResolve({ filter: /.*/ }, (args) => {
-                            if (args.kind === 'entry-point') {
-                                return undefined;
-                            }
-                            if (args.path.startsWith('node:')) {
-                                return {
-                                    path: args.path,
-                                    external: true,
-                                };
-                            }
-                            if (!isHostPeerSpecifier(args.path)) {
-                                return undefined;
-                            }
-                            const resolved = resolveHostPackageEntry(args.path);
-                            if (resolved === undefined) {
-                                return {
-                                    errors: [
-                                        {
-                                            text: `Cannot resolve host peer '${args.path}' from the Langflower install. Peer-only packs need no npm install; this usually means a broken Langflower install.`,
-                                        },
-                                    ],
-                                };
-                            }
-                            return {
-                                path: pathToFileURL(resolved).href,
-                                external: true,
-                            };
-                        });
-                    },
-                },
-            ],
-        });
-        return { ok: true, outfile: options.outfile };
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'errors' in error &&
-            Array.isArray(error.errors)) {
-            return {
-                ok: false,
-                diagnostics: mapEsbuildErrors(error.errors, options.packDir),
-            };
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            diagnostics: [
-                {
-                    file: options.entryPath,
-                    message,
-                },
-            ],
-        };
-    }
-};

package/vendor/compiler/dist/cache-key.d.ts

@@ -1,5 +0,0 @@
-/**
- * Cache key inputs: entry sources + pack `package.json` + lockfile when present
- * + host peer runtime stamp (so empty-project peer rewrite upgrades invalidate).
- */
-export declare const computePackCacheKey: (packDir: string, entries: readonly string[]) => Promise<string>;

package/vendor/compiler/dist/cache-key.js

@@ -1,35 +0,0 @@
-import { createHash } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { hostRuntimeEntryStamp } from './resolve-host-types.js';
-/** Bump when host-peer rewrite policy changes (busts bare-import caches). */
-const HOST_PEER_RUNTIME_POLICY = 'host-peer-runtime:file-url-v1';
-const hashText = (text) => createHash('sha256').update(text).digest('hex');
-const readOptionalFile = async (filePath) => {
-    try {
-        return await fs.readFile(filePath, 'utf8');
-    }
-    catch {
-        return '';
-    }
-};
-/**
- * Cache key inputs: entry sources + pack `package.json` + lockfile when present
- * + host peer runtime stamp (so empty-project peer rewrite upgrades invalidate).
- */
-export const computePackCacheKey = async (packDir, entries) => {
-    const parts = [];
-    for (const entry of [...entries].sort()) {
-        const relative = path
-            .relative(packDir, entry)
-            .split(path.sep)
-            .join('/');
-        const source = await fs.readFile(entry, 'utf8');
-        parts.push(`${relative}\n${source}`);
-    }
-    parts.push(`package.json\n${await readOptionalFile(path.join(packDir, 'package.json'))}`);
-    parts.push(`package-lock.json\n${await readOptionalFile(path.join(packDir, 'package-lock.json'))}`);
-    parts.push(`npm-shrinkwrap.json\n${await readOptionalFile(path.join(packDir, 'npm-shrinkwrap.json'))}`);
-    parts.push(`${HOST_PEER_RUNTIME_POLICY}\n${hostRuntimeEntryStamp()}`);
-    return hashText(parts.join('\n---\n'));
-};