agents-relay 2.0.11 → 2.0.13

package/dist/decision-audit.js

@@ -1,7 +1,7 @@
 import { appendFile, mkdir, readFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
-export const DECISION_AUDIT_SCHEMA_VERSION = 2;
+export const DECISION_AUDIT_SCHEMA_VERSION = 5;
 export class JsonlDecisionAuditStore {
     path;
     constructor(path) {
@@ -59,3 +59,93 @@ export function makeDecisionAudit(input) {
     });
     return { record_type: 'decision', schema_version: DECISION_AUDIT_SCHEMA_VERSION, decision_id: decisionAuditId(), prior_decision_id: input.priorDecisionId, timestamp: input.routing.decidedAt, correlation: { job_id: input.task?.jobId, task_id: input.task?.id, execution_id: input.task?.executionId, attempt: input.task?.attempt }, task: taskAuditFacts(input.task), worker: input.worker, contract: input.contract, policy: { path: input.policy.path, hash: input.policy.hash, snapshot: input.policy.snapshot, rules: input.policy.rules }, candidates: input.candidates.map(candidate), gate_results, eligible_candidates: input.eligibleCandidates.map(candidate), selected: candidate(input.selected), engine: input.routing.decidedBy, fallback: { used: input.routing.decisionEvidence?.fallback ?? false, reason: input.routing.decisionEvidence?.error }, decision_evidence: input.routing.decisionEvidence, prior_failure: input.priorFailure };
 }
+function workerAuditCandidate(worker) {
+    return {
+        id: worker.workerId,
+        adapter: worker.adapter,
+        runtime: worker.runtime ?? null,
+        availability: worker.availability ?? null,
+        capabilities: [...worker.capabilities],
+        trustDomains: worker.trustDomains ?? [],
+        region: worker.region ?? null,
+        labels: worker.labels ?? {},
+        resourceProvider: worker.resourceProvider ?? null,
+        resourceHealthy: worker.resourceHealthy ?? null,
+        resourceUsedPercent: worker.resourceUsedPercent ?? null,
+        resourceRemainingPercent: worker.resourceRemainingPercent ?? null,
+        resourceResetAt: worker.resourceResetAt ?? null,
+        resourceResetInMinutes: worker.resourceResetInMinutes ?? null,
+        resourceWindows: worker.resourceWindows ?? null,
+        browserWorkspaceCapacity: worker.browserWorkspaceCapacity ?? null,
+    };
+}
+function executionRouteAuditCandidate(route) {
+    return {
+        id: route.id,
+        worker: workerAuditCandidate(route.worker),
+        model: {
+            id: route.model.id,
+            provider: route.model.provider,
+            model: route.model.model,
+            profile: route.model.profile ?? null,
+            reasoning: route.model.reasoning ?? null,
+            resourceHealthy: route.model.resourceHealthy ?? null,
+            resourceUsedPercent: route.model.resourceUsedPercent ?? null,
+            resourceRemainingPercent: route.model.resourceRemainingPercent ?? null,
+            resourceResetAt: route.model.resourceResetAt ?? null,
+            resourceResetInMinutes: route.model.resourceResetInMinutes ?? null,
+            resourceWindows: route.model.resourceWindows ?? null,
+        },
+    };
+}
+export function makeExecutionDecisionAudit(input) {
+    const routeRecords = input.evaluations.map(item => executionRouteAuditCandidate(item.route));
+    const eligibleRouteRecords = input.evaluations.filter(item => item.eligible).map(item => executionRouteAuditCandidate(item.route));
+    const selectedRecord = executionRouteAuditCandidate(input.selected);
+    return {
+        record_type: 'decision',
+        schema_version: DECISION_AUDIT_SCHEMA_VERSION,
+        decision_id: decisionAuditId(),
+        timestamp: input.routing.decidedAt,
+        correlation: {
+            job_id: input.task?.jobId,
+            task_id: input.task?.id,
+            execution_id: input.task?.executionId,
+            attempt: input.task?.attempt,
+        },
+        task: taskAuditFacts(input.task),
+        worker: workerAuditCandidate(input.selected.worker),
+        contract: input.contract,
+        policy: {
+            path: input.policy.path,
+            hash: input.policy.hash,
+            snapshot: input.policy.snapshot,
+            rules: input.policy.rules,
+        },
+        candidates: routeRecords,
+        gate_results: input.evaluations.map(item => ({
+            candidate_id: item.route.id,
+            eligible: item.eligible,
+            rejection_reasons: [...item.rejectionReasons],
+        })),
+        eligible_candidates: eligibleRouteRecords,
+        selected: selectedRecord,
+        engine: input.routing.decidedBy,
+        fallback: { used: input.routing.decisionEvidence?.fallback ?? false, reason: input.routing.decisionEvidence?.error },
+        decision_evidence: input.routing.decisionEvidence,
+        decision_input: {
+            facts: input.decisionRequest.facts,
+            contract: {
+                type: input.decisionContract.type,
+                question: input.decisionContract.question,
+                choices: [...input.decisionContract.choices],
+            },
+        },
+        worker_candidates: input.workers.map(workerAuditCandidate),
+        worker_gate_results: input.workerGateEvaluations.map(item => ({
+            worker_id: item.workerId,
+            eligible: item.eligible,
+            rejection_reasons: [...item.rejectionReasons],
+        })),
+    };
+}

package/dist/execution-routing.js

@@ -1,29 +1,44 @@
 import { chooseWithDecision } from './decision.js';
-import { makeDecisionAudit } from './decision-audit.js';
+import { makeExecutionDecisionAudit } from './decision-audit.js';
 import { discoverModelCandidates } from './model-routing.js';
 import { loadExecutionRouterRules, loadRoutingPolicy, policyAllows } from './routing-policy.js';
-import { DEFAULT_CHATGPT_PREFERRED_CONCURRENCY, eligibleWorkerCandidates } from './worker-routing.js';
+import { DEFAULT_CHATGPT_PREFERRED_CONCURRENCY } from './worker-routing.js';
 function sameModelRoute(candidate, route) {
     return (!route.provider || candidate.provider === route.provider)
         && (!route.model || candidate.model === route.model)
         && (route.profile === undefined || candidate.profile === route.profile);
 }
-function modelUsable(candidate, constraints, excludedRoutes, policy) {
+function workerGateReasons(worker, requirements) {
+    const reasons = [];
+    if (worker.availability === 'offline')
+        reasons.push('worker_offline');
+    if (requirements.runtime && worker.runtime !== requirements.runtime)
+        reasons.push('runtime_constraint');
+    if (worker.adapter === 'chatgpt' && worker.browserWorkspaceCapacity?.available === 0)
+        reasons.push('browser_workspace_exhausted');
+    return reasons;
+}
+function modelGateReasons(candidate, constraints, excludedRoutes, policy) {
+    const reasons = [];
     if (candidate.resourceHealthy === false)
-        return false;
+        reasons.push('resource_unhealthy');
     if ((excludedRoutes ?? []).some(route => sameModelRoute(candidate, route)))
-        return false;
-    if (!policyAllows(candidate, policy.policy))
-        return false;
+        reasons.push('prior_failed_route');
+    if (!policyAllows(candidate, policy.policy)) {
+        if (policy.policy.disabledProviders?.includes(candidate.provider))
+            reasons.push('policy_disabled_provider');
+        if (candidate.profile && policy.policy.disabledProfiles?.includes(candidate.profile))
+            reasons.push('policy_disabled_profile');
+    }
     if (constraints?.provider && candidate.provider !== constraints.provider)
-        return false;
+        reasons.push('provider_constraint');
     if (constraints?.model && candidate.model !== constraints.model)
-        return false;
+        reasons.push('model_constraint');
     if (constraints?.profile && candidate.profile !== constraints.profile)
-        return false;
+        reasons.push('profile_constraint');
     if (constraints?.reasoning && candidate.reasoning && candidate.reasoning !== constraints.reasoning)
-        return false;
-    return true;
+        reasons.push('reasoning_constraint');
+    return reasons;
 }
 function routeId(worker, model) {
     return `${worker.workerId}::${model.id}`;
@@ -51,22 +66,27 @@ function workerSelection(worker, selectedBy, evidence) {
     };
 }
 export async function discoverExecutionRoutes(workers, requirements, options = {}) {
-    const legalWorkers = eligibleWorkerCandidates(workers, requirements);
     const registered = options.registered ?? [];
     const policy = await loadRoutingPolicy(options.policyPath, options.rulesPath);
-    const routes = [];
-    for (const worker of legalWorkers) {
+    const workerGateEvaluations = workers.map(worker => {
+        const rejectionReasons = workerGateReasons(worker, requirements);
+        return { workerId: worker.workerId, eligible: rejectionReasons.length === 0, rejectionReasons };
+    });
+    const evaluations = [];
+    for (const worker of workers) {
+        const workerReasons = workerGateEvaluations.find(item => item.workerId === worker.workerId)?.rejectionReasons ?? [];
         const models = await discoverModelCandidates(worker, registered, options.usage, undefined, options.rulesPath);
         for (const model of models) {
-            if (!modelUsable(model, options.routingConstraints, options.excludedRoutes, policy))
-                continue;
-            routes.push({ id: routeId(worker, model), worker, model });
+            const rejectionReasons = [...workerReasons, ...modelGateReasons(model, options.routingConstraints, options.excludedRoutes, policy)];
+            const route = { id: routeId(worker, model), worker, model };
+            evaluations.push({ route, eligible: rejectionReasons.length === 0, rejectionReasons });
         }
     }
-    return { routes, policy };
+    const routes = evaluations.filter(item => item.eligible).map(item => item.route);
+    return { routes, evaluations, workerGateEvaluations, policy };
 }
 export async function routeExecution(workers, requirements, options = {}) {
-    const { routes, policy } = await discoverExecutionRoutes(workers, requirements, options);
+    const { routes, evaluations, workerGateEvaluations, policy } = await discoverExecutionRoutes(workers, requirements, options);
     if (routes.length === 0)
         throw new Error('No executable worker+model route satisfies authoritative constraints');
     const fallback = fallbackRoute(routes);
@@ -118,11 +138,13 @@ export async function routeExecution(workers, requirements, options = {}) {
             },
         })),
     }));
