langflower 0.0.6 → 0.0.7

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

@@ -6,6 +6,8 @@ export type HandlerContext = {
     /** Absolute (or project-relative) roots trusted outside the project. */
     readonly allowedRoots: readonly string[];
     readonly bashEnabled: boolean;
+    /** Per-invoke abort (tool timeout / run cancel). */
+    readonly signal?: AbortSignal;
 };
 export type BuiltinTool<Id extends string = string> = {
     readonly id: Id;

package/vendor/tools/dist/builtins/walk-files.d.ts

@@ -1,2 +1,16 @@
+/** Always skip these directory names (ts-scan-style), even with --no-ignore. */
+export declare const WALK_EXCLUDE_DIR_NAMES: readonly ["node_modules", "dist", "build", ".git"];
 export declare const globToRegExp: (pattern: string) => RegExp;
-export declare const walkFiles: (root: string, dir: string, respectGitignore: boolean) => Promise<readonly string[]>;
+export type WalkFilesOptions = {
+    readonly respectGitignore?: boolean;
+    readonly signal?: AbortSignal;
+    /** Stop collecting after this many files (default unlimited). */
+    readonly maxFiles?: number;
+    /** Yield to the event loop every N directory entries (default 32). */
+    readonly yieldEvery?: number;
+};
+/**
+ * Async recursive file walk. Third arg may be `respectGitignore` boolean
+ * (legacy) or {@link WalkFilesOptions}.
+ */
+export declare const walkFiles: (root: string, dir: string, options?: boolean | WalkFilesOptions) => Promise<readonly string[]>;

package/vendor/tools/dist/builtins/walk-files.js

@@ -1,6 +1,13 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { loadGitIgnoreMatcher } from '../gitignore.js';
+/** Always skip these directory names (ts-scan-style), even with --no-ignore. */
+export const WALK_EXCLUDE_DIR_NAMES = [
+    'node_modules',
+    'dist',
+    'build',
+    '.git',
+];
 export const globToRegExp = (pattern) => {
     const escaped = pattern
         .replace(/\\/g, '/')
@@ -11,12 +18,42 @@ export const globToRegExp = (pattern) => {
         .replace(/::DOUBLESTAR::/g, '.*');
     return new RegExp(`^${escaped}$`);
 };
-export const walkFiles = async (root, dir, respectGitignore) => {
+const normalizeOptions = (options) => typeof options === 'boolean' ? { respectGitignore: options } : options;
+const yieldEventLoop = () => new Promise((resolve) => {
+    setImmediate(resolve);
+});
+const throwIfAborted = (signal) => {
+    if (signal?.aborted) {
+        throw new Error('aborted');
+    }
+};
+/**
+ * Async recursive file walk. Third arg may be `respectGitignore` boolean
+ * (legacy) or {@link WalkFilesOptions}.
+ */
+export const walkFiles = async (root, dir, options = true) => {
+    const opts = normalizeOptions(options);
+    const respectGitignore = opts.respectGitignore !== false;
+    const yieldEvery = opts.yieldEvery ?? 32;
     const matcher = respectGitignore
         ? await loadGitIgnoreMatcher(root)
         : { ignores: () => false };
     const out = [];
+    const visitedDirs = new Set();
+    let steps = 0;
     const visit = async (absoluteDir) => {
+        throwIfAborted(opts.signal);
+        let realDir;
+        try {
+            realDir = await fs.realpath(absoluteDir);
+        }
+        catch {
+            return;
+        }
+        if (visitedDirs.has(realDir)) {
+            return;
+        }
+        visitedDirs.add(realDir);
         let entries;
         try {
             entries = await fs.readdir(absoluteDir, { withFileTypes: true });
@@ -25,6 +62,16 @@ export const walkFiles = async (root, dir, respectGitignore) => {
             return;
         }
         for (const entry of entries) {
+            throwIfAborted(opts.signal);
+            steps += 1;
+            if (steps % yieldEvery === 0) {
+                await yieldEventLoop();
+                throwIfAborted(opts.signal);
+            }
+            if (entry.isDirectory() &&
+                WALK_EXCLUDE_DIR_NAMES.includes(entry.name)) {
+                continue;
+            }
             const absolute = path.join(absoluteDir, entry.name);
             const relative = path
                 .relative(root, absolute)
@@ -33,11 +80,18 @@ export const walkFiles = async (root, dir, respectGitignore) => {
             if (matcher.ignores(relative, entry.isDirectory())) {
                 continue;
             }
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
             if (entry.isDirectory()) {
                 await visit(absolute);
             }
             else if (entry.isFile()) {
                 out.push(relative);
+                if (opts.maxFiles !== undefined &&
+                    out.length >= opts.maxFiles) {
+                    return;
+                }
             }
         }
     };

package/vendor/tools/dist/create-project-harness.js

@@ -48,7 +48,10 @@ export const createProjectHarness = (options) => {
                 return deniedToolResult(toolId, detail);
             }
             try {
-                const text = await invokeBuiltin(toolId, ctx, call.args);
+                const invokeCtx = call.signal === undefined
+                    ? ctx
+                    : { ...ctx, signal: call.signal };
+                const text = await invokeBuiltin(toolId, invokeCtx, call.args);
                 return { ok: true, text };
             }
             catch (error) {

package/vendor/tools/dist/domain/domain-tool-configs.d.ts

@@ -15,6 +15,8 @@ export type ToolHandlerContext = {
     readonly webFetch?: (request: WebFetchRequest) => Promise<WebFetchResult>;
     readonly denyPaths?: readonly string[];
     readonly allowedHosts?: readonly string[];
+    /** Per-invoke abort (tool timeout / run cancel) for builtins. */
+    readonly signal?: AbortSignal;
 };
 export type ToolHandler = (args: Readonly<Record<string, unknown>>, ctx: ToolHandlerContext) => Promise<string>;
 export type DomainToolConfig = {

package/vendor/tools/dist/harness-types.d.ts

@@ -12,6 +12,8 @@ export type ToolInvokeResult = {
 export type ToolInvokeCall = {
     readonly toolId: string;
     readonly args: Readonly<Record<string, unknown>>;
+    /** Per-invoke abort (tool timeout / run cancel). */
+    readonly signal?: AbortSignal;
 };
 export type BuiltinToolRegistration = {
     readonly toolId: string;