agents-relay 1.0.109 → 1.0.110

package/dist/cli.js

@@ -181,7 +181,7 @@ async function runTaskCommand(action, args) {
     if (action === 'retry' || action === 'cancel') {
         if (action === 'retry')
             task.maxAttempts = extendRetryBudget(task);
-        await transitionTaskEvent(task, action === 'retry' ? 'retry' : 'cancel');
+        await transitionTaskEvent(task, action === 'retry' ? 'retry' : task.state === 'RUNNING' ? 'task.cancelled' : 'cancel');
         task.error = action === 'retry' ? null : 'Cancelled by user';
         task.leaseOwner = null;
         task.leaseExpiresAt = null;
@@ -429,9 +429,9 @@ export function dashboardTaskAction(store, reconciler, action) {
             task.error = null;
         }
         else {
-            if (!['DRAFT', 'QUEUED', 'BLOCKED', 'FAILED'].includes(task.state))
+            if (!['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'FAILED'].includes(task.state))
                 throw new Error(`Task ${task.id} is not cancellable (${task.state})`);
-            await transitionTaskEvent(task, 'cancel');
+            await transitionTaskEvent(task, task.state === 'RUNNING' ? 'task.cancelled' : 'cancel');
             task.error = 'Cancelled by user';
         }
         task.leaseOwner = null;

package/dist/dashboard-html.js

@@ -203,7 +203,7 @@ export const dashboardHtml = `<!doctype html>
       <div class="panel-body">
         <div class="rules-editor">
           <p class="rules-help">Free-text guidance loaded by the model decider for every routing decision. Hard capability and health gates remain enforced by code.</p>
-          <textarea id="rules-text" class="rules-textarea" spellcheck="true" aria-label="Model router rules" placeholder="Example: Prefer ZAI when paid quota is abundant and task quality is sufficient. If a provider/runtime path just failed, reconsider using the failure evidence and fresh usage."></textarea>
+          <textarea id="rules-text" class="rules-textarea" spellcheck="true" aria-label="Model router rules" placeholder="Example: ZAI only glm-5.3-flash high thinking. Prefer it while paid quota is abundant. Non-OpenAI models enter the candidate set only when the provider is configured and the concrete model is named here."></textarea>
           <div class="rules-footer"><span id="rules-status" class="subtle" aria-live="polite"></span><button id="rules-save" class="rules-save" type="button">Save rules</button></div>
         </div>
       </div>

package/dist/decision-audit.js

@@ -42,6 +42,9 @@ export function makeDecisionAudit(input) {
         if (item.resourceHealthy === false)
             reasons.push('resource_unhealthy');
         const constraints = input.contract.constraints;
+        const excludedRoutes = Array.isArray(input.contract.excludedRoutes) ? input.contract.excludedRoutes : [];
+        if (excludedRoutes.some(route => (!route.provider || route.provider === item.provider) && (!route.model || route.model === item.model) && (route.profile === undefined || route.profile === item.profile)))
+            reasons.push('prior_failed_route');
         if (typeof constraints?.provider === 'string' && constraints.provider !== item.provider)
             reasons.push('provider_constraint');
         if (typeof constraints?.model === 'string' && constraints.model !== item.model)

package/dist/model-redecision.js

@@ -23,16 +23,18 @@ export async function redecideFailedTask(options) {
     if (options.evidence.classification !== 'model_provider_runtime')
         throw new Error('Model re-decision requires model/provider/runtime evidence');
     const usage = await readUsageSnapshot(options.usage);
-    const candidates = await discoverModelCandidates(options.worker, options.registered, usage);
+    const candidates = await discoverModelCandidates(options.worker, options.registered, usage, undefined, options.rulesPath);
     const result = await routeModel(options.worker, candidates, {
         decisionEngine: options.decisionEngine,
         decisionMode: options.decisionMode,
         policyPath: options.policyPath,
+        rulesPath: options.rulesPath,
         auditStore: options.auditStore,
         auditTask: options.task,
         taskFacts: { kind: options.task.kind ?? 'work', capabilities: options.task.capabilities, prior_routing: options.task.routing ?? null, fresh_usage_generated_at: usage.generatedAt },
         priorDecisionId: options.task.routing?.decisionId,
         priorFailure: options.evidence,
+        excludedRoutes: options.task.routing ? [{ provider: options.task.routing.provider, model: options.task.routing.model, profile: options.task.routing.profile }] : [],
     });
     await options.updateRouting(options.task, result.routing);
     if (options.auditStore && options.task.routing?.decisionId)

package/dist/model-routing.js

@@ -4,7 +4,7 @@ import { readdir, readFile } from 'node:fs/promises';
 import { chooseWithDecision } from './decision.js';
 import { usageForProvider } from './worker-routing.js';
 import { makeDecisionAudit } from './decision-audit.js';
-import { loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
+import { loadModelRouterRules, loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
 function topLevelCodexConfig(text) {
     const result = {};
     let inSection = false;
@@ -38,13 +38,34 @@ async function readConfig(path) {
         return null;
     }
 }
+function compact(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '');
+}
+function modelAliases(model) {
+    const aliases = new Set([compact(model)]);
+    const firstDigit = model.search(/\d/);
+    if (firstDigit >= 0)
+        aliases.add(compact(model.slice(firstDigit)));
+    return [...aliases].filter(Boolean);
+}
+export function nonOpenAiModelAuthorized(provider, model, rulesText) {
+    if (provider === 'openai')
+        return true;
+    const rules = compact(rulesText);
+    if (!rules.includes(compact(provider)))
+        return false;
+    return modelAliases(model).some(alias => alias.length >= 3 && rules.includes(alias));
+}
 function withResource(candidate, usage) {
     const resource = usageForProvider(usage, candidate.provider);
     return { ...candidate, resourceHealthy: resource.healthy, resourceUsedPercent: resource.usedPercent, resourceRemainingPercent: resource.remainingPercent, resourceResetAt: resource.resetAt, resourceResetInMinutes: resource.resetInMinutes, resourceWindows: resource.windows };
 }
-export async function discoverModelCandidates(worker, registered, usage, codexHome = process.env.CODEX_HOME ?? join(homedir(), '.codex')) {
+export async function discoverModelCandidates(worker, registered, usage, codexHome = process.env.CODEX_HOME ?? join(homedir(), '.codex'), rulesPath) {
     const registration = registered.find(item => item.id === worker.workerId);
     if (registration?.runtime.provider && registration.runtime.model) {
+        const rules = await loadModelRouterRules(rulesPath);
+        if (!nonOpenAiModelAuthorized(registration.runtime.provider, registration.runtime.model, rules.text))
+            return [];
         return [withResource({
                 id: `${registration.runtime.provider}/${registration.runtime.model}`,
                 provider: registration.runtime.provider,
@@ -55,9 +76,13 @@ export async function discoverModelCandidates(worker, registered, usage, codexHo
         return [withResource({ id: 'chatgpt/account-defaults', provider: 'chatgpt', model: 'account-defaults' }, usage)];
     }
     const base = await readConfig(join(codexHome, 'config.toml')) ?? {};
+    const rules = await loadModelRouterRules(rulesPath);
     const candidates = [];
-    if (base.model)
-        candidates.push(withResource({ id: `default:${base.provider ?? 'openai'}/${base.model}`, provider: base.provider ?? 'openai', model: base.model, reasoning: base.reasoning }, usage));
+    if (base.model) {
+        const provider = base.provider ?? 'openai';
+        if (nonOpenAiModelAuthorized(provider, base.model, rules.text))
+            candidates.push(withResource({ id: `default:${provider}/${base.model}`, provider, model: base.model, reasoning: base.reasoning }, usage));
+    }
     let files = [];
     try {
         files = (await readdir(codexHome)).filter(name => name.endsWith('.config.toml')).sort();
@@ -69,16 +94,25 @@ export async function discoverModelCandidates(worker, registered, usage, codexHo
             continue;
         const profile = basename(file, '.config.toml');
         const provider = config.provider ?? base.provider ?? 'openai';
+        if (!nonOpenAiModelAuthorized(provider, config.model, rules.text))
+            continue;
         candidates.push(withResource({ id: `${profile}:${provider}/${config.model}`, provider, model: config.model, profile, reasoning: config.reasoning ?? base.reasoning }, usage));
     }
     if (candidates.length === 0)
         candidates.push(withResource({ id: 'default:openai/gpt-5.6-luna', provider: 'openai', model: 'gpt-5.6-luna' }, usage));
     return candidates.filter((candidate, index, all) => all.findIndex(item => item.id === candidate.id) === index);
 }
-function eligibleModels(candidates, constraints, policy) {
+function sameRoute(candidate, route) {
+    return (!route.provider || candidate.provider === route.provider)
+        && (!route.model || candidate.model === route.model)
+        && (route.profile === undefined || candidate.profile === route.profile);
+}
+function eligibleModels(candidates, constraints, policy, excludedRoutes = []) {
     return candidates.filter(candidate => {
         if (candidate.resourceHealthy === false)
             return false;
+        if (excludedRoutes.some(route => sameRoute(candidate, route)))
+            return false;
         if (policy && !policyAllows(candidate, policy.policy))
             return false;
         if (constraints?.provider && candidate.provider !== constraints.provider)
@@ -100,7 +134,7 @@ function deterministicModel(candidates, taskKind, policy) {
 }
 export async function routeModel(worker, candidates, options = {}) {
     const policy = await loadRoutingPolicy(options.policyPath, options.rulesPath);
-    const eligible = eligibleModels(candidates, options.constraints, policy);
+    const eligible = eligibleModels(candidates, options.constraints, policy, options.excludedRoutes);
     if (eligible.length === 0)
         throw new Error(`No eligible model profile is usable by worker ${worker.workerId}`);
     const taskKind = typeof options.taskFacts?.kind === 'string' ? options.taskFacts.kind : undefined;
@@ -130,7 +164,7 @@ export async function routeModel(worker, candidates, options = {}) {
     const audit = makeDecisionAudit({
         task: options.auditTask,
         worker: { id: worker.workerId, adapter: worker.adapter, capabilities: [...worker.capabilities] },
-        contract: { question: 'model-profile-selection', task: options.taskFacts ?? {}, constraints: options.constraints ?? {} },
+        contract: { question: 'model-profile-selection', task: options.taskFacts ?? {}, constraints: options.constraints ?? {}, excludedRoutes: options.excludedRoutes ?? [] },
         policy,
         candidates,
         eligibleCandidates: eligible,

package/dist/reconciler-review.js

@@ -129,7 +129,12 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             });
             const models = await discoverModelCandidates(routedWorker.candidate, registered, usage);
             const routingConstraints = task.routing ? { provider: task.routing.provider, model: task.routing.model, profile: task.routing.profile, reasoning: task.routing.reasoning } : undefined;
-            const routedModel = await routeModel(routedWorker.candidate, models, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts, constraints: routingConstraints, auditStore: this.options.decisionAuditStore, auditTask: task });
+            const parent = task.agentName === 'troubleshooter' && task.parentTaskId ? job.tasks.find(item => item.id === task.parentTaskId) : undefined;
+            const parentRouteFailedBeforeStart = Boolean(parent?.routing && /exited before publishing task\.started|worker_exit_before_start|launch failed/i.test(parent.error ?? parent.failureReason ?? ''));
+            const excludedRoutes = parentRouteFailedBeforeStart && parent?.routing
+                ? [{ provider: parent.routing.provider, model: parent.routing.model, profile: parent.routing.profile }]
+                : [];
+            const routedModel = await routeModel(routedWorker.candidate, models, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts: { ...taskFacts, recovery_parent_failed_route: excludedRoutes[0] ?? null }, constraints: routingConstraints, excludedRoutes, auditStore: this.options.decisionAuditStore, auditTask: task });
             task.workerSelection = routedWorker.selection;
             task.adapter = routedWorker.candidate.adapter;
             task.routing = routedModel.routing;

package/dist/workspace.js

@@ -35,7 +35,7 @@ export async function discoverGitRepositories(root) {
         catch {
             return;
         }
-        await Promise.all(entries.filter(entry => entry.isDirectory() && !['node_modules', '.git', '.worktrees', '.backup'].includes(entry.name)).map(entry => visit(join(directory, entry.name))));
+        await Promise.all(entries.filter(entry => entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')).map(entry => visit(join(directory, entry.name))));
     };
     await visit(resolve(root));
     return found.sort((a, b) => relative(root, a).localeCompare(relative(root, b)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.109",
+  "version": "1.0.110",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli.js dist/relayd.js",
-    "test": "npm run build && node --test test/*.test.js",
+    "test": "npm run build && node --test --test-force-exit test/*.test.js",
     "test:chatgpt-temp-quality": "AGENTS_RELAY_RUN_CHATGPT_TEMP_QUALITY=1 AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT=/Users/chengli/Workspace/neo/skills/chatgpt-browser-worker/agents/browser-worker.agent.md sh -c \"npm run build && node test/quality/run-temporary-chat.mjs\"",
     "dev": "tsx src/cli.ts"
   },