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

package/dist/esm/parallel/helpers.js

@@ -0,0 +1,214 @@
+import { ParallelRunner } from './parallel-runner';
+import { AgentRuntime } from './agent-runtime';
+const DEFAULT_CONCURRENCY = 3;
+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)) {
+        return DEFAULT_CONCURRENCY;
+    }
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : DEFAULT_CONCURRENCY;
+};
+const normalizeTimeout = (value) => {
+    if (value === undefined)
+        return DEFAULT_TIMEOUT_MS;
+    if (typeof value !== 'number' || Number.isNaN(value) || value <= 0)
+        return DEFAULT_TIMEOUT_MS;
+    return value;
+};
+const normalizeRetryPolicy = (policy) => {
+    if (!policy)
+        return { maxRetries: 0, retryDelay: DEFAULT_RETRY_DELAY_MS };
+    const maxRetries = Number.isInteger(policy.maxRetries) && policy.maxRetries >= 0
+        ? policy.maxRetries
+        : 0;
+    const retryDelay = typeof policy.retryDelay === 'number' && policy.retryDelay >= 0
+        ? policy.retryDelay
+        : DEFAULT_RETRY_DELAY_MS;
+    return { maxRetries, retryDelay };
+};
+const createAbortError = (signal) => {
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        return reason;
+    if (typeof reason === 'string')
+        return new Error(reason);
+    return new Error('Parallel operation aborted');
+};
+const waitForDelay = (delayMs, signal) => {
+    if (delayMs <= 0)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, delayMs);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(createAbortError(signal));
+        };
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+};
+const executeWithRetry = async (execute, retryPolicy, signal) => {
+    let lastFailureResult;
+    let lastError;
+    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)
+                return result;
+        }
+        catch (error) {
+            lastError = error;
+            if (signal.aborted)
+                throw createAbortError(signal);
+            if (attempt === retryPolicy.maxRetries) {
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        if (attempt < retryPolicy.maxRetries) {
+            await waitForDelay(retryPolicy.retryDelay, signal);
+        }
+    }
+    if (lastFailureResult)
+        return lastFailureResult;
+    if (lastError)
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    throw new Error('Parallel helper encountered an unexpected state');
+};
+const recordProgress = (config, state, wasSuccessful) => {
+    state.completed += 1;
+    if (wasSuccessful)
+        state.success += 1;
+    else
+        state.failure += 1;
+    try {
+        config.onProgress?.(state.completed, state.total);
+    }
+    catch (error) {
+        if (process.env['NODE_ENV'] !== 'production') {
+            console.warn('Parallel helper onProgress callback threw an error:', error);
+        }
+    }
+};
+const buildAgentResults = (taskResults) => {
+    const decorated = taskResults.map((taskResult) => ({
+        metadata: taskResult.metadata,
+        taskResult,
+    }));
+    return decorated
+        .slice()
+        .sort((a, b) => a.metadata.index - b.metadata.index)
+        .map(({ metadata, taskResult }) => {
+        if (taskResult.value) {
+            const base = taskResult.value;
+            return {
+                ...base,
+                agentId: base.agentId ?? metadata.request.agentId,
+                metadata: {
+                    ...base.metadata,
+                    requestIndex: metadata.index,
+                    mode: metadata.mode,
+                },
+            };
+        }
+        const error = taskResult.error ?? new Error('Unknown error');
+        return {
+            agentId: metadata.request.agentId,
+            content: error.message,
+            success: false,
+            metadata: {
+                error: error.message,
+                aborted: taskResult.aborted ?? false,
+                requestIndex: metadata.index,
+                mode: metadata.mode,
+            },
+        };
+    });
+};
+const collectErrors = (taskResults) => {
+    return taskResults
+        .filter((r) => !r.success)
+        .map((taskResult) => {
+        const meta = taskResult.metadata;
+        if (taskResult.error instanceof Error) {
+            return { index: meta.index, error: taskResult.error };
+        }
+        if (taskResult.value && !taskResult.value.success) {
+            const msg = String(taskResult.value.metadata?.['error'] ?? taskResult.value.content ?? 'Agent returned unsuccessful result');
+            return { index: meta.index, error: new Error(msg) };
+        }
+        return { index: meta.index, error: new Error('Unknown failure') };
+    });
+};
+const createCallbacks = (progressState, config) => ({
+    onTaskComplete: async (result) => {
+        recordProgress(config, progressState, result.success);
+    },
+    onError: async () => {
+        recordProgress(config, progressState, false);
+    },
+});
+const runAgentOperations = async (requests, mode, config = {}) => {
+    if (!Array.isArray(requests)) {
+        throw new TypeError('Parallel helpers expect an array of requests');
+    }
+    if (requests.length === 0) {
+        const emptyMetrics = {
+            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,
+        };
+        config.onComplete?.(summary);
+        return [];
+    }
+    const concurrency = normalizeConcurrency(config.concurrency);
+    const timeout = normalizeTimeout(config.timeout);
+    const retryPolicy = normalizeRetryPolicy(config.retryPolicy);
+    const runner = new ParallelRunner();
+    const runtime = new AgentRuntime();
+    const tasks = requests.map((request, index) => ({
+        id: `${mode}:${request.agentId ?? 'anonymous'}:${index}`,
+        metadata: { index, mode, request },
+        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 taskResults = await runner.run(tasks, {
+        maxConcurrency: concurrency,
+        timeoutMs: timeout,
+        evaluateTaskSuccess: (value) => value.success,
+        callbacks: createCallbacks(progressState, config),
+    });
+    const agentResults = buildAgentResults(taskResults);
+    const errors = collectErrors(taskResults);
+    const metrics = runner.getMetrics();
+    const summary = {
+        total: requests.length,
+        completed: requests.length,
+        successCount: agentResults.filter((r) => r.success).length,
+        failureCount: agentResults.filter((r) => !r.success).length,
+        results: agentResults,
+        errors,
+        metrics,
+    };
+    config.onComplete?.(summary);
+    return agentResults;
+};
+export const runQueriesParallel = (queries, config) => runAgentOperations(queries, 'query', config);
+export const runExecutesParallel = (requests, config) => runAgentOperations(requests, 'execute', config);
+//# sourceMappingURL=helpers.js.map

package/dist/esm/parallel/index.js

@@ -0,0 +1,5 @@
+export { ParallelRunner } from './parallel-runner';
+export { ParallelRunnerTimeoutError } from './parallel-runner';
+export { runQueriesParallel, runExecutesParallel } from './helpers';
+export { AgentRuntime } from './agent-runtime';
+//# sourceMappingURL=index.js.map

package/dist/esm/parallel/parallel-runner.js

@@ -0,0 +1,221 @@
+import { performance } from 'node:perf_hooks';
+/**
+ * Error raised when a task exceeds the configured per-task timeout.
+ */
+export class ParallelRunnerTimeoutError extends Error {
+    taskId;
+    timeoutMs;
+    constructor(taskId, timeoutMs) {
+        super(`Task ${taskId} timed out after ${timeoutMs}ms`);
+        this.taskId = taskId;
+        this.timeoutMs = timeoutMs;
+        this.name = 'ParallelRunnerTimeoutError';
+    }
+}
+/**
+ * Executes tasks with bounded concurrency and cooperative cancellation support.
+ * Framework-agnostic — usable from CLI, SDK, or any consumer.
+ */
+export class ParallelRunner {
+    defaults;
+    metrics = {
+        totalTasks: 0,
+        startedTasks: 0,
+        completedTasks: 0,
+        successCount: 0,
+        failureCount: 0,
+        totalDurationMs: 0,
+        averageDurationMs: 0,
+        throughput: 0,
+    };
+    constructor(defaults = {}) {
+        this.defaults = defaults;
+    }
+    async run(tasks, options = {}) {
+        if (!Array.isArray(tasks)) {
+            throw new TypeError('ParallelRunner.run expects an array of tasks');
+        }
+        if (tasks.length === 0) {
+            this.metrics = {
+                totalTasks: 0,
+                startedTasks: 0,
+                completedTasks: 0,
+                successCount: 0,
+                failureCount: 0,
+                totalDurationMs: 0,
+                averageDurationMs: 0,
+                throughput: 0,
+            };
+            return [];
+        }
+        const merged = this.mergeOptions(options);
+        const maxConcurrency = Math.max(1, merged.maxConcurrency ?? 5);
+        const timeoutMs = merged.timeoutMs;
+        const failFast = merged.failFast ?? false;
+        const callbacks = merged.callbacks;
+        const evaluateTaskSuccess = merged.evaluateTaskSuccess ?? (() => true);
+        const results = [];
+        let successCount = 0;
+        let failureCount = 0;
+        let startedTasks = 0;
+        let aborted = false;
+        let cursor = 0;
+        const startedAt = performance.now();
+        const executeTask = async (task) => {
+            if (callbacks?.onTaskStart) {
+                await callbacks.onTaskStart(task);
+            }
+            startedTasks += 1;
+            const controller = new AbortController();
+            const context = { signal: controller.signal };
+            let timeoutId;
+            let timeoutPromise;
+            if (typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+                timeoutPromise = new Promise((_, reject) => {
+                    timeoutId = setTimeout(() => {
+                        const err = new ParallelRunnerTimeoutError(task.id, timeoutMs);
+                        controller.abort(err);
+                        reject(err);
+                    }, timeoutMs);
+                });
+            }
+            const taskStartedAt = performance.now();
+            const runPromise = task.run(context);
+            const combinedPromise = timeoutPromise
+                ? Promise.race([runPromise, timeoutPromise])
+                : runPromise;
+            try {
+                const value = await combinedPromise;
+                const taskFinishedAt = performance.now();
+                const durationMs = taskFinishedAt - taskStartedAt;
+                const success = evaluateTaskSuccess(value, task);
+                const result = {
+                    taskId: task.id,
+                    success,
+                    value,
+                    durationMs,
+                    startedAt: taskStartedAt,
+                    finishedAt: taskFinishedAt,
+                    metadata: task.metadata,
+                    aborted: false,
+                };
+                results.push(result);
+                success ? (successCount += 1) : (failureCount += 1);
+                if (callbacks?.onTaskComplete) {
+                    await callbacks.onTaskComplete(result);
+                }
+                if (failFast && !success) {
+                    aborted = true;
+                }
+            }
+            catch (rawError) {
+                const taskFinishedAt = performance.now();
+                const durationMs = taskFinishedAt - taskStartedAt;
+                const error = rawError instanceof Error ? rawError : new Error(String(rawError));
+                const result = {
+                    taskId: task.id,
+                    success: false,
+                    error,
+                    durationMs,
+                    startedAt: taskStartedAt,
+                    finishedAt: taskFinishedAt,
+                    metadata: task.metadata,
+                    aborted: controller.signal.aborted,
+                };
+                results.push(result);
+                failureCount += 1;
+                if (callbacks?.onError) {
+                    await callbacks.onError(task, error, durationMs);
+                }
+                if (failFast) {
+                    aborted = true;
+                }
+            }
+            finally {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                // Prevent unhandled rejections if timeout fired before task finished
+                if (timeoutPromise)
+                    runPromise.catch(() => undefined);
+            }
+        };
+        const worker = async () => {
+            while (true) {
+                if (aborted)
+                    break;
+                const index = cursor;
+                if (index >= tasks.length)
+                    break;
+                cursor += 1;
+                const task = tasks[index];
+                if (!task)
+                    break;
+                await executeTask(task);
+                if (aborted)
+                    break;
+            }
+        };
+        const workerCount = Math.min(maxConcurrency, tasks.length);
+        const workers = [];
+        for (let i = 0; i < workerCount; i++) {
+            workers.push(worker());
+        }
+        await Promise.all(workers);
+        const finishedAt = performance.now();
+        const totalDurationMs = finishedAt - startedAt;
+        const averageDurationMs = results.length
+            ? results.reduce((sum, r) => sum + r.durationMs, 0) / results.length
+            : 0;
+        const throughput = totalDurationMs > 0
+            ? results.length / (totalDurationMs / 1000)
+            : results.length;
+        this.metrics = {
+            totalTasks: tasks.length,
+            startedTasks,
+            completedTasks: results.length,
+            successCount,
+            failureCount,
+            totalDurationMs,
+            averageDurationMs,
+            throughput,
+        };
+        return results;
+    }
+    getMetrics() {
+        return this.metrics;
+    }
+    mergeOptions(options) {
+        return {
+            maxConcurrency: options.maxConcurrency ?? this.defaults.maxConcurrency,
+            timeoutMs: options.timeoutMs ?? this.defaults.timeoutMs,
+            failFast: options.failFast ?? this.defaults.failFast,
+            evaluateTaskSuccess: options.evaluateTaskSuccess ?? this.defaults.evaluateTaskSuccess,
+            callbacks: this.mergeCallbacks(this.defaults.callbacks, options.callbacks),
+        };
+    }
+    mergeCallbacks(base, override) {
+        if (!base && !override)
+            return undefined;
+        return {
+            onTaskStart: async (task) => {
+                if (base?.onTaskStart)
+                    await base.onTaskStart(task);
+                if (override?.onTaskStart)
+                    await override.onTaskStart(task);
+            },
+            onTaskComplete: async (result) => {
+                if (base?.onTaskComplete)
+                    await base.onTaskComplete(result);
+                if (override?.onTaskComplete)
+                    await override.onTaskComplete(result);
+            },
+            onError: async (task, error, durationMs) => {
+                if (base?.onError)
+                    await base.onError(task, error, durationMs);
+                if (override?.onError)
+                    await override.onError(task, error, durationMs);
+            },
+        };
+    }
+}
+//# sourceMappingURL=parallel-runner.js.map

package/dist/esm/parallel/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for the parallel execution module.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/parsers/agent-call.util.js

@@ -0,0 +1,15 @@
+/** Detect crewx execute/x command pattern */
+export function isAgentCallCommand(command) {
+    return /crewx\s+(x|execute)\s/.test(command);
+}
+/** Extract agent_call entry from crewx x "@agent ..." command */
+export function parseAgentCall(timestamp, command) {
+    const agentMatch = command.match(/@(\S+)/);
+    return {
+        timestamp,
+        type: 'agent_call',
+        targetAgent: agentMatch?.[1]?.replace(/["']/g, ''),
+        toolInput: command,
+    };
+}
+//# sourceMappingURL=agent-call.util.js.map

package/dist/esm/parsers/claude.parser.js

@@ -0,0 +1,64 @@
+import { isAgentCallCommand, parseAgentCall } from './agent-call.util';
+/**
+ * Parse Claude stream-json events into TaskLogEntry[].
+ *
+ * Claude events:
+ * - { type: "assistant", message: { content: [{ type: "text"|"tool_use", ... }] } }
+ * - { type: "user", message: { content: [{ type: "tool_result", ... }] } }
+ */
+export function parseClaudeEvent(timestamp, parsed) {
+    const msg = parsed.message;
+    const content = msg?.content;
+    if (!Array.isArray(content))
+        return [];
+    const entries = [];
+    for (const block of content) {
+        const entry = parseClaudeBlock(timestamp, block);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+function parseClaudeBlock(timestamp, block) {
+    const blockType = block.type;
+    if (blockType === 'text') {
+        const text = String(block.text || '');
+        if (!text)
+            return null;
+        return { timestamp, type: 'text', content: text };
+    }
+    if (blockType === 'tool_use') {
+        const toolName = String(block.name || '');
+        const toolUseId = block.id;
+        const input = block.input;
+        const inputStr = input?.command
+            ? String(input.command)
+            : JSON.stringify(input || {});
+        if (toolName === 'Bash' && isAgentCallCommand(inputStr)) {
+            return parseAgentCall(timestamp, inputStr);
+        }
+        return { timestamp, type: 'tool_use', toolUseId, toolName, toolInput: inputStr };
+    }
+    if (blockType === 'tool_result') {
+        const isError = Boolean(block.is_error);
+        const toolUseId = block.tool_use_id;
+        const raw = block.output ?? block.content ?? '';
+        let output;
+        if (typeof raw === 'string') {
+            output = raw;
+        }
+        else if (Array.isArray(raw)) {
+            // Claude tool_result content can be [{ type: "text", text: "..." }, ...]
+            output = raw
+                .filter(c => c.type === 'text' && typeof c.text === 'string')
+                .map(c => c.text)
+                .join('\n');
+        }
+        else {
+            output = JSON.stringify(raw);
+        }
+        return { timestamp, type: 'tool_result', toolUseId, resultPreview: output, isError };
+    }
+    return null;
+}
+//# sourceMappingURL=claude.parser.js.map

package/dist/esm/parsers/codex.parser.js

@@ -0,0 +1,97 @@
+import { isAgentCallCommand, parseAgentCall } from './agent-call.util';
+/**
+ * Parse Codex experimental-json events into TaskLogEntry[].
+ *
+ * Codex events:
+ * - { type: "item.started", item: { type: "command_execution", command } }
+ * - { type: "item.completed", item: { type: "command_execution"|"message"|"text"|"reasoning"|"tool_use"|"tool_result", ... } }
+ */
+export function parseCodexEvent(timestamp, parsed) {
+    const type = parsed.type;
+    const item = parsed.item;
+    if (!item)
+        return [];
+    if (type === 'item.started') {
+        return parseItemStarted(timestamp, item);
+    }
+    if (type === 'item.completed') {
+        const entry = parseItemCompleted(timestamp, item);
+        return entry ? [entry] : [];
+    }
+    return [];
+}
+function parseItemStarted(timestamp, item) {
+    const itemType = item.type;
+    if (itemType === 'command_execution') {
+        const command = String(item.command || '');
+        if (isAgentCallCommand(command)) {
+            return [parseAgentCall(timestamp, command)];
+        }
+        return [{ timestamp, type: 'tool_use', toolName: 'Bash', toolInput: command }];
+    }
+    return [];
+}
+function parseItemCompleted(timestamp, item) {
+    const itemType = item.type;
+    // assistant_message / message / text
+    if (itemType === 'message' || itemType === 'text') {
+        const content = item.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                const entry = parseCodexBlock(timestamp, block);
+                if (entry)
+                    return entry;
+            }
+        }
+        if (typeof item.text === 'string') {
+            return { timestamp, type: 'text', content: item.text };
+        }
+    }
+    if (itemType === 'reasoning') {
+        return { timestamp, type: 'text', content: String(item.text || '') };
+    }
+    // command_execution completed → tool_result (with error support)
+    if (itemType === 'command_execution') {
+        const output = String(item.aggregated_output || item.output || '');
+        const isError = Boolean(item.is_error);
+        return { timestamp, type: 'tool_result', resultPreview: output, isError };
+    }
+    // tool_use from Codex item.completed
+    if (itemType === 'tool_use') {
+        const toolName = String(item.name || item.tool_name || '');
+        const input = item.input;
+        const inputStr = input?.command
+            ? String(input.command)
+            : JSON.stringify(input || {});
+        if (toolName === 'Bash' && isAgentCallCommand(inputStr)) {
+            return parseAgentCall(timestamp, inputStr);
+        }
+        return { timestamp, type: 'tool_use', toolName, toolInput: inputStr };
+    }
+    // tool_result from Codex item.completed
+    if (itemType === 'tool_result') {
+        const isError = Boolean(item.is_error);
+        const output = String(item.output || item.content || '');
+        return { timestamp, type: 'tool_result', resultPreview: output, isError };
+    }
+    return null;
+}
+function parseCodexBlock(timestamp, block) {
+    const blockType = block.type;
+    if (blockType === 'text') {
+        return { timestamp, type: 'text', content: String(block.text || '') };
+    }
+    if (blockType === 'tool_use') {
+        const toolName = String(block.name || '');
+        const input = block.input;
+        const inputStr = input?.command
+            ? String(input.command)
+            : JSON.stringify(input || {});
+        if (toolName === 'Bash' && isAgentCallCommand(inputStr)) {
+            return parseAgentCall(timestamp, inputStr);
+        }
+        return { timestamp, type: 'tool_use', toolName, toolInput: inputStr };
+    }
+    return null;
+}
+//# sourceMappingURL=codex.parser.js.map

package/dist/esm/parsers/copilot.parser.js

@@ -0,0 +1,63 @@
+import { isAgentCallCommand, parseAgentCall } from './agent-call.util';
+/**
+ * Parse Copilot json events into TaskLogEntry[].
+ *
+ * Copilot events:
+ * - { type: "tool.execution_start", data: { toolName, arguments } }
+ * - { type: "tool.execution_complete", data: { result?: { content }, error?: { message } } }
+ * - { type: "assistant.message", data: { content } }
+ */
+export function parseCopilotEvent(timestamp, parsed) {
+    const type = parsed.type;
+    const data = parsed.data;
+    if (!data)
+        return [];
+    const toolCallId = data.toolCallId;
+    if (type === 'tool.execution_start') {
+        const toolName = String(data.toolName || '');
+        const args = data.arguments;
+        const inputStr = args?.command
+            ? String(args.command)
+            : JSON.stringify(args || {});
+        if ((toolName === 'bash' || toolName === 'Bash') &&
+            isAgentCallCommand(inputStr)) {
+            return [parseAgentCall(timestamp, inputStr)];
+        }
+        return [{
+                timestamp,
+                type: 'tool_use',
+                toolName,
+                toolInput: inputStr,
+                ...(toolCallId && { toolUseId: toolCallId }),
+            }];
+    }
+    if (type === 'tool.execution_complete') {
+        const error = data.error;
+        if (error) {
+            return [{
+                    timestamp,
+                    type: 'tool_result',
+                    isError: true,
+                    resultPreview: String(error.message || ''),
+                    ...(toolCallId && { toolUseId: toolCallId }),
+                }];
+        }
+        const result = data.result;
+        const content = String(result?.content || '');
+        return [{
+                timestamp,
+                type: 'tool_result',
+                resultPreview: content,
+                isError: false,
+                ...(toolCallId && { toolUseId: toolCallId }),
+            }];
+    }
+    if (type === 'assistant.message') {
+        const content = String(data.content || '');
+        if (!content)
+            return [];
+        return [{ timestamp, type: 'text', content }];
+    }
+    return [];
+}
+//# sourceMappingURL=copilot.parser.js.map