agents-relay 2.0.140 → 2.0.141

package/dist/chatgpt-platform-fallback.js

@@ -1,21 +1,39 @@
 import { eligibleWorkerCandidates, workerCandidates } from './worker-routing.js';
 import { routeExecution } from './execution-routing.js';
+import { eventFor } from './events.js';
+export function codexFallbackRouting(task, adapters, registered, usage) {
+    const requirements = task.workerRequirements ?? { capabilities: [] };
+    const excludedWorkers = new Set((task.routingExclusions ?? []).map(item => item.workerId).filter((id) => Boolean(id)));
+    const excludedAdapters = new Set((task.routingExclusions ?? []).map(item => item.adapter).filter((adapter) => Boolean(adapter)));
+    const candidates = eligibleWorkerCandidates(workerCandidates(adapters, registered, usage), requirements, { strictCapabilities: true })
+        .filter(candidate => candidate.adapter === 'codex' && !excludedWorkers.has(candidate.workerId) && !excludedAdapters.has(candidate.adapter));
+    const excludedRoutes = (task.routingExclusions ?? []).map(item => ({ provider: item.provider, model: item.model, ...(item.profile ? { profile: item.profile } : {}) }));
+    return { candidates, excludedRoutes };
+}
 export async function codexFallbackCompatible(task, adapters, registered, usage) {
     if (task.adapter !== 'chatgpt' || task.chatgptThreadDelivery || task.workerRequirements?.runtime === 'chatgpt')
         return false;
     const requirements = task.workerRequirements ?? { capabilities: [] };
-    const candidates = eligibleWorkerCandidates(workerCandidates(adapters, registered, usage), requirements, { strictCapabilities: true })
-        .filter(candidate => candidate.adapter === 'codex');
+    const { candidates, excludedRoutes } = codexFallbackRouting(task, adapters, registered, usage);
     if (candidates.length === 0)
         return false;
     try {
-        await routeExecution(candidates, requirements, { registered, usage, taskFacts: { task } });
+        await routeExecution(candidates, requirements, { registered, usage, taskFacts: { task }, excludedRoutes });
         return true;
     }
     catch {
         return false;
     }
 }
+export async function quarantineUnavailableCodexFallback(transitions, emit, jobId, taskId, error) {
+    const transition = await transitions.apply(jobId, taskId, 'worker.platform_failure', {
+        eligible: (_job, task) => task.state === 'QUEUED' && task.adapter === 'chatgpt' && task.platformFailure?.safeToReroute === true,
+        facts: () => ({ platformFallbackSafe: false }),
+        mutate: (_job, task) => { task.error = `Codex fallback route became unavailable: ${error instanceof Error ? error.message : String(error)}`; },
+    });
+    if (transition?.decision.accepted)
+        await emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.blocked', 'blocked', transition.task.error ?? 'Codex fallback route unavailable', 'user', { reason: transition.task.failureReason, phase: 'fallback-routing' }));
+}
 export function persistChatGptPlatformFailure(task, original, executionId, classification, evidence, safeToReroute) {
     const route = original?.routing;
     const workerId = original?.workerSelection?.workerId ?? 'chatgpt';

package/dist/reconciler-review.js

@@ -11,6 +11,7 @@ import { createTaskEntity } from './workflow/entity-creation.js';
 import { localSourceHead, localWorkingHead } from './local-git-merge.js';
 import { chatgptThreadRequirements, resolveReviewerThreadDestination, resolveImplementationTaskThreadDestination, prepareReviewerThreadDelivery } from './reviewer-thread.js';
 import { reviewGenerationMatches } from './review-generation-fence.js';
+import { codexFallbackRouting, quarantineUnavailableCodexFallback } from './chatgpt-platform-fallback.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) {
         // GitHub PR head facts are audit-only. Source identity is local Git.
@@ -268,9 +269,11 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             return { task, routed: false };
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
         const registered = await this.store.listAgents();
+        const codexFallback = task.platformFailure?.safeToReroute === true && task.adapter === 'chatgpt';
+        const fallbackRouting = codexFallback ? codexFallbackRouting(task, this.options.adapters, registered, usage) : undefined;
         const excludedWorkers = new Set((task.routingExclusions ?? []).map(item => item.workerId).filter((id) => Boolean(id)));
         const excludedAdapters = new Set((task.routingExclusions ?? []).map(item => item.adapter).filter((adapter) => Boolean(adapter)));
-        const candidates = workerCandidates(this.options.adapters, registered, usage)
+        const candidates = fallbackRouting?.candidates ?? workerCandidates(this.options.adapters, registered, usage)
             .filter(candidate => !excludedWorkers.has(candidate.workerId))
             .filter(candidate => !excludedAdapters.has(candidate.adapter))
             .filter(candidate => (implementationThread || reviewerThread) ? candidate.adapter === 'chatgpt' : true);
@@ -301,7 +304,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const parentExcludedRoutes = parentRouteFailedBeforeStart && parent?.routing
             ? [{ provider: parent.routing.provider, model: parent.routing.model, profile: parent.routing.profile }]
             : [];
-        const taskExcludedRoutes = (task.routingExclusions ?? []).map(item => ({ provider: item.provider, model: item.model, profile: item.profile }));
+        const taskExcludedRoutes = fallbackRouting?.excludedRoutes ?? (task.routingExclusions ?? []).map(item => ({ provider: item.provider, model: item.model, profile: item.profile }));
         const excludedRoutes = [...taskExcludedRoutes, ...parentExcludedRoutes];
         const routed = await routeExecution(candidates, requirements, {
             decisionEngine: this.options.decisionEngine,
@@ -325,6 +328,17 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'model.selected', 'queued', 'Selected ' + task.routing.model + ' · thinking ' + (task.routing.reasoning ?? 'unknown'), 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
         return { task, routed: true };
     }
+    async routeTaskForExecutionFailClosed(job, task) {
+        try {
+            return await this.routeTaskForExecution(job, task);
+        }
+        catch (error) {
+            if (task.adapter !== 'chatgpt' || !task.platformFailure?.safeToReroute)
+                throw error;
+            await quarantineUnavailableCodexFallback(this.taskTransitions, event => this.emit(event), job.id, task.id, error);
+            return undefined;
+        }
+    }
     async applyReviewEvent(event) {
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id && item.agentName === 'reviewer');

package/dist/reconciler.js

@@ -374,7 +374,10 @@ export class Reconciler extends ReconcilerReviewBase {
                 await bindPlannedReviewHead(this.store, freshTask, await this.currentHeadSha(freshJob));
             const implementationThread = resolveImplementationTaskThreadDestination(freshJob, freshTask);
             if ((!freshTask.routing || ((implementationThread || (freshTask.agentName === 'reviewer' && resolveReviewerThreadDestination(freshJob, this.options.reviewer?.threadId))) && freshTask.adapter !== 'chatgpt')) && freshTask.adapter !== 'orchestrator') {
-                freshTask = (await this.routeTaskForExecution(freshJob, freshTask)).task;
+                const routed = await this.routeTaskForExecutionFailClosed(freshJob, freshTask);
+                if (!routed)
+                    return;
+                freshTask = routed.task;
             }
             if (['codex', 'chatgpt'].includes(freshTask.adapter) && !freshTask.routing) {
                 throw new Error('Task ' + freshTask.id + ' requires routing metadata before execution claim');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.140",
+  "version": "2.0.141",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",