jev-recipes 0.9.9 → 0.9.11

package/dist/adapters/ai-sdk/index.d.ts

@@ -2,9 +2,9 @@ import type { FlexibleSchema, LanguageModel, PrepareStepFunction, StopCondition,
 import type { RecipeName } from '../../catalog/schema.js';
 import type { ModelRouteResult } from '../../recipes/model-route/index.js';
 import type { RecipeOptions } from '../../src/schema.js';
-import type { BlockedToolOutput, CompletionOptions, CompletionToolOutput, GuardOptions, RecipeToolOptions } from '../shared.js';
-export type { BlockedToolOutput, CompletionEvent, CompletionOptions, CompletionToolOutput, GuardEvent, GuardOptions, RecipeToolOptions, } from '../shared.js';
-export type RecipeTool = Tool<Record<string, unknown>, Record<string, unknown>>;
+import type { BlockedToolOutput, CompletionOptions, CompletionToolOutput, GuardOptions, RecipeToolOptions, RecipeToolOutput } from '../shared.js';
+export type { BlockedToolOutput, CompletionEvent, CompletionOptions, CompletionToolOutput, GuardEvent, GuardOptions, RecipeToolOptions, RecipeToolOutput, } from '../shared.js';
+export type RecipeTool = Tool<Record<string, unknown>, RecipeToolOutput>;
 export declare function recipeTool(name: RecipeName, options?: RecipeToolOptions): RecipeTool;
 export declare function recipeTools(names: readonly RecipeName[], options?: RecipeToolOptions): Record<string, RecipeTool>;
 export type GuardToolsOptions = GuardOptions & {

package/dist/adapters/langchain/index.d.ts

@@ -2,7 +2,7 @@ import { DynamicStructuredTool } from '@langchain/core/tools';
 import type { RecipeName } from '../../catalog/schema.js';
 import { COMPLETION_TOOL_INPUT_SCHEMA } from '../shared.js';
 import type { CompletionOptions, GuardOptions, RecipeToolOptions } from '../shared.js';
-export type { BlockedToolOutput, CompletionEvent, CompletionOptions, CompletionToolOutput, GuardEvent, GuardOptions, RecipeToolOptions, } from '../shared.js';
+export type { BlockedToolOutput, CompletionEvent, CompletionOptions, CompletionToolOutput, GuardEvent, GuardOptions, RecipeToolOptions, RecipeToolOutput, } from '../shared.js';
 type JsonSchema = Record<string, unknown>;
 export type RecipeTool = DynamicStructuredTool<JsonSchema>;
 export declare function recipeTool(name: RecipeName, options?: RecipeToolOptions): RecipeTool;

package/dist/adapters/shared.d.ts

@@ -5,11 +5,12 @@ import type { RecipeOptions } from '../src/schema.js';
 export type RecipeToolOptions = RecipeOptions & {
     description?: string;
 };
+export type RecipeToolOutput = Record<string, unknown> | null;
 export type RecipeToolDefinition = {
     name: RecipeName;
     description: string;
     inputSchema: Record<string, unknown>;
-    execute: (input: unknown, signal?: AbortSignal) => Promise<Record<string, unknown>>;
+    execute: (input: unknown, signal?: AbortSignal) => Promise<RecipeToolOutput>;
 };
 export type GuardOptions = RecipeOptions & {
     policy?: string;

package/dist/src/batch.d.ts

@@ -2,11 +2,4 @@ import type { ResultMetadata } from './schema.js';
 export type BatchEvaluation<Item> = ResultMetadata & {
     items: Item[];
 };
-/**
- * Split `items` into chunks of at most `batchSize`, evaluate every chunk
- * concurrently with `evaluate`, and merge the per-item results back into the
- * original order. Token usage is summed across requests; `model` comes from
- * the first response. One chunk is one Jev request, so a caller with 1,000
- * inputs and a batch size of 20 makes 50 requests instead of 1,000.
- */
-export declare function evaluateInBatches<Input, Item>(items: Input[], batchSize: number, evaluate: (chunk: Input[], offset: number) => Promise<BatchEvaluation<Item>>): Promise<BatchEvaluation<Item>>;
+export declare function evaluateInBatches<Input, Item>(items: Input[], batchSize: number, evaluateBatch: (items: Input[], offset: number) => Promise<BatchEvaluation<Item>>): Promise<BatchEvaluation<Item>>;

package/dist/src/batch.js

@@ -1,30 +1,21 @@
-/**
- * Split `items` into chunks of at most `batchSize`, evaluate every chunk
- * concurrently with `evaluate`, and merge the per-item results back into the
- * original order. Token usage is summed across requests; `model` comes from
- * the first response. One chunk is one Jev request, so a caller with 1,000
- * inputs and a batch size of 20 makes 50 requests instead of 1,000.
- */
-export async function evaluateInBatches(items, batchSize, evaluate) {
+export async function evaluateInBatches(items, batchSize, evaluateBatch) {
     if (!Number.isInteger(batchSize) || batchSize < 1)
         throw new Error('batchSize must be a positive integer.');
-    const chunks = [];
+    const batches = splitIntoBatches(items, batchSize);
+    const batchResults = await Promise.allSettled(batches.map(async ({ items, offset }) => evaluateBatch(items, offset)));
+    const firstFailedBatch = batchResults.find((result) => result.status === 'rejected');
+    if (firstFailedBatch)
+        throw firstFailedBatch.reason;
+    const evaluations = batchResults.flatMap((result) => result.status === 'fulfilled' ? [result.value] : []);
+    return combineBatchResults(evaluations);
+}
+function splitIntoBatches(items, batchSize) {
+    const batches = [];
     for (let offset = 0; offset < items.length; offset += batchSize)
-        chunks.push({ chunk: items.slice(offset, offset + batchSize), offset });
-    let firstFailure;
-    const settled = await Promise.allSettled(chunks.map(async ({ chunk, offset }) => {
-        try {
-            return await evaluate(chunk, offset);
-        }
-        catch (error) {
-            firstFailure ??= { error };
-            throw error;
-        }
-    }));
-    // Let request recorders finish before a caller archives this failed batch.
-    if (firstFailure)
-        throw firstFailure.error;
-    const evaluations = settled.flatMap((result) => result.status === 'fulfilled' ? [result.value] : []);
+        batches.push({ items: items.slice(offset, offset + batchSize), offset });
+    return batches;
+}
+function combineBatchResults(evaluations) {
     return {
         items: evaluations.flatMap((evaluation) => evaluation.items),
         model: evaluations[0]?.model ?? 'none',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jev-recipes",
-  "version": "0.9.9",
+  "version": "0.9.11",
   "description": "248 small Jev decisions for JavaScript and TypeScript: route, rerank, gate, grade, compare, and label text for agents, RAG, support, code review, and music. Each returns a typed result with explicit uncertainty. Plug into Vercel AI SDK or LangChain agents, import one recipe, or run the CLI with JSON from any language.",
   "type": "module",
   "license": "MIT",