agents-relay 2.0.12 → 2.0.14

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 = 3;
+export const DECISION_AUDIT_SCHEMA_VERSION = 5;
 export class JsonlDecisionAuditStore {
     path;
     constructor(path) {
@@ -79,16 +79,6 @@ function workerAuditCandidate(worker) {
         browserWorkspaceCapacity: worker.browserWorkspaceCapacity ?? null,
     };
 }
-function workerGateResult(worker, requirements) {
-    const rejectionReasons = [];
-    if (worker.availability === 'offline')
-        rejectionReasons.push('worker_offline');
-    if (requirements.runtime && worker.runtime !== requirements.runtime)
-        rejectionReasons.push('runtime_constraint');
-    if (worker.adapter === 'chatgpt' && worker.browserWorkspaceCapacity?.available === 0)
-        rejectionReasons.push('browser_workspace_exhausted');
-    return { worker_id: worker.workerId, eligible: rejectionReasons.length === 0, rejection_reasons: rejectionReasons };
-}
 function executionRouteAuditCandidate(route) {
     return {
         id: route.id,
@@ -109,9 +99,9 @@ function executionRouteAuditCandidate(route) {
     };
 }
 export function makeExecutionDecisionAudit(input) {
-    const routeRecords = input.routes.map(executionRouteAuditCandidate);
+    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);
-    const workerGateResults = input.workers.map(worker => workerGateResult(worker, input.requirements));
     return {
         record_type: 'decision',
         schema_version: DECISION_AUDIT_SCHEMA_VERSION,
@@ -133,13 +123,29 @@ export function makeExecutionDecisionAudit(input) {
             rules: input.policy.rules,
         },
         candidates: routeRecords,
-        gate_results: routeRecords.map(record => ({ candidate_id: String(record.id), eligible: true, rejection_reasons: [] })),
-        eligible_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: workerGateResults,
+        worker_gate_results: input.workerGateEvaluations.map(item => ({
+            worker_id: item.workerId,
+            eligible: item.eligible,
+            rejection_reasons: [...item.rejectionReasons],
+        })),
     };
 }

package/dist/execution-routing.js

@@ -2,28 +2,43 @@ import { chooseWithDecision } from './decision.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 = {
@@ -138,7 +160,8 @@ export async function routeExecution(workers, requirements, options = {}) {
         task: options.auditTask,
         workers,
         requirements,
-        routes,
+        evaluations,
+        workerGateEvaluations,
         selected,
         contract: {
             question: 'execution-route-selection',
@@ -150,6 +173,8 @@ export async function routeExecution(workers, requirements, options = {}) {
         },
         policy,
         routing,
+        decisionRequest,
+        decisionContract,
     });
     routing.decisionId = audit.decision_id;
     if (options.auditStore)

package/dist/pool.js

@@ -108,9 +108,14 @@ export class RepositoryWorkerPool {
         }
         const seedKey = `${target.repository}#${target.prNumber}:${jobId}`;
         const mayConsumeSeed = signals.some(signal => signal.reason === 'target.request' || signal.reason.startsWith('github.webhook:'));
-        const seed = mayConsumeSeed ? this.targetSeeds.get(seedKey) ?? null : null;
+        let seed = mayConsumeSeed ? this.targetSeeds.get(seedKey) ?? null : null;
         if (mayConsumeSeed)
             this.targetSeeds.delete(seedKey);
+        const needsFreshPullRequestFacts = signals.some(signal => !signal.event || signal.event.type === 'task.completed');
+        if (!seed && needsFreshPullRequestFacts && this.refreshWebhookSnapshot && !this.isRateLimited()) {
+            const trigger = `coordinator.${signals.map(signal => signal.reason).join('+') || 'reconcile'}`;
+            seed = (await this.refreshWebhookSnapshot(target.repository, target.prNumber, trigger)).seed;
+        }
         const store = this.makeStore(target.repository, target.prNumber, seed);
         const reconciler = this.makeReconciler(store, Math.max(1, this.concurrency));
         let shouldReconcile = false;

package/dist/projected-store.js

@@ -289,7 +289,11 @@ export class ProjectedDurableStore {
         });
     }
     async ensurePullRequestFacts() {
-        const local = await localPullRequestFacts(this.relay, this.seededFacts);
+        const local = await this.relay.loadPullRequestFacts();
+        if (this.seededFacts && (!local || this.seededFacts.observedAt >= local.observedAt)) {
+            await this.relay.savePullRequestFacts(structuredClone(this.seededFacts));
+            return this.seededFacts;
+        }
         if (local)
             return local;
         if (!this.github.pullRequestState || !this.github.pullRequestHead)

package/package.json

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