@crewx/sdk 0.8.0-rc.79 → 0.8.0-rc.80

package/dist/esm/parallel/helpers.js

@@ -1,214 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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

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

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

@@ -1,15 +0,0 @@
-/** 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

@@ -1,64 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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