@crewx/sdk 0.8.0-rc.72 → 0.8.0-rc.74

package/dist/layout/renderer.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * LayoutRenderer — Handlebars-based layout rendering.
+ * Ported from packages/sdk-bak/src/services/layout-renderer.service.ts.
+ * Excluded: registerTemplateHelpers (exec/shell-quote).
+ * Exec is handled separately by TemplateEngine in the facade layer.
+ * WI-CONV-002: formatConversation helper restored.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutRenderer = exports.PropsValidationError = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const format_conversation_1 = require("../template/helpers/format-conversation");
+const props_validator_1 = require("./props-validator");
+const types_1 = require("./types");
+var types_2 = require("./types");
+Object.defineProperty(exports, "PropsValidationError", { enumerable: true, get: function () { return types_2.PropsValidationError; } });
+/**
+ * LayoutRenderer — renders layout templates with Handlebars.
+ */
+class LayoutRenderer {
+    handlebars;
+    propsValidator;
+    constructor(propsValidator) {
+        this.handlebars = handlebars_1.default.create();
+        this.propsValidator = propsValidator ?? new props_validator_1.PropsValidator();
+        this.registerHelpers();
+    }
+    /**
+     * Render a layout template with the given context.
+     */
+    render(layout, context, options = {}) {
+        try {
+            const preparedContext = this.prepareRenderContext(layout, context, options);
+            const template = this.handlebars.compile(layout.template, { noEscape: true });
+            return template(preparedContext);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Template rendering failed for layout '${layout.id}': ${error.message}`);
+            }
+            throw new Error(`Unknown error rendering layout '${layout.id}'`);
+        }
+    }
+    /**
+     * Validate props against schema.
+     */
+    validate(props, propsSchema, mode = 'lenient') {
+        return this.executeValidation(props, propsSchema, mode);
+    }
+    /**
+     * Merge default props and runtime props, then validate.
+     */
+    resolveProps(layout, props, mode = 'lenient') {
+        const mergedProps = this.mergeProps(layout.defaultProps, props);
+        if (!layout.propsSchema || Object.keys(layout.propsSchema).length === 0) {
+            return { valid: true, props: mergedProps, errors: [] };
+        }
+        return this.executeValidation(mergedProps, layout.propsSchema, mode);
+    }
+    prepareRenderContext(layout, context, options) {
+        const { validationMode = 'lenient', skipValidation = false } = options;
+        const resolvedProps = skipValidation
+            ? this.mergeProps(layout.defaultProps, context.props)
+            : this.resolveProps(layout, context.props, validationMode).props;
+        return {
+            ...context,
+            vars: this.sanitizeVars(context.vars),
+            props: resolvedProps,
+        };
+    }
+    /**
+     * Register built-in Handlebars helpers (no exec).
+     * WI-CONV-002: formatConversation block helper registered for conversation history.
+     */
+    registerHelpers() {
+        // Conversation history block helper (WI-CONV-002)
+        this.handlebars.registerHelper('formatConversation', format_conversation_1.formatConversationHelper);
+        // Built-in block helpers
+        if (handlebars_1.default.helpers.each) {
+            this.handlebars.registerHelper('each', handlebars_1.default.helpers.each);
+        }
+        if (handlebars_1.default.helpers.if) {
+            this.handlebars.registerHelper('if', handlebars_1.default.helpers.if);
+        }
+        if (handlebars_1.default.helpers.unless) {
+            this.handlebars.registerHelper('unless', handlebars_1.default.helpers.unless);
+        }
+        if (handlebars_1.default.helpers.with) {
+            this.handlebars.registerHelper('with', handlebars_1.default.helpers.with);
+        }
+        this.handlebars.registerHelper('eq', function (a, b) {
+            return a === b;
+        });
+        this.handlebars.registerHelper('ne', function (a, b) {
+            return a !== b;
+        });
+        this.handlebars.registerHelper('gt', function (a, b) {
+            return a > b;
+        });
+        this.handlebars.registerHelper('lt', function (a, b) {
+            return a < b;
+        });
+        this.handlebars.registerHelper('json', function (obj) {
+            return new handlebars_1.default.SafeString(JSON.stringify(obj));
+        });
+        this.handlebars.registerHelper('raw', function (options) {
+            return typeof options?.fn === 'function' ? options.fn(this) : '';
+        });
+        this.handlebars.registerHelper('escapeHandlebars', function (text) {
+            if (typeof text !== 'string')
+                return '';
+            return text.replace(/\{\{/g, '&#123;&#123;').replace(/\}\}/g, '&#125;&#125;');
+        });
+        this.handlebars.registerHelper('formatFileSize', function (bytes) {
+            if (bytes === 0)
+                return '0 B';
+            const sizes = ['B', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(1024));
+            return Math.round((bytes / Math.pow(1024, i)) * 100) / 100 + ' ' + sizes[i];
+        });
+    }
+    executeValidation(props, propsSchema, mode) {
+        try {
+            return this.propsValidator.validate(props, propsSchema, mode);
+        }
+        catch (error) {
+            if (error instanceof types_1.PropsValidationError && error.errors && error.errors.length > 0) {
+                const firstError = error.errors[0];
+                if (firstError) {
+                    throw new types_1.PropsValidationError(firstError.message, error.errors);
+                }
+            }
+            throw error;
+        }
+    }
+    mergeProps(defaultProps, overrides) {
+        const base = this.cloneDeep(defaultProps ?? {});
+        if (!overrides)
+            return base;
+        return this.deepMerge(base, overrides);
+    }
+    deepMerge(target, source) {
+        for (const [key, value] of Object.entries(source)) {
+            if (this.isPlainObject(value)) {
+                const existing = target[key];
+                target[key] = this.deepMerge(this.isPlainObject(existing) ? existing : {}, value);
+                continue;
+            }
+            if (Array.isArray(value)) {
+                target[key] = this.cloneDeep(value);
+                continue;
+            }
+            target[key] = value;
+        }
+        return target;
+    }
+    cloneDeep(value) {
+        if (Array.isArray(value)) {
+            return value.map(item => this.cloneDeep(item));
+        }
+        if (this.isPlainObject(value)) {
+            const cloned = {};
+            for (const [key, nested] of Object.entries(value)) {
+                cloned[key] = this.cloneDeep(nested);
+            }
+            return cloned;
+        }
+        return value;
+    }
+    isPlainObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    sanitizeVars(vars) {
+        if (!vars)
+            return {};
+        const sanitizedVars = { ...vars };
+        if (typeof vars.user_input === 'string') {
+            sanitizedVars.user_input_raw = vars.user_input;
+            const escapedHandlebars = vars.user_input
+                .replace(/\{\{\{/g, '&#123;&#123;&#123;')
+                .replace(/\}\}\}/g, '&#125;&#125;&#125;')
+                .replace(/\{\{/g, '&#123;&#123;')
+                .replace(/\}\}/g, '&#125;&#125;');
+            sanitizedVars.user_input = this.handlebars.escapeExpression(escapedHandlebars);
+        }
+        return sanitizedVars;
+    }
+}
+exports.LayoutRenderer = LayoutRenderer;
+//# sourceMappingURL=renderer.js.map

package/dist/{types/layout.types.d.ts → layout/types.d.ts}

@@ -1,4 +1,18 @@
-import type { TemplateVars } from './template.types';
+/**
+ * Layout system type definitions for CrewX SDK.
+ * Ported from packages/sdk-bak/src/types/layout.types.ts (1:1, import path only changed).
+ */
+/**
+ * Template variables for layout rendering (security_key, custom extensions).
+ */
+export interface TemplateVars {
+    /** Authentication token used to validate prompt containers */
+    security_key?: string;
+    [key: string]: unknown;
+}
+/**
+ * Prop schema definition (React PropTypes style).
+ */
 export interface PropSchema {
     type: 'string' | 'number' | 'bool' | 'array' | 'arrayOf' | 'object' | 'shape' | 'oneOfType' | 'func' | 'node';
     isRequired?: boolean;
@@ -15,6 +29,9 @@ export interface PropSchema {
     pattern?: string;
     description?: string;
 }
+/**
+ * Layout definition loaded from YAML.
+ */
 export interface LayoutDefinition {
     id: string;
     version: string;
@@ -23,6 +40,9 @@ export interface LayoutDefinition {
     propsSchema: Record<string, PropSchema>;
     defaultProps: Record<string, any>;
 }
+/**
+ * Custom layout configuration for runtime registration.
+ */
 export interface CustomLayoutDefinition {
     template: string;
     description?: string;
@@ -30,25 +50,40 @@ export interface CustomLayoutDefinition {
     propsSchema?: Record<string, any>;
     defaultProps?: Record<string, any>;
 }
+/**
+ * Inline layout specification from agent config.
+ */
 export type InlineLayoutSpec = string | {
     id: string;
     props?: Record<string, any>;
 };
+/**
+ * Validation result from PropsValidator.
+ */
 export interface ValidationResult {
     valid: boolean;
     props: Record<string, any>;
     errors: ValidationError[];
 }
+/**
+ * Validation error details.
+ */
 export interface ValidationError {
     path: string;
     message: string;
     value?: any;
 }
+/**
+ * Layout loader options.
+ */
 export interface LoaderOptions {
     templatesPath: string;
     validationMode?: 'strict' | 'lenient';
     fallbackLayoutId?: string;
 }
+/**
+ * Render context for layout-specific template rendering.
+ */
 export interface RenderContext {
     user_input?: string;
     messages?: Array<{
@@ -94,7 +129,11 @@ export interface RenderContext {
         [key: string]: any;
     };
     context?: Record<string, any>;
+    [key: string]: unknown;
 }
+/**
+ * Raw layout YAML structure.
+ */
 export interface RawLayoutYaml {
     id?: string;
     version?: string;
@@ -103,13 +142,20 @@ export interface RawLayoutYaml {
     template?: string;
     layouts?: Record<string, string>;
 }
+/**
+ * Error thrown when layout loading fails.
+ */
 export declare class LayoutLoadError extends Error {
     readonly layoutId?: string | undefined;
     readonly cause?: Error | undefined;
     constructor(message: string, layoutId?: string | undefined, cause?: Error | undefined);
 }
+/**
+ * Error thrown when props validation fails (strict mode).
+ */
 export declare class PropsValidationError extends Error {
     readonly errors: ValidationError[];
     readonly cause?: Error | undefined;
     constructor(message: string, errors?: ValidationError[], cause?: Error | undefined);
 }
+//# sourceMappingURL=types.d.ts.map

package/dist/{types/layout.types.js → layout/types.js}

@@ -1,7 +1,16 @@
 "use strict";
+/**
+ * Layout system type definitions for CrewX SDK.
+ * Ported from packages/sdk-bak/src/types/layout.types.ts (1:1, import path only changed).
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropsValidationError = exports.LayoutLoadError = void 0;
+/**
+ * Error thrown when layout loading fails.
+ */
 class LayoutLoadError extends Error {
+    layoutId;
+    cause;
     constructor(message, layoutId, cause) {
         super(message);
         this.layoutId = layoutId;
@@ -10,7 +19,12 @@ class LayoutLoadError extends Error {
     }
 }
 exports.LayoutLoadError = LayoutLoadError;
+/**
+ * Error thrown when props validation fails (strict mode).
+ */
 class PropsValidationError extends Error {
+    errors;
+    cause;
     constructor(message, errors = [], cause) {
         super(message);
         this.errors = errors;
@@ -19,4 +33,4 @@ class PropsValidationError extends Error {
     }
 }
 exports.PropsValidationError = PropsValidationError;
-//# sourceMappingURL=layout.types.js.map
+//# sourceMappingURL=types.js.map

package/dist/parallel/agent-runtime.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Minimal AgentRuntime for the parallel execution module.
+ * Provides query/execute methods to run agent operations.
+ * Tests use vi.spyOn(AgentRuntime.prototype, 'query') to mock these methods.
+ */
+export interface AgentQueryRequest {
+    agentId?: string;
+    prompt: string;
+    context?: string;
+}
+export interface AgentExecuteRequest {
+    agentId?: string;
+    prompt: string;
+    context?: string;
+}
+export interface AgentResult {
+    content: string;
+    success: boolean;
+    agentId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Runtime that executes agent query/execute operations.
+ * Default implementation throws — callers must inject a working provider
+ * or mock the prototype methods in tests.
+ */
+export declare class AgentRuntime {
+    query(_request: AgentQueryRequest): Promise<AgentResult>;
+    execute(_request: AgentExecuteRequest): Promise<AgentResult>;
+}
+//# sourceMappingURL=agent-runtime.d.ts.map

package/dist/parallel/agent-runtime.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Minimal AgentRuntime for the parallel execution module.
+ * Provides query/execute methods to run agent operations.
+ * Tests use vi.spyOn(AgentRuntime.prototype, 'query') to mock these methods.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRuntime = void 0;
+/**
+ * Runtime that executes agent query/execute operations.
+ * Default implementation throws — callers must inject a working provider
+ * or mock the prototype methods in tests.
+ */
+class AgentRuntime {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async query(_request) {
+        throw new Error('AgentRuntime.query is not implemented. Provide a subclass or mock AgentRuntime.prototype.query.');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async execute(_request) {
+        throw new Error('AgentRuntime.execute is not implemented. Provide a subclass or mock AgentRuntime.prototype.execute.');
+    }
+}
+exports.AgentRuntime = AgentRuntime;
+//# sourceMappingURL=agent-runtime.js.map

package/dist/{core/parallel → parallel}/helpers.d.ts

@@ -1,5 +1,5 @@
 import type { ParallelRunnerMetrics } from './types';
-import { type AgentQueryRequest, type AgentExecuteRequest, type AgentResult } from '../agent';
+import type { AgentQueryRequest, AgentExecuteRequest, AgentResult } from './agent-runtime';
 export interface RetryPolicy {
     maxRetries: number;
     retryDelay: number;
@@ -25,3 +25,4 @@ export interface HelperResult<T = AgentResult> {
 }
 export declare const runQueriesParallel: (queries: AgentQueryRequest[], config?: ParallelConfig) => Promise<AgentResult[]>;
 export declare const runExecutesParallel: (requests: AgentExecuteRequest[], config?: ParallelConfig) => Promise<AgentResult[]>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/{core/parallel → parallel}/helpers.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runExecutesParallel = exports.runQueriesParallel = void 0;
 const parallel_runner_1 = require("./parallel-runner");
-const agent_1 = require("../agent");
+const agent_runtime_1 = require("./agent-runtime");
 const DEFAULT_CONCURRENCY = 3;
-const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_RETRY_DELAY_MS = 500;
 const normalizeConcurrency = (value) => {
     if (typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value)) {
@@ -14,18 +14,15 @@ const normalizeConcurrency = (value) => {
     return normalized > 0 ? normalized : DEFAULT_CONCURRENCY;
 };
 const normalizeTimeout = (value) => {
-    if (value === undefined) {
+    if (value === undefined)
         return DEFAULT_TIMEOUT_MS;
-    }
-    if (typeof value !== 'number' || Number.isNaN(value) || value <= 0) {
+    if (typeof value !== 'number' || Number.isNaN(value) || value <= 0)
         return DEFAULT_TIMEOUT_MS;
-    }
     return value;
 };
 const normalizeRetryPolicy = (policy) => {
-    if (!policy) {
+    if (!policy)
         return { maxRetries: 0, retryDelay: DEFAULT_RETRY_DELAY_MS };
-    }
     const maxRetries = Number.isInteger(policy.maxRetries) && policy.maxRetries >= 0
         ? policy.maxRetries
         : 0;
@@ -36,18 +33,15 @@ const normalizeRetryPolicy = (policy) => {
 };
 const createAbortError = (signal) => {
     const reason = signal.reason;
-    if (reason instanceof Error) {
+    if (reason instanceof Error)
         return reason;
-    }
-    if (typeof reason === 'string') {
+    if (typeof reason === 'string')
         return new Error(reason);
-    }
     return new Error('Parallel operation aborted');
 };
 const waitForDelay = (delayMs, signal) => {
-    if (delayMs <= 0) {
+    if (delayMs <= 0)
         return Promise.resolve();
-    }
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
             signal.removeEventListener('abort', onAbort);
@@ -67,72 +61,64 @@ const waitForDelay = (delayMs, signal) => {
 const executeWithRetry = async (execute, retryPolicy, signal) => {
     let lastFailureResult;
     let lastError;
-    for (let attempt = 0; attempt <= retryPolicy.maxRetries; attempt += 1) {
-        if (signal.aborted) {
+    for (let attempt = 0; attempt <= retryPolicy.maxRetries; attempt++) {
+        if (signal.aborted)
             throw createAbortError(signal);
-        }
         try {
             const result = await execute();
             lastFailureResult = result;
-            if (result.success || attempt === retryPolicy.maxRetries) {
+            if (result.success || attempt === retryPolicy.maxRetries)
                 return result;
-            }
         }
         catch (error) {
             lastError = error;
-            if (signal.aborted) {
+            if (signal.aborted)
                 throw createAbortError(signal);
-            }
             if (attempt === retryPolicy.maxRetries) {
-                const normalizedError = error instanceof Error ? error : new Error(String(error));
-                throw normalizedError;
+                throw error instanceof Error ? error : new Error(String(error));
             }
         }
         if (attempt < retryPolicy.maxRetries) {
             await waitForDelay(retryPolicy.retryDelay, signal);
         }
     }
-    if (lastFailureResult) {
+    if (lastFailureResult)
         return lastFailureResult;
-    }
-    if (lastError) {
+    if (lastError)
         throw lastError instanceof Error ? lastError : new Error(String(lastError));
-    }
     throw new Error('Parallel helper encountered an unexpected state');
 };
-const recordProgress = (callbacks, state, wasSuccessful) => {
+const recordProgress = (config, state, wasSuccessful) => {
     state.completed += 1;
-    if (wasSuccessful) {
+    if (wasSuccessful)
         state.success += 1;
-    }
-    else {
+    else
         state.failure += 1;
-    }
     try {
-        callbacks.onProgress?.(state.completed, state.total);
+        config.onProgress?.(state.completed, state.total);
     }
     catch (error) {
-        if (process.env.NODE_ENV !== 'production') {
+        if (process.env['NODE_ENV'] !== 'production') {
             console.warn('Parallel helper onProgress callback threw an error:', error);
         }
     }
 };
-const mapResults = (taskResults) => {
-    return taskResults.map((taskResult) => ({
+const buildAgentResults = (taskResults) => {
+    const decorated = taskResults.map((taskResult) => ({
         metadata: taskResult.metadata,
         taskResult,
     }));
-};
-const buildAgentResults = (decoratedResults) => {
-    const ordered = decoratedResults.slice().sort((a, b) => a.metadata.index - b.metadata.index);
-    return ordered.map(({ metadata, taskResult }) => {
+    return decorated
+        .slice()
+        .sort((a, b) => a.metadata.index - b.metadata.index)
+        .map(({ metadata, taskResult }) => {
         if (taskResult.value) {
-            const baseResult = taskResult.value;
+            const base = taskResult.value;
             return {
-                ...baseResult,
-                agentId: baseResult.agentId ?? metadata.request.agentId,
+                ...base,
+                agentId: base.agentId ?? metadata.request.agentId,
                 metadata: {
-                    ...baseResult.metadata,
+                    ...base.metadata,
                     requestIndex: metadata.index,
                     mode: metadata.mode,
                 },
@@ -152,20 +138,19 @@ const buildAgentResults = (decoratedResults) => {
         };
     });
 };
-const collectErrors = (decoratedResults) => {
-    return decoratedResults
-        .filter(({ taskResult }) => !taskResult.success)
-        .map(({ metadata, taskResult }) => {
+const collectErrors = (taskResults) => {
+    return taskResults
+        .filter((r) => !r.success)
+        .map((taskResult) => {
+        const meta = taskResult.metadata;
         if (taskResult.error instanceof Error) {
-            return { index: metadata.index, error: taskResult.error };
+            return { index: meta.index, error: taskResult.error };
         }
         if (taskResult.value && !taskResult.value.success) {
-            const errorMessage = taskResult.value.metadata?.error
-                ?? taskResult.value.content
-                ?? 'Agent returned unsuccessful result';
-            return { index: metadata.index, error: new Error(errorMessage) };
+            const msg = String(taskResult.value.metadata?.['error'] ?? taskResult.value.content ?? 'Agent returned unsuccessful result');
+            return { index: meta.index, error: new Error(msg) };
         }
-        return { index: metadata.index, error: new Error('Unknown failure') };
+        return { index: meta.index, error: new Error('Unknown failure') };
     });
 };
 const createCallbacks = (progressState, config) => ({
@@ -182,23 +167,13 @@ const runAgentOperations = async (requests, mode, config = {}) => {
     }
     if (requests.length === 0) {
         const emptyMetrics = {
-            totalTasks: 0,
-            startedTasks: 0,
-            completedTasks: 0,
-            successCount: 0,
-            failureCount: 0,
-            totalDurationMs: 0,
-            averageDurationMs: 0,
-            throughput: 0,
+            totalTasks: 0, startedTasks: 0, completedTasks: 0,
+            successCount: 0, failureCount: 0, totalDurationMs: 0,
+            averageDurationMs: 0, throughput: 0,
         };
         const summary = {
-            total: 0,
-            completed: 0,
-            successCount: 0,
-            failureCount: 0,
-            results: [],
-            errors: [],
-            metrics: emptyMetrics,
+            total: 0, completed: 0, successCount: 0, failureCount: 0,
+            results: [], errors: [], metrics: emptyMetrics,
         };
         config.onComplete?.(summary);
         return [];
@@ -207,37 +182,29 @@ const runAgentOperations = async (requests, mode, config = {}) => {
     const timeout = normalizeTimeout(config.timeout);
     const retryPolicy = normalizeRetryPolicy(config.retryPolicy);
     const runner = new parallel_runner_1.ParallelRunner();
-    const runtime = new agent_1.AgentRuntime();
-    const runSingleOperation = (request) => (mode === 'query'
-        ? runtime.query(request)
-        : runtime.execute(request));
+    const runtime = new agent_runtime_1.AgentRuntime();
     const tasks = requests.map((request, index) => ({
         id: `${mode}:${request.agentId ?? 'anonymous'}:${index}`,
         metadata: { index, mode, request },
-        run: (context) => executeWithRetry(() => runSingleOperation(request), retryPolicy, context.signal),
+        run: (context) => executeWithRetry(() => mode === 'query'
+            ? runtime.query(request)
+            : runtime.execute(request), retryPolicy, context.signal),
     }));
-    const progressState = {
-        completed: 0,
-        success: 0,
-        failure: 0,
-        total: requests.length,
-    };
-    const runnerOptions = {
+    const progressState = { completed: 0, success: 0, failure: 0, total: requests.length };
+    const taskResults = await runner.run(tasks, {
         maxConcurrency: concurrency,
         timeoutMs: timeout,
         evaluateTaskSuccess: (value) => value.success,
         callbacks: createCallbacks(progressState, config),
-    };
-    const taskResults = await runner.run(tasks, runnerOptions);
-    const decoratedResults = mapResults(taskResults);
-    const agentResults = buildAgentResults(decoratedResults);
-    const errors = collectErrors(decoratedResults);
+    });
+    const agentResults = buildAgentResults(taskResults);
+    const errors = collectErrors(taskResults);
     const metrics = runner.getMetrics();
     const summary = {
         total: requests.length,
         completed: requests.length,
-        successCount: agentResults.filter((item) => item.success).length,
-        failureCount: agentResults.filter((item) => !item.success).length,
+        successCount: agentResults.filter((r) => r.success).length,
+        failureCount: agentResults.filter((r) => !r.success).length,
         results: agentResults,
         errors,
         metrics,

package/dist/parallel/index.d.ts

@@ -0,0 +1,8 @@
+export { ParallelRunner } from './parallel-runner';
+export { ParallelRunnerTimeoutError } from './parallel-runner';
+export type { Task, TaskResult, TaskExecutionContext, TaskCallbacks, ParallelRunnerOptions, ParallelRunnerMetrics, } from './types';
+export { runQueriesParallel, runExecutesParallel } from './helpers';
+export type { ParallelConfig, HelperResult, RetryPolicy } from './helpers';
+export { AgentRuntime } from './agent-runtime';
+export type { AgentResult, AgentQueryRequest, AgentExecuteRequest } from './agent-runtime';
+//# sourceMappingURL=index.d.ts.map