open-multi-agent-kit 0.80.8 → 0.90.3

package/dist/core/automation/index.js

@@ -0,0 +1,665 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+export const AUTOPILOT_MAX = {
+    id: "autopilot-max",
+    humanPromptBudget: { maxPromptsPerTask: 0, maxPromptRate: 0 },
+    capabilities: [
+        "fs.read",
+        "fs.write",
+        "process.exec",
+        "network.read",
+        "network.write",
+        "browser.observe",
+        "browser.mutate",
+        "browser.credentialed",
+        "mcp.call",
+        "extension.run",
+        "api.call",
+        "secrets.resolve",
+        "subagent.spawn",
+    ],
+    env: {
+        mode: "passthrough-audited",
+        allowPatterns: ["*"],
+        denyPatterns: [],
+        redactPatterns: [
+            "*KEY*",
+            "*TOKEN*",
+            "*SECRET*",
+            "*PASSWORD*",
+            "AWS_*",
+            "GCP_*",
+            "AZURE_*",
+            "OPENAI_*",
+            "ANTHROPIC_*",
+            "GITHUB_*",
+            "NPM_*",
+        ],
+        exposeToModel: false,
+    },
+    api: {
+        allowOrigins: ["*"],
+        allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+        mutationDefault: "auto",
+        requireIdempotencyForMethods: ["POST", "PUT", "PATCH", "DELETE"],
+    },
+    browser: {
+        persistentProfile: true,
+        credentialedSessions: true,
+        autoSubmit: true,
+        autoDownload: true,
+        maxUnknownOutcomeReconciliations: 5,
+    },
+    verification: {
+        minVerifiabilityByRisk: { R0: 0.1, R1: 0.25, R2: 0.45, R3: 0.65 },
+        requireEvidenceByRisk: { R0: false, R1: true, R2: true, R3: true },
+        requirePostconditionsByRisk: { R0: false, R1: true, R2: true, R3: true },
+    },
+    recovery: {
+        autoRetry: true,
+        autoRollback: true,
+        autoCompensate: true,
+        duplicateMutationSuppression: true,
+    },
+    budgets: {
+        maxWallClockMs: 30 * 60 * 1000,
+        maxToolCalls: 500,
+        maxBrowserActions: 250,
+        maxNetworkCalls: 1000,
+        maxCostUsd: 10,
+        riskBudget: { R0: 10000, R1: 2000, R2: 500, R3: 100 },
+    },
+};
+export class EnvBroker {
+    processEnv;
+    ledger;
+    constructor(args) {
+        this.processEnv = args.processEnv;
+        this.ledger = args.ledger;
+    }
+    async createChildEnv(req) {
+        const selected = this.collect(req).filter((record) => this.isAllowed(record, req));
+        const childEnv = {};
+        for (const record of selected) {
+            childEnv[record.key] = record.value;
+            await this.ledger.append({
+                actionId: req.actionId,
+                toolId: req.toolId,
+                key: record.key,
+                sensitivity: record.sensitivity,
+                fingerprint: record.fingerprint,
+                purpose: req.purpose,
+                passedToProcess: true,
+                exposedToModel: false,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        return childEnv;
+    }
+    redactEnvForModel(env) {
+        const out = {};
+        for (const [key, value] of Object.entries(env)) {
+            const sensitivity = classifyEnvKey(key, value);
+            out[key] = sensitivity === "public" ? value : `[REDACTED:${sha256(value).slice(0, 12)}]`;
+        }
+        return out;
+    }
+    collect(req) {
+        const records = [];
+        for (const [key, value] of Object.entries(this.processEnv)) {
+            if (typeof value !== "string")
+                continue;
+            records.push({
+                key,
+                value,
+                sensitivity: classifyEnvKey(key, value),
+                source: "process",
+                fingerprint: sha256(value),
+            });
+        }
+        for (const [key, value] of Object.entries(req.extraEnv ?? {})) {
+            records.push({
+                key,
+                value,
+                sensitivity: classifyEnvKey(key, value),
+                source: "tool",
+                fingerprint: sha256(value),
+            });
+        }
+        return records;
+    }
+    isAllowed(record, req) {
+        if (req.profile.env.mode === "passthrough-full")
+            return true;
+        if (req.profile.env.mode === "secret-ref-only" && record.sensitivity !== "public")
+            return false;
+        const allowedByPattern = matchesAny(record.key, req.profile.env.allowPatterns);
+        const deniedByPattern = matchesAny(record.key, req.profile.env.denyPatterns);
+        if (deniedByPattern || !allowedByPattern)
+            return false;
+        if (req.requestedKeys?.includes(record.key))
+            return true;
+        if (req.requestedPatterns?.some((pattern) => globMatch(record.key, pattern)))
+            return true;
+        return req.profile.env.allowPatterns.includes("*");
+    }
+}
+export class EvidenceLedger {
+    sessionId;
+    taskId;
+    events = [];
+    previousHash = "genesis";
+    constructor(args) {
+        this.sessionId = args.sessionId;
+        this.taskId = args.taskId;
+    }
+    async append(event) {
+        const fullWithoutHash = {
+            ...event,
+            sequence: this.events.length + 1,
+            previousHash: this.previousHash,
+            timestamp: new Date().toISOString(),
+            sessionId: this.sessionId,
+            taskId: this.taskId,
+        };
+        const eventHash = canonicalHash(fullWithoutHash);
+        const full = { ...fullWithoutHash, eventHash };
+        this.events.push(full);
+        this.previousHash = eventHash;
+        return full;
+    }
+    snapshot() {
+        return this.events.map((event) => ({ ...event }));
+    }
+}
+export class PostconditionVerifier {
+    async verify(conditions, ctx) {
+        if (conditions.length === 0) {
+            return { pass: false, confidence: 0, evidencePointers: [], failures: ["no postconditions"] };
+        }
+        const results = [];
+        for (const condition of conditions) {
+            results.push(await this.verifyOne(condition, ctx));
+        }
+        return {
+            pass: results.every((result) => result.pass),
+            confidence: Math.min(...results.map((result) => result.confidence)),
+            evidencePointers: results.flatMap((result) => result.evidencePointers),
+            failures: results.flatMap((result) => result.failures),
+            receiptId: results.find((result) => result.receiptId)?.receiptId,
+        };
+    }
+    async verifyOne(condition, ctx) {
+        switch (condition.kind) {
+            case "api-status":
+                return booleanResult(ctx.apiStatus === condition.status, "api-status", `status ${condition.status}`);
+            case "api-json": {
+                const actual = readJsonPath(ctx.apiBody, condition.jsonPath);
+                return booleanResult(deepEqual(actual, condition.expected), "api-json", condition.jsonPath);
+            }
+            case "text": {
+                const text = ctx.text ?? "";
+                const pass = condition.exact !== undefined
+                    ? text.includes(condition.exact)
+                    : condition.pattern !== undefined && new RegExp(condition.pattern).test(text);
+                return booleanResult(pass, "text", condition.exact ?? condition.pattern ?? "<missing>");
+            }
+            case "url": {
+                const currentUrl = ctx.currentUrl;
+                if (typeof currentUrl !== "string") {
+                    return booleanResult(false, "url", "<missing>");
+                }
+                const parsedUrl = new URL(currentUrl);
+                let pass = true;
+                if (condition.origin)
+                    pass = parsedUrl.origin === condition.origin;
+                if (pass && condition.path)
+                    pass = parsedUrl.pathname === condition.path;
+                if (pass && condition.pattern)
+                    pass = new RegExp(condition.pattern).test(currentUrl);
+                return booleanResult(pass, "url", currentUrl ?? "<missing>");
+            }
+            case "file-exists":
+                return verifyFile(condition.path, condition.sha256, "file-exists");
+            case "download":
+                return verifyFile(condition.path, condition.sha256, "download");
+            case "receipt": {
+                const receiptId = ctx.receiptId;
+                const pass = typeof receiptId === "string" && new RegExp(condition.idPattern).test(receiptId);
+                return { ...booleanResult(pass, "receipt", receiptId ?? "<missing>"), receiptId };
+            }
+            case "database": {
+                const actualHash = ctx.databaseHashes?.[condition.queryId];
+                return booleanResult(actualHash === condition.expectedHash, "database", condition.queryId);
+            }
+            case "element-visible": {
+                const pass = (ctx.elements ?? []).some((element) => element.visible === true &&
+                    (condition.ref === undefined || element.ref === condition.ref) &&
+                    (condition.role === undefined || element.role === condition.role) &&
+                    (condition.name === undefined || element.name === condition.name));
+                return booleanResult(pass, "element-visible", condition.ref ?? condition.role ?? condition.name ?? "<any>");
+            }
+            case "element-value": {
+                const pass = (ctx.elements ?? []).some((element) => element.ref === condition.ref && element.value === condition.expected);
+                return booleanResult(pass, "element-value", condition.ref);
+            }
+        }
+    }
+}
+export class ApiBroker {
+    ledger;
+    verifier;
+    fetcher;
+    constructor(args) {
+        this.ledger = args.ledger;
+        this.verifier = args.verifier;
+        this.fetcher = args.fetcher ?? defaultFetcher;
+    }
+    async execute(action, ctx = {}) {
+        const idempotencyKey = action.idempotencyKey ?? deriveIdempotencyKey(action);
+        const headers = { ...action.headers, "Idempotency-Key": idempotencyKey, "X-OMK-Action-Id": action.actionId };
+        await this.ledger.append({
+            actor: "api",
+            kind: "api.dispatch.planned",
+            actionId: action.actionId,
+            inputHash: canonicalHash({ method: action.method, url: action.url, headers, body: action.body }),
+            outcome: "planned",
+        });
+        let response;
+        try {
+            response = await this.fetcher(action.url, {
+                method: action.method,
+                headers,
+                body: action.body === undefined ? undefined : JSON.stringify(action.body),
+                signal: ctx.signal,
+            });
+        }
+        catch {
+            return this.reconcileUnknown(action, idempotencyKey, ctx.profile ?? AUTOPILOT_MAX);
+        }
+        const rawBody = await safeReadJsonOrText(response);
+        const redactedBody = redactForModel(rawBody);
+        await this.ledger.append({
+            actor: "api",
+            kind: "api.response",
+            actionId: action.actionId,
+            outputHash: canonicalHash(rawBody),
+            redactedOutputHash: canonicalHash(redactedBody),
+            outcome: "executed",
+        });
+        const verification = await this.verifier.verify(action.expectedPostconditions, {
+            apiStatus: response.status,
+            apiBody: rawBody,
+            receiptId: readReceiptId(rawBody),
+        });
+        if (!verification.pass) {
+            return {
+                kind: "succeeded_unverified",
+                status: response.status,
+                bodyHash: canonicalHash(rawBody),
+                redactedBody,
+            };
+        }
+        return {
+            kind: "succeeded",
+            status: response.status,
+            bodyHash: canonicalHash(rawBody),
+            receiptId: verification.receiptId,
+            redactedBody,
+        };
+    }
+    async reconcileUnknown(action, idempotencyKey, profile) {
+        for (let attempt = 0; attempt < profile.browser.maxUnknownOutcomeReconciliations; attempt++) {
+            const verification = await this.verifier.verify(action.expectedPostconditions, { receiptId: idempotencyKey });
+            if (verification.pass) {
+                await this.ledger.append({
+                    actor: "recovery",
+                    kind: "api.unknown.reconciled",
+                    actionId: action.actionId,
+                    outcome: "reconciled",
+                });
+                return { kind: "succeeded", receiptId: verification.receiptId };
+            }
+        }
+        await this.ledger.append({
+            actor: "recovery",
+            kind: "api.unknown.unresolved",
+            actionId: action.actionId,
+            outcome: "unknown_after_dispatch",
+        });
+        return { kind: "unknown_after_dispatch" };
+    }
+}
+export function strategyForRisk(risk) {
+    if (risk === "R0") {
+        return {
+            execute: true,
+            requirePostcondition: false,
+            requireIdempotency: false,
+            recovery: "retry",
+            evidenceDepth: "minimal",
+        };
+    }
+    if (risk === "R1") {
+        return {
+            execute: true,
+            requirePostcondition: true,
+            requireIdempotency: false,
+            recovery: "retry",
+            evidenceDepth: "normal",
+        };
+    }
+    if (risk === "R2") {
+        return {
+            execute: true,
+            requirePostcondition: true,
+            requireIdempotency: true,
+            recovery: "repair",
+            evidenceDepth: "deep",
+        };
+    }
+    return {
+        execute: true,
+        requirePostcondition: true,
+        requireIdempotency: true,
+        recovery: "reconcile-and-compensate",
+        evidenceDepth: "forensic",
+    };
+}
+export class DynamicToolPortfolioOptimizer {
+    rank(candidates, need) {
+        return candidates
+            .filter((candidate) => candidate.enabled && candidate.capability === need.requiredCapability)
+            .map((candidate) => this.scoreCandidate(candidate, need))
+            .sort((left, right) => right.score - left.score);
+    }
+    scoreCandidate(candidate, need) {
+        const strategy = strategyForRisk(need.risk);
+        const contextMatch = need.contextFingerprint === undefined || candidate.contextFingerprint === need.contextFingerprint ? 1 : 0;
+        const idempotency = !strategy.requireIdempotency || candidate.supportsIdempotency ? 1 : 0;
+        const latency = Math.max(0, 1 - candidate.avgLatencyMs / 30000);
+        const cost = Math.max(0, 1 - candidate.costUsd / Math.max(1, AUTOPILOT_MAX.budgets.maxCostUsd));
+        const postconditionCoverage = need.requiredPostconditions.length > 0 ? candidate.verificationStrength : 1;
+        const score = 0.32 * candidate.reliability +
+            0.26 * postconditionCoverage +
+            0.16 * idempotency +
+            0.12 * contextMatch +
+            0.08 * latency +
+            0.06 * cost;
+        return {
+            candidate,
+            score: Number(score.toFixed(4)),
+            strategy,
+            reasons: [
+                `reliability=${candidate.reliability}`,
+                `verification=${postconditionCoverage}`,
+                `idempotency=${idempotency}`,
+                `context=${contextMatch}`,
+            ],
+        };
+    }
+}
+export class ToolExecutionBroker {
+    ledger;
+    profile;
+    optimizer;
+    constructor(args) {
+        this.ledger = args.ledger;
+        this.profile = args.profile ?? AUTOPILOT_MAX;
+        this.optimizer = args.optimizer ?? new DynamicToolPortfolioOptimizer();
+    }
+    async select(need, candidates) {
+        const choices = this.optimizer.rank(candidates, need);
+        const choice = choices[0];
+        if (choice === undefined) {
+            throw new Error(`No enabled tool candidate for ${need.requiredCapability}`);
+        }
+        await this.ledger.append({
+            actor: "tool",
+            kind: "tool.execution.planned",
+            actionId: need.actionId,
+            inputHash: canonicalHash(need),
+            policyHash: canonicalHash(this.profile),
+            schemaHash: choice.candidate.schemaHash,
+            outcome: "planned",
+        });
+        return choice;
+    }
+    async recordResult(choice, result) {
+        return this.ledger.append({
+            actor: "tool",
+            kind: "tool.execution.result",
+            actionId: choice.candidate.toolId,
+            outputHash: canonicalHash(result),
+            schemaHash: choice.candidate.schemaHash,
+            outcome: result.pass ? "verified" : "unknown_after_dispatch",
+        });
+    }
+}
+export class AutomationHarnessScorer {
+    score(input) {
+        const verifiedSuccess = this.verifiedSuccess(input);
+        const autonomy = 1 - input.trace.humanPrompts / Math.max(1, input.trace.actions.length);
+        const toolUse = this.toolUseScore(input.trace);
+        const browserUse = this.browserUseScore(input.trace);
+        const envApi = this.envApiScore(input.trace);
+        const recovery = this.recoveryScore(input.trace);
+        const determinism = input.trace.replayMatches ? 1 : 0;
+        const context = this.contextScore(input.trace);
+        const critical = input.trace.secretLeaks > 0 ||
+            input.trace.duplicateIrreversibleMutations > 0 ||
+            (input.requiredPostconditions.length > 0 && verifiedSuccess < 1) ||
+            !input.trace.replayMatches ||
+            input.trace.unledgeredEnvUses > 0 ||
+            input.trace.envApiUses.some((use) => !use.ledgered) ||
+            input.trace.actions.some((action) => action.schemaHashMatched === false ||
+                (action.kind === "browser" && action.targetFingerprintMatched === false));
+        const raw = 20 * verifiedSuccess +
+            15 * autonomy +
+            15 * toolUse +
+            15 * browserUse +
+            10 * envApi +
+            10 * recovery +
+            10 * determinism +
+            5 * context;
+        return {
+            score: critical ? Math.min(79, raw) : raw,
+            verifiedSuccess: verifiedSuccess >= 0.93,
+            envApiUseCorrectness: envApi,
+            duplicateMutations: input.trace.duplicateIrreversibleMutations,
+            secretLeaks: input.trace.secretLeaks,
+            critical,
+        };
+    }
+    verifiedSuccess(input) {
+        const passed = input.requiredPostconditions.filter((condition) => input.trace.verifications.some((verification) => verification.conditionHash === canonicalHash(condition) && verification.pass));
+        return passed.length / Math.max(1, input.requiredPostconditions.length);
+    }
+    toolUseScore(trace) {
+        const calls = trace.actions.filter((action) => action.kind === "tool");
+        if (calls.length === 0)
+            return 1;
+        const verified = calls.filter((action) => action.verificationPass).length;
+        const schemaStable = calls.filter((action) => action.schemaHashMatched === true).length;
+        const envLedgered = calls.filter((action) => action.envUseLedgered === true).length;
+        return (verified + schemaStable + envLedgered) / (3 * calls.length);
+    }
+    browserUseScore(trace) {
+        const actions = trace.actions.filter((action) => action.kind === "browser");
+        if (actions.length === 0)
+            return 1;
+        const verified = actions.filter((action) => action.verificationPass).length;
+        const targetStable = actions.filter((action) => action.targetFingerprintMatched === true).length;
+        const unknownResolved = actions.filter((action) => action.outcome !== "unknown_after_dispatch" || action.reconciled === true).length;
+        return (verified + targetStable + unknownResolved) / (3 * actions.length);
+    }
+    envApiScore(trace) {
+        if (trace.envApiUses.length === 0)
+            return 1;
+        const ledgered = trace.envApiUses.filter((use) => use.ledgered).length;
+        const notLeaked = trace.envApiUses.filter((use) => !use.exposedToModel && !use.exposedToLogs).length;
+        return (ledgered + notLeaked) / (2 * trace.envApiUses.length);
+    }
+    recoveryScore(trace) {
+        const failures = trace.failures + trace.unknownOutcomes;
+        if (failures === 0)
+            return 1;
+        return (trace.recoveredFailures + trace.reconciledUnknowns) / failures;
+    }
+    contextScore(trace) {
+        if (trace.contextPlans.length === 0)
+            return 1;
+        const valid = trace.contextPlans.filter((plan) => plan.renderedTokens <= plan.resourceBudget &&
+            plan.planHash === plan.renderedHashLinkedPlanHash &&
+            plan.outputReserveCountedOnce).length;
+        return valid / trace.contextPlans.length;
+    }
+}
+export function classifyEnvKey(key, value) {
+    const normalizedKey = key.toUpperCase();
+    if (normalizedKey.includes("TOKEN") ||
+        normalizedKey.includes("SECRET") ||
+        normalizedKey.includes("PASSWORD") ||
+        normalizedKey.includes("API_KEY") ||
+        normalizedKey.endsWith("_KEY") ||
+        normalizedKey.startsWith("AWS_") ||
+        normalizedKey.startsWith("GCP_") ||
+        normalizedKey.startsWith("AZURE_") ||
+        normalizedKey.startsWith("OPENAI_") ||
+        normalizedKey.startsWith("ANTHROPIC_") ||
+        normalizedKey.startsWith("GITHUB_") ||
+        normalizedKey.startsWith("NPM_")) {
+        return "credential";
+    }
+    if (looksLikePaymentCredential(value))
+        return "payment";
+    if (looksLikeSessionCookie(value))
+        return "session";
+    return "public";
+}
+export function canonicalHash(value) {
+    return sha256(stableStringify(value));
+}
+export function redactForModel(value) {
+    if (typeof value === "string")
+        return redactString(value);
+    if (Array.isArray(value))
+        return value.map((item) => redactForModel(item));
+    if (isRecord(value)) {
+        const out = {};
+        for (const [key, child] of Object.entries(value)) {
+            out[key] =
+                classifyEnvKey(key, typeof child === "string" ? child : "") === "public"
+                    ? redactForModel(child)
+                    : "[REDACTED]";
+        }
+        return out;
+    }
+    return value;
+}
+function booleanResult(pass, kind, description) {
+    return {
+        pass,
+        confidence: pass ? 1 : 0,
+        evidencePointers: pass ? [{ kind, description }] : [],
+        failures: pass ? [] : [`${kind} postcondition failed: ${description}`],
+    };
+}
+async function verifyFile(path, expectedHash, kind) {
+    try {
+        await stat(path);
+        const content = await readFile(path);
+        const actualHash = createHash("sha256").update(content).digest("hex");
+        const pass = expectedHash === undefined || expectedHash === actualHash;
+        return {
+            pass,
+            confidence: pass ? 1 : 0,
+            evidencePointers: pass ? [{ kind, description: path, sha256: actualHash }] : [],
+            failures: pass ? [] : [`${kind} hash mismatch for ${path}`],
+        };
+    }
+    catch {
+        return { pass: false, confidence: 0, evidencePointers: [], failures: [`${kind} missing: ${path}`] };
+    }
+}
+function readJsonPath(value, path) {
+    if (path === "$")
+        return value;
+    if (!path.startsWith("$."))
+        return undefined;
+    let current = value;
+    for (const segment of path.slice(2).split(".")) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function readReceiptId(value) {
+    if (!isRecord(value))
+        return undefined;
+    const receipt = value.receiptId ?? value.id;
+    return typeof receipt === "string" ? receipt : undefined;
+}
+async function safeReadJsonOrText(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return response.text();
+    }
+}
+function deriveIdempotencyKey(action) {
+    return `omk-${canonicalHash({ method: action.method, url: action.url, body: action.body, actionId: action.actionId }).slice(0, 24)}`;
+}
+async function defaultFetcher(url, init) {
+    const response = await fetch(url, init);
+    return {
+        status: response.status,
+        json: () => response.json(),
+        text: () => response.text(),
+    };
+}
+function redactString(value) {
+    return value
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]{8,}/g, "Bearer [REDACTED]")
+        .replace(/([?&]?(?:access_)?token=)[^&\s]+/gi, "$1[REDACTED]")
+        .replace(/((?:api[_-]?key|password|secret)=)[^&\s]+/gi, "$1[REDACTED]");
+}
+function deepEqual(left, right) {
+    return stableStringify(left) === stableStringify(right);
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+        .join(",")}}`;
+}
+function matchesAny(value, patterns) {
+    return patterns.some((pattern) => pattern === "*" || globMatch(value, pattern));
+}
+function globMatch(value, pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`, "i").test(value);
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function looksLikePaymentCredential(value) {
+    return /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b/.test(value);
+}
+function looksLikeSessionCookie(value) {
+    return value.length >= 32 && /[A-Za-z0-9+/=_-]{32,}/.test(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=index.js.map