-    const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', { facts }, {
+    const decisionRequest = { facts };
+    const decisionContract = {
         type: 'choice',
         question: 'Choose the best complete execution route for this task. The listed candidates are already executable. Treat all non-impossibility signals as soft facts, follow free-text user guidance, and choose worker+model together in this one decision.',
         choices: routes.map(route => route.id),
-    }, () => fallback.id);
+    };
+    const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', decisionRequest, decisionContract, () => fallback.id);
     const selected = routes.find(route => route.id === choice.choice) ?? fallback;
     const selectedBy = choice.evidence.engine && !choice.evidence.fallback ? 'execution-router:laya' : 'execution-router:fallback';
     const routing = {
@@ -134,9 +156,13 @@ export async function routeExecution(workers, requirements, options = {}) {
         decidedAt: new Date().toISOString(),
         decisionEvidence: choice.evidence,
     };
-    const audit = makeDecisionAudit({
+    const audit = makeExecutionDecisionAudit({
         task: options.auditTask,
-        worker: { id: selected.worker.workerId, adapter: selected.worker.adapter, capabilities: [...selected.worker.capabilities], route_id: selected.id },
+        workers,
+        requirements,
+        evaluations,
+        workerGateEvaluations,
+        selected,
         contract: {
             question: 'execution-route-selection',
             task: options.taskFacts ?? {},
@@ -146,10 +172,9 @@ export async function routeExecution(workers, requirements, options = {}) {
             candidateRoutes: routes.map(route => ({ id: route.id, workerId: route.worker.workerId, adapter: route.worker.adapter })),
         },
         policy,
-        candidates: routes.map(route => ({ ...route.model, id: route.id })),
-        eligibleCandidates: routes.map(route => ({ ...route.model, id: route.id })),
-        selected: { ...selected.model, id: selected.id },
         routing,
+        decisionRequest,
+        decisionContract,
     });
     routing.decisionId = audit.decision_id;
     if (options.auditStore)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {