langflower 0.0.6 → 0.0.8

package/vendor/common-nodes/dist/ai/llm-loop/run-llm-loop.js

@@ -407,19 +407,42 @@ const invokeTool = (state, call, options, cancelSignal) => {
             ? `Error: Sub-Agent ${payload.callId} timed out after ${options.recovery.subagentTimeoutMs}ms.`
             : `Error: ${classifyLlmFailure(error).message}`)), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
     }
-    const invocation$ = defer(() => invokeInventoryTool(options.harness, options.inventoryTools, call, options.toolCtx, options.policy.toolNotAllowedText === undefined
-        ? undefined
-        : {
-            notInAllowlistText: options.policy.toolNotAllowedText,
-        }));
+    const toolAbort = new AbortController();
+    const abortTool = () => {
+        toolAbort.abort();
+    };
+    cancelSignal.addEventListener('abort', abortTool);
+    const invokeOptions = {
+        ...(options.policy.toolNotAllowedText === undefined
+            ? {}
+            : {
+                notInAllowlistText: options.policy.toolNotAllowedText,
+            }),
+        signal: toolAbort.signal,
+    };
+    const invocation$ = defer(() => invokeInventoryTool(options.harness, options.inventoryTools, call, options.toolCtx, invokeOptions).catch((error) => {
+        // Avoid unhandled rejection when timeout/cancel aborts in-flight work.
+        if (toolAbort.signal.aborted) {
+            return {
+                ok: false,
+                text: 'Tool aborted.',
+            };
+        }
+        throw error;
+    })).pipe(finalize(() => {
+        cancelSignal.removeEventListener('abort', abortTool);
+    }));
     const boundedInvocation$ = options.recovery.toolTimeoutMs > 0
         ? invocation$.pipe(timeout({
             first: options.recovery.toolTimeoutMs,
         }))
         : invocation$;
