@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/server/workflows/WorkflowEngine.js

@@ -1,575 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { getEffectivePrerequisites } from '../ToolRouter.policy.js';
-import { getRoutingState } from '../ToolRouter.probe.js';
-class WorkflowDataBus {
-    store = new Map();
-    set(key, value) {
-        this.store.set(key, value);
-    }
-    get(key) {
-        return this.store.get(key);
-    }
-    getValueAtPath(key, path) {
-        const value = this.store.get(key);
-        if (!value || typeof value !== 'object') {
-            return value;
-        }
-        const payload = parseToolPayload(value);
-        const obj = payload || value;
-        return path.split('.').reduce((current, segment) => {
-            if (current && typeof current === 'object') {
-                const arrayMatch = segment.match(/^(\d+)$/);
-                if (arrayMatch && Array.isArray(current)) {
-                    return current[Number(arrayMatch[1])];
-                }
-                return current[segment];
-            }
-            return undefined;
-        }, obj);
-    }
-    resolve(template) {
-        const match = template.match(/^\$\{(.+)\}$/);
-        if (!match || !match[1]) {
-            return template;
-        }
-        const ref = match[1];
-        const dotIndex = ref.indexOf('.');
-        if (dotIndex === -1) {
-            return this.store.get(ref);
-        }
-        const stepId = ref.slice(0, dotIndex);
-        const fieldPath = ref.slice(dotIndex + 1);
-        return this.getValueAtPath(stepId, fieldPath);
-    }
-}
-class PreflightError extends Error {
-    warnings;
-    constructor(warnings) {
-        super(`Workflow preflight failed with ${warnings.length} unsatisfied prerequisite(s)`);
-        this.warnings = warnings;
-        this.name = 'PreflightError';
-    }
-}
-function extractConfigValue(config, path, fallback) {
-    const segments = path.split('.').filter(Boolean);
-    let current = config;
-    for (const segment of segments) {
-        if (!current || typeof current !== 'object')
-            return fallback;
-        current = current[segment];
-    }
-    return current ?? fallback;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withTimeout(promise, timeoutMs, label) {
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-        return promise;
-    }
-    return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
-        promise.then((value) => {
-            clearTimeout(timeoutId);
-            resolve(value);
-        }, (error) => {
-            clearTimeout(timeoutId);
-            reject(error);
-        });
-    });
-}
-function parseToolPayload(response) {
-    if (!response || typeof response !== 'object')
-        return undefined;
-    const toolResponse = response;
-    const text = toolResponse.content?.find((item) => item.type === 'text')?.text;
-    if (typeof text !== 'string')
-        return undefined;
-    try {
-        const parsed = JSON.parse(text);
-        return parsed && typeof parsed === 'object' ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function responseIndicatesFailure(response) {
-    if (!response || typeof response !== 'object')
-        return undefined;
-    const toolResponse = response;
-    if (toolResponse.isError) {
-        return 'Tool returned MCP error response';
-    }
-    const payload = parseToolPayload(response);
-    if (payload?.success === false) {
-        return typeof payload.error === 'string' ? payload.error : 'Tool reported success=false';
-    }
-    return undefined;
-}
-function collectSuccessStats(value) {
-    if (Array.isArray(value)) {
-        return value.reduce((acc, item) => {
-            const next = collectSuccessStats(item);
-            acc.success += next.success;
-            acc.failure += next.failure;
-            return acc;
-        }, { success: 0, failure: 0 });
-    }
-    if (!value || typeof value !== 'object') {
-        return { success: 0, failure: 0 };
-    }
-    const payload = parseToolPayload(value);
-    if (payload?.success === true)
-        return { success: 1, failure: 0 };
-    if (payload?.success === false)
-        return { success: 0, failure: 1 };
-    if ('error' in value) {
-        return { success: 0, failure: 1 };
-    }
-    return { success: 0, failure: 0 };
-}
-function resolveInputFrom(mapping, dataBus) {
-    const resolved = {};
-    for (const [targetKey, sourceRef] of Object.entries(mapping)) {
-        const template = sourceRef.startsWith('${') ? sourceRef : `\${${sourceRef}}`;
-        resolved[targetKey] = dataBus.resolve(template);
-    }
-    return resolved;
-}
-function resolveInputValues(input, dataBus) {
-    if (!input)
-        return {};
-    const resolved = {};
-    for (const [key, value] of Object.entries(input)) {
-        resolved[key] = resolveValue(value, dataBus);
-    }
-    return resolved;
-}
-function resolveValue(value, dataBus) {
-    if (typeof value === 'string') {
-        return dataBus.resolve(value);
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => resolveValue(item, dataBus));
-    }
-    if (value && typeof value === 'object') {
-        const resolved = {};
-        for (const [k, v] of Object.entries(value)) {
-            resolved[k] = resolveValue(v, dataBus);
-        }
-        return resolved;
-    }
-    return value;
-}
-async function runToolNode(ctx, node, overrides, executionContext) {
-    const fromResolved = node.inputFrom
-        ? resolveInputFrom(node.inputFrom, executionContext.dataBus)
-        : {};
-    const fromInputValues = node.input
-        ? resolveInputValues(node.input, executionContext.dataBus)
-        : {};
-    const mergedInput = {
-        ...fromInputValues,
-        ...fromResolved,
-        ...overrides?.[node.id],
-    };
-    const runAttempt = async () => {
-        const response = await withTimeout(ctx.executeToolWithTracking(node.toolName, mergedInput), node.timeoutMs ?? 0, `Workflow tool node "${node.id}"`);
-        const failure = responseIndicatesFailure(response);
-        if (failure) {
-            throw new Error(failure);
-        }
-        executionContext.dataBus.set(node.id, response);
-        return response;
-    };
-    const retry = node.retry;
-    if (!retry) {
-        return runAttempt();
-    }
-    let attempt = 0;
-    let backoffMs = retry.backoffMs;
-    while (attempt < retry.maxAttempts) {
-        try {
-            return await runAttempt();
-        }
-        catch (error) {
-            attempt += 1;
-            if (attempt >= retry.maxAttempts) {
-                throw error;
-            }
-            await sleep(backoffMs);
-            backoffMs = Math.max(0, Math.floor(backoffMs * (retry.multiplier ?? 1)));
-        }
-    }
-    throw new Error(`Workflow tool node "${node.id}" exhausted retries`);
-}
-async function runParallelNode(ctx, node, executionContext, options) {
-    const concurrency = Math.max(1, node.maxConcurrency ?? 4);
-    const results = Array.from({ length: node.steps.length });
-    let nextIndex = 0;
-    let stopped = false;
-    const worker = async () => {
-        while (true) {
-            if (stopped)
-                return;
-            const currentIndex = nextIndex;
-            nextIndex += 1;
-            if (currentIndex >= node.steps.length)
-                return;
-            const step = node.steps[currentIndex];
-            if (!step)
-                return;
-            try {
-                results[currentIndex] = await executeNode(ctx, step, executionContext, options);
-            }
-            catch (error) {
-                if (node.failFast) {
-                    stopped = true;
-                    throw error;
-                }
-                results[currentIndex] = {
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
-    };
-    await Promise.all(Array.from({ length: Math.min(concurrency, node.steps.length) }, () => worker()));
-    return results;
-}
-function getWorkflowVariable(stepResults, keyPath) {
-    if (stepResults.has(keyPath)) {
-        return stepResults.get(keyPath);
-    }
-    const segments = keyPath.split('.');
-    const stepId = segments[0];
-    const fieldSegments = segments.slice(1);
-    if (!stepId || !stepResults.has(stepId)) {
-        return undefined;
-    }
-    let current = stepResults.get(stepId);
-    if (current && typeof current === 'object') {
-        const payload = parseToolPayload(current);
-        if (payload) {
-            current = payload;
-        }
-    }
-    for (const segment of fieldSegments) {
-        if (current && typeof current === 'object') {
-            const arrayMatch = segment.match(/^(\d+)$/);
-            if (arrayMatch && Array.isArray(current)) {
-                current = current[Number(arrayMatch[1])];
-                continue;
-            }
-            current = current[segment];
-        }
-        else {
-            return undefined;
-        }
-    }
-    return current;
-}
-async function evaluatePredicate(node, ctx) {
-    if (node.predicateFn) {
-        return await node.predicateFn(ctx);
-    }
-    if (node.predicateId === 'always_true')
-        return true;
-    if (node.predicateId === 'always_false')
-        return false;
-    if (node.predicateId === 'any_step_failed') {
-        return [...ctx.stepResults.values()].some((value) => collectSuccessStats(value).failure > 0);
-    }
-    const successRateMatch = node.predicateId.match(/success_rate_gte_(\d+)/i);
-    if (successRateMatch) {
-        const threshold = Number(successRateMatch[1]);
-        const aggregate = [...ctx.stepResults.values()].reduce((acc, value) => {
-            const next = collectSuccessStats(value);
-            acc.success += next.success;
-            acc.failure += next.failure;
-            return acc;
-        }, { success: 0, failure: 0 });
-        const total = aggregate.success + aggregate.failure;
-        if (total === 0)
-            return false;
-        return aggregate.success / total >= threshold / 100;
-    }
-    const equalsMatch = node.predicateId.match(/^variable_equals_(.+?)_(.+)$/);
-    if (equalsMatch && equalsMatch[1] && equalsMatch[2]) {
-        const keyPath = equalsMatch[1];
-        const expectedValue = equalsMatch[2];
-        const actualValue = getWorkflowVariable(ctx.stepResults, keyPath);
-        return deepEquals(actualValue, expectedValue);
-    }
-    const containsMatch = node.predicateId.match(/^variable_contains_(.+?)_(.+)$/);
-    if (containsMatch && containsMatch[1] && containsMatch[2]) {
-        const keyPath = containsMatch[1];
-        const substring = containsMatch[2];
-        const value = getWorkflowVariable(ctx.stepResults, keyPath);
-        if (typeof value !== 'string' && !Array.isArray(value)) {
-            return false;
-        }
-        return String(value).includes(substring);
-    }
-    const matchesMatch = node.predicateId.match(/^variable_matches_(.+?)_(.+)$/);
-    if (matchesMatch && matchesMatch[1] && matchesMatch[2]) {
-        const keyPath = matchesMatch[1];
-        const pattern = matchesMatch[2];
-        const value = getWorkflowVariable(ctx.stepResults, keyPath);
-        if (typeof value !== 'string') {
-            return false;
-        }
-        try {
-            const regex = new RegExp(pattern);
-            return regex.test(value);
-        }
-        catch {
-            return false;
-        }
-    }
-    throw new Error(`Unknown workflow predicateId "${node.predicateId}"`);
-}
-function deepEquals(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (typeof a !== typeof b) {
-        return false;
-    }
-    if (a && b && typeof a === 'object' && typeof b === 'object') {
-        if (Array.isArray(a) !== Array.isArray(b)) {
-            return false;
-        }
-        if (Array.isArray(a)) {
-            const arrA = a;
-            const arrB = b;
-            return arrA.length === arrB.length && arrA.every((v, i) => deepEquals(v, arrB[i]));
-        }
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
-        if (keysA.length !== keysB.length) {
-            return false;
-        }
-        return keysA.every((key) => deepEquals(a[key], b[key]));
-    }
-    return false;
-}
-async function executeNode(ctx, node, executionContext, options) {
-    executionContext.emitSpan('workflow.node.start', { nodeId: node.id, kind: node.kind });
-    let result;
-    switch (node.kind) {
-        case 'tool':
-            result = await runToolNode(ctx, node, options.nodeInputOverrides, executionContext);
-            break;
-        case 'sequence': {
-            const sequenceNode = node;
-            const items = [];
-            for (const step of sequenceNode.steps) {
-                items.push(await executeNode(ctx, step, executionContext, options));
-            }
-            result = items;
-            break;
-        }
-        case 'parallel':
-            result = await runParallelNode(ctx, node, executionContext, options);
-            break;
-        case 'branch': {
-            const branchNode = node;
-            const predicate = await evaluatePredicate(branchNode, executionContext);
-            const selected = predicate ? branchNode.whenTrue : branchNode.whenFalse;
-            if (selected) {
-                result = await executeNode(ctx, selected, executionContext, options);
-            }
-            else {
-                result = undefined;
-            }
-            break;
-        }
-        case 'fallback': {
-            const fallbackNode = node;
-            try {
-                result = await executeNode(ctx, fallbackNode.primary, executionContext, options);
-            }
-            catch (error) {
-                executionContext.emitSpan('workflow.node.fallback', {
-                    nodeId: fallbackNode.id,
-                    primaryNodeId: fallbackNode.primary.id,
-                    fallbackNodeId: fallbackNode.fallback.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                result = await executeNode(ctx, fallbackNode.fallback, executionContext, options);
-            }
-            break;
-        }
-        default:
-            throw new Error(`Unsupported workflow node kind: ${node.kind}`);
-    }
-    executionContext.stepResults.set(node.id, result);
-    executionContext.emitSpan('workflow.node.finish', { nodeId: node.id, kind: node.kind });
-    return result;
-}
-function collectToolNodes(node) {
-    switch (node.kind) {
-        case 'tool':
-            return [node];
-        case 'sequence':
-        case 'parallel':
-            return node.steps.flatMap((step) => collectToolNodes(step));
-        case 'branch':
-            return [
-                ...collectToolNodes(node.whenTrue),
-                ...(node.whenFalse ? collectToolNodes(node.whenFalse) : []),
-            ];
-        case 'fallback': {
-            const fallbackNode = node;
-            return [
-                ...collectToolNodes(fallbackNode.primary),
-                ...collectToolNodes(fallbackNode.fallback),
-            ];
-        }
-        default:
-            return [];
-    }
-}
-function getEvidenceState(ctx) {
-    try {
-        const evidenceGraph = ctx.getDomainInstance('evidenceGraph');
-        return evidenceGraph
-            ? { hasGraph: true, nodeCount: evidenceGraph.nodeCount, edgeCount: evidenceGraph.edgeCount }
-            : { hasGraph: false, nodeCount: 0, edgeCount: 0 };
-    }
-    catch {
-        return { hasGraph: false, nodeCount: 0, edgeCount: 0 };
-    }
-}
-function collectUnsatisfiedPrerequisites(graph, routingState) {
-    const prerequisites = getEffectivePrerequisites();
-    const warnings = [];
-    for (const toolNode of collectToolNodes(graph)) {
-        const toolPrerequisites = prerequisites[toolNode.toolName] ?? [];
-        for (const prerequisite of toolPrerequisites) {
-            if (prerequisite.check(routingState)) {
-                continue;
-            }
-            warnings.push({
-                nodeId: toolNode.id,
-                toolName: toolNode.toolName,
-                condition: prerequisite.condition,
-                fix: prerequisite.fix,
-            });
-        }
-    }
-    return warnings;
-}
-export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
-    const runId = randomUUID();
-    const profile = options.profile ?? String(ctx.baseTier ?? 'workflow');
-    const startedAt = new Date().toISOString();
-    const startedAtMs = Date.now();
-    const metrics = [];
-    const spans = [];
-    const stepResults = new Map();
-    const dataBus = new WorkflowDataBus();
-    const mergedConfig = options.config
-        ? { ...ctx.config, ...options.config }
-        : ctx.config;
-    const executionContext = {
-        workflowRunId: runId,
-        profile,
-        stepResults,
-        dataBus,
-        invokeTool(toolName, args) {
-            return ctx.executeToolWithTracking(toolName, args);
-        },
-        emitSpan(name, attrs) {
-            spans.push({ name, attrs, at: new Date().toISOString() });
-        },
-        emitMetric(name, value, type, attrs) {
-            metrics.push({ name, value, type, attrs, at: new Date().toISOString() });
-        },
-        getConfig(path, fallback) {
-            return extractConfigValue(mergedConfig, path, fallback);
-        },
-    };
-    try {
-        await workflow.onStart?.(executionContext);
-        const graph = workflow.build(executionContext);
-        const preflightMode = options.preflightMode ?? 'warn';
-        let preflightWarnings = [];
-        if (preflightMode === 'skip') {
-            executionContext.emitSpan('workflow.preflight', {
-                mode: preflightMode,
-                skipped: true,
-                evidenceState: getEvidenceState(ctx),
-                warningCount: 0,
-            });
-        }
-        else {
-            try {
-                const routingState = await getRoutingState(ctx);
-                const evidenceState = getEvidenceState(ctx);
-                preflightWarnings = collectUnsatisfiedPrerequisites(graph, routingState);
-                executionContext.emitSpan('workflow.preflight', {
-                    mode: preflightMode,
-                    routingState,
-                    evidenceState,
-                    warningCount: preflightWarnings.length,
-                    warnings: preflightWarnings,
-                });
-                if (preflightMode === 'strict' && preflightWarnings.length > 0) {
-                    throw new PreflightError(preflightWarnings);
-                }
-            }
-            catch (error) {
-                if (error instanceof PreflightError) {
-                    throw error;
-                }
-                executionContext.emitSpan('workflow.preflight', {
-                    mode: preflightMode,
-                    warningCount: 0,
-                    skipped: true,
-                    error: error instanceof Error ? error.message : String(error),
-                    evidenceState: getEvidenceState(ctx),
-                });
-            }
-        }
-        const result = await withTimeout(executeNode(ctx, graph, executionContext, options), options.timeoutMs ?? workflow.timeoutMs ?? 0, `Workflow "${workflow.id}"`);
-        await workflow.onFinish?.(executionContext, result);
-        try {
-            const evidenceGraph = typeof ctx.getDomainInstance === 'function'
-                ? ctx.getDomainInstance('evidenceGraph')
-                : undefined;
-            if (evidenceGraph && evidenceGraph.nodeCount > 0) {
-                stepResults.set('__evidenceSnapshot', evidenceGraph.exportJson());
-                executionContext.emitSpan('workflow.evidence.auto-export', {
-                    nodeCount: evidenceGraph.nodeCount,
-                    edgeCount: evidenceGraph.edgeCount,
-                });
-            }
-        }
-        catch (exportError) {
-            executionContext.emitSpan('workflow.evidence.auto-export', {
-                skipped: true,
-                error: exportError instanceof Error ? exportError.message : String(exportError),
-            });
-        }
-        return {
-            workflowId: workflow.id,
-            displayName: workflow.displayName,
-            runId,
-            profile,
-            startedAt,
-            finishedAt: new Date().toISOString(),
-            durationMs: Date.now() - startedAtMs,
-            result,
-            stepResults: Object.fromEntries(stepResults.entries()),
-            metrics,
-            spans,
-        };
-    }
-    catch (error) {
-        const workflowError = error instanceof Error ? error : new Error(String(error));
-        await workflow.onError?.(executionContext, workflowError);
-        throw workflowError;
-    }
-}

package/dist/src/server/workflows/examples/batch-register.workflow.d.ts

@@ -1,2 +0,0 @@
-declare const batchRegisterWorkflow: import("../../workflows/WorkflowContract.js").WorkflowContract;
-export default batchRegisterWorkflow;

package/dist/src/server/workflows/examples/batch-register.workflow.js

@@ -1,67 +0,0 @@
-import { createWorkflow, ToolNodeBuilder, SequenceNodeBuilder, } from '../../workflows/WorkflowContract.js';
-const batchRegisterWorkflow = createWorkflow('workflow.batch-register.v1', 'Batch Register Accounts')
-    .description('Run register_account_flow for multiple accounts with concurrency controls, ' +
-    'retry policies, and success rate gating.')
-    .tags(['workflow', 'registration', 'batch', 'automation'])
-    .timeoutMs(15 * 60_000)
-    .defaultMaxConcurrency(3)
-    .buildGraph((ctx) => {
-    const maxConcurrency = ctx.getConfig('workflows.batchRegister.maxConcurrency', 3);
-    return new SequenceNodeBuilder('batch-register-root')
-        .tool('precheck', 'web_api_capture_session', (t) => t.input({
-        url: 'about:blank',
-        exportHar: false,
-        exportReport: false,
-    }))
-        .parallel('register-parallel', (p) => p
-        .maxConcurrency(maxConcurrency)
-        .failFast(false)
-        .tool('register-account-1', 'register_account_flow', (t) => t
-        .input({
-        registerUrl: 'https://example.com/register',
-        fields: {
-            username: 'user1',
-            email: 'user1@temp.mail',
-            password: '{{PLACEHOLDER}}',
-        },
-    })
-        .retry({ maxAttempts: 2, backoffMs: 1000, multiplier: 2 }))
-        .tool('register-account-2', 'register_account_flow', (t) => t
-        .input({
-        registerUrl: 'https://example.com/register',
-        fields: {
-            username: 'user2',
-            email: 'user2@temp.mail',
-            password: '{{PLACEHOLDER}}',
-        },
-    })
-        .retry({ maxAttempts: 2, backoffMs: 1000, multiplier: 2 })))
-        .branch('summary-branch', 'batch_success_rate_gte_80', (b) => b
-        .predicateFn((_ctx) => true)
-        .whenTrue(new ToolNodeBuilder('success-summary', 'console_execute').input({
-        expression: '({ status: "batch_complete", successRate: ">=80%" })',
-    }))
-        .whenFalse(new ToolNodeBuilder('failure-summary', 'console_execute').input({
-        expression: '({ status: "needs_retry", successRate: "<80%", suggestion: "Check captcha provider or increase timeout" })',
-    })));
-})
-    .onStart((ctx) => {
-    ctx.emitMetric('workflow_runs_total', 1, 'counter', {
-        workflowId: 'workflow.batch-register.v1',
-        stage: 'start',
-    });
-})
-    .onFinish((ctx) => {
-    ctx.emitMetric('workflow_runs_total', 1, 'counter', {
-        workflowId: 'workflow.batch-register.v1',
-        stage: 'finish',
-    });
-})
-    .onError((ctx, error) => {
-    ctx.emitMetric('workflow_errors_total', 1, 'counter', {
-        workflowId: 'workflow.batch-register.v1',
-        error: error.name,
-    });
-})
-    .build();
-export default batchRegisterWorkflow;