@sebastiantuyu/agest 0.3.1 → 0.3.3-next.1

package/dist/adapters/remote.js

@@ -24,12 +24,13 @@
  */
 export function remote(endpoint, options = {}) {
     const { headers = {}, method = "POST", body: extraBody, buildRequest = defaultBuildRequest, parseResponse, metadata: staticMetadata, } = options;
-    return async (input) => {
+    return async (input, execOptions) => {
         let res;
         try {
             const fetchOptions = {
                 method,
                 headers: { "Content-Type": "application/json", ...headers },
+                signal: execOptions?.signal,
             };
             if (method !== "GET") {
                 const built = buildRequest(input);

package/dist/cli.js

@@ -2,11 +2,35 @@
 import { spawn } from "child_process";
 import { main as stats } from "./stats.js";
 import { main as preview } from "./preview.js";
+import { DEFAULT_PATTERN, discoverTestFiles } from "./discover.js";
 const command = process.argv[2];
+function parseRunArgs(args) {
+    const targets = [];
+    let pattern;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--pattern" || a === "-p") {
+            pattern = args[++i];
+            if (pattern === undefined) {
+                console.error("  Error: --pattern requires a value");
+                process.exit(1);
+            }
+        }
+        else if (a.startsWith("--pattern=")) {
+            pattern = a.slice("--pattern=".length);
+        }
+        else {
+            targets.push(a);
+        }
+    }
+    return { pattern, targets };
+}
 async function run() {
-    const files = process.argv.slice(3);
+    const { pattern, targets } = parseRunArgs(process.argv.slice(3));
+    const files = await discoverTestFiles(targets, { pattern });
     if (files.length === 0) {
-        console.error("  Usage: agest run <file...>");
+        const effective = pattern ?? DEFAULT_PATTERN;
+        console.error(`  No test files found (pattern: ${effective})`);
         process.exit(1);
     }
     for (const file of files) {
@@ -29,7 +53,10 @@ if (!command || !commands[command]) {
   Usage: agest <command>
 
   Commands:
-    run        Run test file(s)    agest run tests/*.test.ts
+    run        Run test file(s), directories, or glob patterns
+               agest run tests/                       # walks for ${DEFAULT_PATTERN}
+               agest run src/agest --pattern "**/*.test.ts"
+               agest run "tests/**/*.agest.ts" path/to/file.agest.ts
     stats      Show aggregated test statistics
     preview    Generate an HTML report preview
 `);

package/dist/config.d.ts

@@ -13,6 +13,7 @@ export interface AgestConfig {
     parallelism?: number;
     timeout?: number;
     turns?: number;
+    runs?: number;
     judge?: JudgeConfig;
 }
 export declare function defineConfig(config: AgestConfig): AgestConfig;

package/dist/context.js

@@ -98,7 +98,7 @@ export class AgentContext {
             for (const hook of this._beforeEachHooks) {
                 await hook();
             }
-            const result = await executeScene(this._executor, scene, config.timeout, config.judge, config.turns);
+            const result = await executeScene(this._executor, scene, config.timeout, config.judge, config.turns, config.runs);
             orderedResults[i] = result;
             // Run afterEach hooks
             for (const hook of this._afterEachHooks) {

package/dist/discover.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_PATTERN = "**/*.agest.ts";
+export interface DiscoverOptions {
+    pattern?: string;
+    cwd?: string;
+}
+/**
+ * Resolve a mix of file paths, directories, and glob patterns into a
+ * deduplicated, sorted list of absolute file paths.
+ *
+ * Rules per target:
+ *   - directory: search recursively for `pattern` (default `**\/*.agest.ts`)
+ *   - glob (contains *, ?, [], {}): expand it
+ *   - file: use as-is
+ *   - anything else: try as glob (zero matches is fine)
+ */
+export declare function discoverTestFiles(targets: string[], options?: DiscoverOptions): Promise<string[]>;

package/dist/discover.js

@@ -0,0 +1,62 @@
+import { promises as fs } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+export const DEFAULT_PATTERN = "**/*.agest.ts";
+const GLOB_CHARS = /[*?[\]{}]/;
+function hasGlobChars(value) {
+    return GLOB_CHARS.test(value);
+}
+async function statSafe(path) {
+    try {
+        const stat = await fs.stat(path);
+        return { isFile: stat.isFile(), isDir: stat.isDirectory() };
+    }
+    catch {
+        return { isFile: false, isDir: false };
+    }
+}
+async function expandGlob(pattern, cwd) {
+    const out = [];
+    // fs.promises.glob is available in Node >= 22 (the package's required engine).
+    for await (const match of fs.glob(pattern, { cwd })) {
+        out.push(isAbsolute(match) ? match : resolve(cwd, match));
+    }
+    return out;
+}
+/**
+ * Resolve a mix of file paths, directories, and glob patterns into a
+ * deduplicated, sorted list of absolute file paths.
+ *
+ * Rules per target:
+ *   - directory: search recursively for `pattern` (default `**\/*.agest.ts`)
+ *   - glob (contains *, ?, [], {}): expand it
+ *   - file: use as-is
+ *   - anything else: try as glob (zero matches is fine)
+ */
+export async function discoverTestFiles(targets, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const pattern = options.pattern ?? DEFAULT_PATTERN;
+    const work = targets.length === 0 ? ["."] : targets;
+    const found = new Set();
+    for (const target of work) {
+        if (hasGlobChars(target)) {
+            for (const f of await expandGlob(target, cwd))
+                found.add(f);
+            continue;
+        }
+        const stat = await statSafe(isAbsolute(target) ? target : resolve(cwd, target));
+        if (stat.isDir) {
+            const trimmed = target.replace(/\/+$/, "");
+            const dirPattern = `${trimmed}/${pattern}`;
+            for (const f of await expandGlob(dirPattern, cwd))
+                found.add(f);
+            continue;
+        }
+        if (stat.isFile) {
+            found.add(isAbsolute(target) ? target : resolve(cwd, target));
+            continue;
+        }
+        for (const f of await expandGlob(target, cwd))
+            found.add(f);
+    }
+    return [...found].sort();
+}

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export type { AgestConfig, JudgeConfig, JudgeExecutor } from "./config";
 export type { LogLevel } from "./logger";
 export type { AgentExpectation, AgentMatchers } from "./assertions";
 export type { JudgeCriteria } from "./judge";
-export type { AgentExecutor, AgentResponse, AgentReport, SceneResult, RunResult, JudgeVerdict, JudgeResult, HookFn, } from "./types";
+export type { AgentExecutor, ExecutorOptions, AgentResponse, AgentReport, SceneResult, RunResult, JudgeVerdict, JudgeResult, HookFn, } from "./types";
 export interface AgentOptions {
     name?: string;
 }

package/dist/runner.d.ts

@@ -1,4 +1,4 @@
 import type { AgentExecutor, AgentResponse, SceneDefinition, SceneResult } from "./types";
 import type { JudgeConfig } from "./config";
 export declare function extractField(response: AgentResponse, field: string): unknown;
-export declare function executeScene(executor: AgentExecutor, scene: SceneDefinition, globalTimeout?: number, judgeConfig?: JudgeConfig, globalTurns?: number): Promise<SceneResult>;
+export declare function executeScene(executor: AgentExecutor, scene: SceneDefinition, globalTimeout?: number, judgeConfig?: JudgeConfig, globalTurns?: number, globalRuns?: number): Promise<SceneResult>;

package/dist/runner.js

@@ -35,19 +35,24 @@ async function executeSingleRun(executor, scene, timeoutMs, turns, judgeConfig)
     let duration;
     try {
         const start = performance.now();
-        let input = scene.prompt;
+        const input = scene.prompt;
         for (let t = 0; t < turns; t++) {
-            let timer;
-            response = await Promise.race([
-                executor(input).finally(() => clearTimeout(timer)),
-                new Promise((_, reject) => {
-                    timer = setTimeout(() => reject(new Error(`Scene timed out after ${timeoutMs}ms`)), timeoutMs);
-                }),
-            ]);
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                response = await executor(input, { signal: controller.signal });
+            }
+            catch (err) {
+                if (err.name === "AbortError" || controller.signal.aborted) {
+                    throw new Error(`Scene timed out after ${timeoutMs}ms`);
+                }
+                throw err;
+            }
+            finally {
+                clearTimeout(timer);
+            }
             if (response.executionError)
                 break;
-            if (t < turns - 1)
-                input = response.text;
         }
         duration = performance.now() - start;
     }
@@ -104,10 +109,10 @@ async function executeSingleRun(executor, scene, timeoutMs, turns, judgeConfig)
     }
     return { passed, error, response, duration, judgement };
 }
-export async function executeScene(executor, scene, globalTimeout, judgeConfig, globalTurns) {
+export async function executeScene(executor, scene, globalTimeout, judgeConfig, globalTurns, globalRuns) {
     const timeoutMs = scene.timeout ?? globalTimeout ?? DEFAULT_SCENE_TIMEOUT;
     const turns = scene.turns ?? globalTurns ?? 1;
-    const numRuns = scene.runs ?? 1;
+    const numRuns = scene.runs ?? globalRuns ?? 1;
     // Single run — original fast path
     if (numRuns <= 1) {
         const run = await executeSingleRun(executor, scene, timeoutMs, turns, judgeConfig);

package/dist/types.d.ts

@@ -1,4 +1,7 @@
-export type AgentExecutor = (input: string) => Promise<AgentResponse>;
+export interface ExecutorOptions {
+    signal?: AbortSignal;
+}
+export type AgentExecutor = (input: string, options?: ExecutorOptions) => Promise<AgentResponse>;
 export interface AgentResponse {
     text: string;
     refusal?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebastiantuyu/agest",
-  "version": "0.3.1",
+  "version": "0.3.3-next.1",
   "description": "A testing library for agents",
   "repository": {
     "type": "git",
@@ -37,25 +37,26 @@
     "site:preview": "npx serve site -p 3000",
     "release:patch": "npm version patch && git push && git push --tags",
     "release:minor": "npm version minor && git push && git push --tags",
-    "release:major": "npm version major && git push && git push --tags"
+    "release:major": "npm version major && git push && git push --tags",
+    "release:next": "npm version prerelease --preid=next && git push && git push --tags"
   },
   "engines": {
     "node": ">=22.0.0"
   },
   "devDependencies": {
-    "@langchain/core": "^1.1.39",
-    "@langchain/langgraph": "^1.2.8",
-    "@langchain/openai": "^1.4.4",
-    "@types/node": "^22.0.0",
-    "@vitest/coverage-v8": "^3",
-    "dotenv": "^17.4.1",
-    "langchain": "^1.3.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.4.0",
-    "vitest": "^3",
-    "zod": "^4.3.6"
+    "@langchain/core": "1.1.39",
+    "@langchain/langgraph": "1.2.8",
+    "@langchain/openai": "1.4.4",
+    "@types/node": "22.19.17",
+    "@vitest/coverage-v8": "3.2.4",
+    "dotenv": "17.4.1",
+    "langchain": "1.3.1",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4",
+    "zod": "4.3.6"
   },
   "dependencies": {
-    "@supercharge/promise-pool": "^3.3.0"
+    "@supercharge/promise-pool": "3.3.0"
   }
 }