-    return concat(of(callLog), boundedInvocation$.pipe(map((result) => result.ok ? result.text : `Error: ${result.text}`), catchError((error) => of(error instanceof TimeoutError
-        ? `Error: Tool ${call.name} timed out after ${options.recovery.toolTimeoutMs}ms.`
-        : `Error: ${classifyLlmFailure(error).message}`)), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
+    return concat(of(callLog), boundedInvocation$.pipe(map((result) => result.ok ? result.text : `Error: ${result.text}`), catchError((error) => {
+        abortTool();
+        return of(error instanceof TimeoutError
+            ? `Error: Tool ${call.name} timed out after ${options.recovery.toolTimeoutMs}ms.`
+            : `Error: ${classifyLlmFailure(error).message}`);
+    }), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
 };
 const toolResultPackets = (state, call, result, options, prefix) => {
     const normalized = normalizeToolResult(result, options.recovery.maxToolResultChars);

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

@@ -15,6 +15,7 @@ export declare const parseToolArgs: (raw: string) => Readonly<Record<string, unk
  */
 export declare const invokeInventoryTool: (harness: Harness | undefined, tools: readonly ToolHandle[], call: ChatCompletionToolCall, toolCtx: ToolHandlerContext | undefined, options?: {
     readonly notInAllowlistText?: (toolName: string) => string;
+    readonly signal?: AbortSignal;
 }) => Promise<{
     readonly ok: boolean;
     readonly text: string;

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

@@ -60,8 +60,11 @@ export const invokeInventoryTool = async (harness, tools, call, toolCtx, options
     }
     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 = toolCtx.authorize ?? harness?.authorize;
+        const authorize = ctx.authorize ?? harness?.authorize;
         if (authorize === undefined) {
             return {
                 ok: false,
@@ -77,7 +80,7 @@ export const invokeInventoryTool = async (harness, tools, call, toolCtx, options
         }
     }
     try {
-        const text = await handle.invoke(args, toolCtx);
+        const text = await handle.invoke(args, ctx);
         return { ok: true, text };
     }
     catch (error) {

package/vendor/server/dist/bridge/settings-draft-controller.js

@@ -8,6 +8,30 @@ import { applyDraftPatch, buildDraftSnapshot, providerIndexesWithBaseUrl, seedSc
 import { bridgeEmit, clientEmit } from './bridge-outbound.js';
 import { buildLangflowerConfigSnapshot } from './build-langflower-config-snapshot.js';
 const isScope = (value) => value === 'project' || value === 'global';
+/** Fill missing/empty Save keys from the session draft (write-only apiKey). */
+const mergeProviderApiKeysFromSession = (payload, sessionDraft) => {
+    if (payload.provider === undefined || sessionDraft === undefined) {
+        return payload.providerApiKeys;
+    }
+    const merged = {
+        ...(payload.providerApiKeys ?? {}),
+    };
+    for (const row of sessionDraft.providers) {
+        const id = row.id.trim();
+        if (id.length === 0) {
+            continue;
+        }
+        const fromPayload = merged[id]?.trim() ?? '';
+        if (fromPayload.length > 0) {
+            continue;
+        }
+        const pending = row.apiKey.trim();
+        if (pending.length > 0) {
+            merged[id] = pending;
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : payload.providerApiKeys;
+};
 const layerForScope = (layers, scope) => (scope === 'project' ? layers.project : layers.global);
 export const createSettingsDraftController = (bridge, context, session) => {
     const probeGeneration = new Map();
@@ -144,15 +168,14 @@ export const createSettingsDraftController = (bridge, context, session) => {
         if (payload === undefined || !isScope(payload.scope)) {
             return null;
         }
+        const providerApiKeys = mergeProviderApiKeysFromSession(payload, state?.draft);
         const layers = await context.langflowerConfigService.writeSettings({
             scope: payload.scope,
             ...(payload.model !== undefined ? { model: payload.model } : {}),
             ...(payload.provider !== undefined
                 ? { provider: payload.provider }
                 : {}),
-            ...(payload.providerApiKeys !== undefined
-                ? { providerApiKeys: payload.providerApiKeys }
-                : {}),
+            ...(providerApiKeys !== undefined ? { providerApiKeys } : {}),
             ...('serverLogs' in payload
                 ? { serverLogs: payload.serverLogs }
                 : {}),

package/vendor/server/dist/bridge/wrap-builtin-tool-handles.js

@@ -23,10 +23,15 @@ export const wrapBuiltinToolHandles = (harness, enabledToolIds, permission) => {
         name: reg.name,
         description: reg.description,
         inputSchema: reg.inputSchema,
-        invoke: async (args) => {
+        invoke: async (args, toolCtx) => {
+            // Shell passes tools host bag (optional signal); SDK type stays identity-only.
+            const hostCtx = toolCtx;
             const result = await harness.invoke({
                 toolId: reg.toolId,
                 args,
+                ...(hostCtx?.signal !== undefined
+                    ? { signal: hostCtx.signal }
+                    : {}),
             });
             if (!result.ok) {
                 throw new Error(result.text);

package/vendor/server/skeleton/schemas/langflower-config.schema.json

@@ -55,7 +55,17 @@
 					},
 					"options": {
 						"type": "object",
-						"additionalProperties": true
+						"additionalProperties": true,
+						"properties": {
+							"baseURL": {
+								"type": "string",
+								"description": "OpenAI-compatible API base URL (e.g. https://api.openai.com/v1 or http://127.0.0.1:1234/v1)."
+							},
+							"apiKey": {
+								"type": "string",
+								"description": "API key or `{env:VAR_NAME}` placeholder. Resolved on the server only; omitted from WebSocket snapshots. Prefer `{env:…}` over literals on disk."
+							}
+						}
 					}
 				}
 			}

package/vendor/tools/dist/builtins/catalog.d.ts

@@ -75,13 +75,13 @@ export declare const BUILTIN_TOOLS: readonly [{
     readonly registration: {
         readonly toolId: "grep";
         readonly name: "grep";
-        readonly description: "Regex search across project files (gitignore-aware by default; Node walk — not ripgrep). Optional postProcess.";
+        readonly description: "Regex search across project files (gitignore-aware by default; ripgrep when available, else grep, else bounded Node walk). Optional postProcess.";
         readonly inputSchema: {
             readonly type: "object";
             readonly properties: {
                 readonly pattern: {
                     readonly type: "string";
-                    readonly description: "JavaScript RegExp source";
+                    readonly description: "Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)";
                 };
                 readonly path: {
                     readonly type: "string";

package/vendor/tools/dist/builtins/command-exists.d.ts

@@ -0,0 +1,5 @@
+/**
+ * True when `cmd` resolves on PATH (`where` on Windows, `which` elsewhere).
+ * Result is cached per process.
+ */
+export declare const commandExists: (cmd: string) => Promise<boolean>;

package/vendor/tools/dist/builtins/command-exists.js

@@ -0,0 +1,27 @@
+import { spawn } from 'node:child_process';
+const cache = new Map();
+/**
+ * True when `cmd` resolves on PATH (`where` on Windows, `which` elsewhere).
+ * Result is cached per process.
+ */
+export const commandExists = async (cmd) => {
+    const cached = cache.get(cmd);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const checkCmd = process.platform === 'win32' ? 'where' : 'which';
+    const exists = await new Promise((resolve) => {
+        const child = spawn(checkCmd, [cmd], {
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.on('error', () => {
+            resolve(false);
+        });
+        child.on('close', (code) => {
+            resolve(code === 0);
+        });
+    });
+    cache.set(cmd, exists);
+    return exists;
+};

package/vendor/tools/dist/builtins/grep/search.d.ts

@@ -0,0 +1,43 @@
+import { type SpawnCaptureOptions, type SpawnCaptureResult } from '../spawn-capture.js';
+export declare const MAX_GREP_MATCHES = 100;
+type GrepHit = {
+    readonly file: string;
+    readonly line: number;
+    readonly text: string;
+};
+export type GrepSearchInput = {
+    readonly pattern: string;
+    readonly caseInsensitive: boolean;
+    readonly respectGitignore: boolean;
+    /** Absolute search file or directory (already fenced). */
+    readonly searchAbsolute: string;
+    /** Fence root for relative display paths. */
+    readonly fenceRoot: string;
+    readonly displayPath: (absolute: string) => string;
+    readonly signal?: AbortSignal;
+};
+export type GrepSearchDeps = {
+    readonly commandExists?: (cmd: string) => Promise<boolean>;
+    readonly spawnCapture?: (command: string, args: readonly string[], options?: SpawnCaptureOptions) => Promise<SpawnCaptureResult>;
+};
+type GrepSearchOutcome = {
+    readonly ok: true;
+    readonly hits: readonly GrepHit[];
+    readonly truncated: boolean;
+    readonly backend: 'rg' | 'grep' | 'node';
+} | {
+    readonly ok: false;
+    readonly reason: 'unavailable' | 'error';
+    readonly message: string;
+};
+export declare const searchWithNodeWalk: (input: GrepSearchInput) => Promise<GrepSearchOutcome>;
+/**
+ * ts-scan-style cascade: rg → grep → bounded Node walk.
+ * Soft-falls through when a CLI binary is missing or fails to spawn;
+ * Node tier surfaces invalid JS RegExp errors.
+ */
+export declare const runGrepCascade: (input: GrepSearchInput, deps?: GrepSearchDeps) => Promise<{
+    readonly body: string;
+    readonly backend: "rg" | "grep" | "node";
+}>;
+export {};

package/vendor/tools/dist/builtins/grep/search.js

@@ -0,0 +1,315 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { commandExists } from '../command-exists.js';
+import { spawnCapture, } from '../spawn-capture.js';
+import { WALK_EXCLUDE_DIR_NAMES, walkFiles } from '../walk-files.js';
+export const MAX_GREP_MATCHES = 100;
+const MAX_GREP_FILES_SCANNED = 5_000;
+const MAX_GREP_FILE_BYTES = 1_048_576;
+const MAX_GREP_LINE_CHARS = 8_000;
+const SEARCH_EXCLUDE_GLOBS = [
+    '!**/node_modules/**',
+    '!**/dist/**',
+    '!**/build/**',
+    '!**/.git/**',
+];
+const throwIfAborted = (signal) => {
+    if (signal?.aborted) {
+        throw new Error('aborted');
+    }
+};
+const formatHits = (hits, truncated) => {
+    if (hits.length === 0) {
+        return '(no matches)';
+    }
+    const body = hits
+        .map((hit) => `${hit.file}:${hit.line}:${hit.text}`)
+        .join('\n');
+    return truncated
+        ? `${body}\n…[truncated at ${MAX_GREP_MATCHES}; refine pattern or path]`
+        : body;
+};
+const formatGrepBody = (hits, truncated) => formatHits(hits, truncated);
+const parseLineHits = (stdout, displayPath, fenceRoot, maxHits) => {
+    const hits = [];
+    const lines = stdout.split(/\r?\n/);
+    for (const raw of lines) {
+        if (raw.length === 0) {
+            continue;
+        }
+        const match = /^(.+?):(\d+):(.*)$/.exec(raw);
+        if (match === null) {
+            continue;
+        }
+        const fileAbs = path.isAbsolute(match[1] ?? '')
+            ? (match[1] ?? '')
+            : path.join(fenceRoot, match[1] ?? '');
+        const line = Number(match[2]);
+        const text = match[3] ?? '';
+        if (!Number.isFinite(line)) {
+            continue;
+        }
+        hits.push({
+            file: displayPath(fileAbs),
+            line,
+            text: text.length > MAX_GREP_LINE_CHARS
+                ? `${text.slice(0, MAX_GREP_LINE_CHARS)}…`
+                : text,
+        });
+        if (hits.length >= maxHits) {
+            return { hits, truncated: true };
+        }
+    }
+    return { hits, truncated: false };
+};
+const isBinaryAbortError = (error) => error instanceof Error &&
+    (error.name === 'AbortError' || error.message === 'aborted');
+const searchWithRipgrep = async (input, deps = {}) => {
+    const exists = deps.commandExists ?? commandExists;
+    const run = deps.spawnCapture ?? spawnCapture;
+    if (!(await exists('rg'))) {
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: 'ripgrep (rg) is not available on this system',
+        };
+    }
+    throwIfAborted(input.signal);
+    const args = [
+        '-n',
+        '--color',
+        'never',
+        '--max-filesize',
+        `${MAX_GREP_FILE_BYTES}`,
+        ...(input.respectGitignore ? [] : ['--no-ignore']),
+        ...SEARCH_EXCLUDE_GLOBS.flatMap((glob) => ['--glob', glob]),
+        ...(input.caseInsensitive ? ['-i'] : []),
+        '-e',
+        input.pattern,
+        input.searchAbsolute,
+    ];
+    try {
+        const result = await run('rg', args, {
+            cwd: input.fenceRoot,
+            ...(input.signal !== undefined ? { signal: input.signal } : {}),
+        });
+        // rg: 0 = matches, 1 = no matches, 2 = error
+        if (result.code !== null && result.code >= 2) {
+            const detail = result.stderr.trim();
+            return {
+                ok: false,
+                reason: 'error',
+                message: detail.length > 0
+                    ? `ripgrep failed: ${detail}`
+                    : 'ripgrep failed',
+            };
+        }
+        const parsed = parseLineHits(result.stdout, input.displayPath, input.fenceRoot, MAX_GREP_MATCHES);
+        return {
+            ok: true,
+            hits: parsed.hits,
+            truncated: parsed.truncated,
+            backend: 'rg',
+        };
+    }
+    catch (error) {
+        if (isBinaryAbortError(error)) {
+            throw new Error('aborted');
+        }
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: error instanceof Error
+                ? error.message
+                : 'Error executing ripgrep',
+        };
+    }
+};
+const searchWithGrep = async (input, deps = {}) => {
+    const exists = deps.commandExists ?? commandExists;
+    const run = deps.spawnCapture ?? spawnCapture;
+    if (!(await exists('grep'))) {
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: 'grep is not available on this system',
+        };
+    }
+    throwIfAborted(input.signal);
+    const args = [
+        '-r',
+        '-n',
+        '-E',
+        '-I',
+        ...(input.caseInsensitive ? ['-i'] : []),
+        ...WALK_EXCLUDE_DIR_NAMES.flatMap((name) => ['--exclude-dir', name]),
+        '-e',
+        input.pattern,
+        input.searchAbsolute,
+    ];
+    try {
+        const result = await run('grep', args, {
+            cwd: input.fenceRoot,
+            ...(input.signal !== undefined ? { signal: input.signal } : {}),
+        });
+        // grep: 0 = matches, 1 = no matches, ≥2 = error
+        if (result.code !== null && result.code >= 2) {
+            const detail = result.stderr.trim();
+            return {
+                ok: false,
+                reason: 'error',
+                message: detail.length > 0
+                    ? `grep failed: ${detail}`
+                    : 'grep failed',
+            };
+        }
+        const parsed = parseLineHits(result.stdout, input.displayPath, input.fenceRoot, MAX_GREP_MATCHES);
+        return {
+            ok: true,
+            hits: parsed.hits,
+            truncated: parsed.truncated,
+            backend: 'grep',
+        };
+    }
+    catch (error) {
+        if (isBinaryAbortError(error)) {
+            throw new Error('aborted');
+        }
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: error instanceof Error ? error.message : 'Error executing grep',
+        };
+    }
+};
+const looksBinary = (buf) => {
+    const sample = buf.subarray(0, Math.min(buf.length, 8_192));
+    return sample.includes(0);
+};
+const yieldEventLoop = () => new Promise((resolve) => {
+    setImmediate(resolve);
+});
+export const searchWithNodeWalk = async (input) => {
+    throwIfAborted(input.signal);
+    let regex;
+    try {
+        regex = new RegExp(input.pattern, input.caseInsensitive ? 'i' : '');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            reason: 'error',
+            message: `Invalid regex «${input.pattern}»: ${message}. Escape special characters or simplify the pattern.`,
+        };
+    }
+    const stat = await fs.stat(input.searchAbsolute).catch(() => null);
+    if (stat === null) {
+        return {
+            ok: false,
+            reason: 'error',
+            message: `Path not found: ${input.searchAbsolute}`,
+        };
+    }
+    const files = stat.isFile()
+        ? [input.searchAbsolute]
+        : (await walkFiles(input.fenceRoot, input.searchAbsolute, {
+            respectGitignore: input.respectGitignore,
+            ...(input.signal !== undefined
+                ? { signal: input.signal }
+                : {}),
+            maxFiles: MAX_GREP_FILES_SCANNED,
+        })).map((relative) => path.join(input.fenceRoot, relative));
+    const hits = [];
+    let matchCapHit = false;
+    let scanned = 0;
+    for (const fileAbs of files) {
+        throwIfAborted(input.signal);
+        scanned += 1;
+        if (scanned % 16 === 0) {
+            await yieldEventLoop();
+            throwIfAborted(input.signal);
+        }
+        if (hits.length >= MAX_GREP_MATCHES) {
+            matchCapHit = true;
+            break;
+        }
+        let buf;
+        try {
+            const handle = await fs.open(fileAbs, 'r');
+            try {
+                const st = await handle.stat();
+                if (st.size > MAX_GREP_FILE_BYTES) {
+                    continue;
+                }
+                buf = Buffer.alloc(Number(st.size));
+                await handle.read(buf, 0, buf.length, 0);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch {
+            continue;
+        }
+        if (looksBinary(buf)) {
+            continue;
+        }
+        const text = buf.toString('utf8');
+        const lines = text.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i += 1) {
+            let line = lines[i] ?? '';
+            if (line.length > MAX_GREP_LINE_CHARS) {
+                line = line.slice(0, MAX_GREP_LINE_CHARS);
+            }
+            if (regex.test(line)) {
+                hits.push({
+                    file: input.displayPath(fileAbs),
+                    line: i + 1,
+                    text: line,
+                });
+                if (hits.length >= MAX_GREP_MATCHES) {
+                    matchCapHit = true;
+                    break;
+                }
+            }
+        }
+    }
+    const fileCapHit = !stat.isFile() && files.length >= MAX_GREP_FILES_SCANNED;
+    return {
+        ok: true,
+        hits,
+        truncated: matchCapHit || fileCapHit,
+        backend: 'node',
+    };
+};
+/**
+ * ts-scan-style cascade: rg → grep → bounded Node walk.
+ * Soft-falls through when a CLI binary is missing or fails to spawn;
+ * Node tier surfaces invalid JS RegExp errors.
+ */
+export const runGrepCascade = async (input, deps = {}) => {
+    throwIfAborted(input.signal);
+    const rg = await searchWithRipgrep(input, deps);
+    if (rg.ok) {
+        return {
+            body: formatGrepBody(rg.hits, rg.truncated),
+            backend: rg.backend,
+        };
+    }
+    const grep = await searchWithGrep(input, deps);
+    if (grep.ok) {
+        return {
+            body: formatGrepBody(grep.hits, grep.truncated),
+            backend: grep.backend,
+        };
+    }
+    const node = await searchWithNodeWalk(input);
+    if (!node.ok) {
+        throw new Error(node.message);
+    }
+    return {
+        body: formatGrepBody(node.hits, node.truncated),
+        backend: node.backend,
+    };
+};

package/vendor/tools/dist/builtins/grep/tool.d.ts

@@ -4,13 +4,13 @@ export declare const grepTool: {
     readonly registration: {
         readonly toolId: "grep";
         readonly name: "grep";
-        readonly description: "Regex search across project files (gitignore-aware by default; Node walk — not ripgrep). Optional postProcess.";
+        readonly description: "Regex search across project files (gitignore-aware by default; ripgrep when available, else grep, else bounded Node walk). Optional postProcess.";
         readonly inputSchema: {
             readonly type: "object";
             readonly properties: {
                 readonly pattern: {
                     readonly type: "string";
-                    readonly description: "JavaScript RegExp source";
+                    readonly description: "Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)";
                 };
                 readonly path: {
                     readonly type: "string";