agents-relay 2.0.27 → 2.0.28

package/dist/dashboard-html.js

@@ -329,6 +329,8 @@ const displayedEventIds=new Set();
 function value(input){return input===null||input===undefined||input===''?'—':String(input);}
 function text(input){return document.createTextNode(value(input));}
 function element(name,className,child){const node=document.createElement(name);if(className)node.className=className;if(child)node.append(child);return node;}
+function yamlScalar(input){if(input===null)return 'null';if(typeof input==='boolean'||typeof input==='number')return String(input);return JSON.stringify(String(input));}
+function yamlDump(input,indent=0){const pad=' '.repeat(indent);if(Array.isArray(input)){if(!input.length)return pad+'[]';return input.map(item=>{if(item&&typeof item==='object'){return pad+'-\\n'+yamlDump(item,indent+2);}return pad+'- '+yamlScalar(item);}).join('\\n');}if(input&&typeof input==='object'){const entries=Object.entries(input);if(!entries.length)return pad+'{}';const lines=[];for(const [key,item] of entries){if(typeof item==='string'&&item.includes('\\n')){lines.push(pad+key+': |');for(const line of item.replace(/\\n$/,'').split('\\n'))lines.push(' '.repeat(indent+2)+line);continue;}if(item&&typeof item==='object'){lines.push(pad+key+':');lines.push(yamlDump(item,indent+2));}else{lines.push(pad+key+': '+yamlScalar(item));}}return lines.join('\\n');}return pad+yamlScalar(input);}
 function field(label,input){const box=element('div','detail-group');box.append(element('p','detail-label',text(label)),element('p','detail-value',text(input)));return box;}
 function markdownField(label,input){const box=element('div','detail-group');box.append(element('p','detail-label',text(label)),markdownValue(input));return box;}
 function rememberSelection(){if(selectedJob)sessionStorage.setItem('agents-relay:selected-job',selectedJob);else sessionStorage.removeItem('agents-relay:selected-job');if(selectedTaskId)sessionStorage.setItem('agents-relay:selected-task',selectedTaskId);else sessionStorage.removeItem('agents-relay:selected-task');}
@@ -451,7 +453,7 @@ function routeWorker(record){const id=record?.selected?.worker?.id||record?.work
 function renderAudit(records){auditLog.replaceChildren();if(!Array.isArray(records)||!records.length){auditLog.append(element('p','empty',text('No schema v5 routing decisions yet.')));return;}for(const record of records){const card=element('article','audit-entry');const head=element('div','audit-entry-head');head.append(element('strong','',text(routeWorker(record)+' · '+value(record?.selected?.model?.model))),element('span','subtle',text(new Date(record.timestamp).toLocaleString())));card.append(head);const correlation=record.correlation||{};card.append(element('div','subtle',text([correlation.job_id,correlation.task_id].filter(Boolean).join(' / ')||'uncorrelated')));const probabilities=record.decision_evidence?.probabilities||{};const gates=(record.gate_results||[]).filter(item=>!item.eligible).map(item=>item.candidate_id+': '+item.rejection_reasons.join(', '));const nl=String.fromCharCode(10);const details=document.createElement('pre');details.textContent='fallback: '+String(Boolean(record.decision_evidence?.fallback))+(Object.keys(probabilities).length?nl+'probabilities: '+JSON.stringify(probabilities,null,2):'')+(gates.length?nl+'rejected: '+gates.join(nl):'');card.append(details);auditLog.append(card);}}
 async function drawAudit(){auditRefresh.disabled=true;try{renderAudit(await loadJSON('/api/decision-audit'));}catch(error){auditLog.replaceChildren(element('p','error-state',text('Audit unavailable: '+error.message)));}finally{auditRefresh.disabled=false;}}
 async function drawRules(){rulesStatus.textContent='';try{const rules=await loadJSON('/api/execution-router-rules');rulesText.value=typeof rules.text==='string'?rules.text:'';rulesMeta.textContent=rules.hash&&rules.hash!=='none'?'Loaded · '+rules.hash.slice(0,12):'No custom rules saved';}catch(error){rulesMeta.textContent='Unavailable';rulesStatus.textContent='Could not load rules: '+error.message;}void drawAudit();}
-async function testRouter(){rulesTest.disabled=true;routerTestResults.replaceChildren(element('p','subtle',text('Calling router with current status…')));try{if(!selectedJob||!selectedTaskId)throw new Error('Select a Job and Task first');const response=await fetch('/api/router-test',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({jobId:selectedJob,taskId:selectedTaskId})});if(!response.ok)throw new Error(response.status+' '+await response.text());const result=await response.json();const selected=result.selected||{};const payload={selected,probabilities:result.probabilities||{},fallback:Boolean(result.fallback),hard_gates:result.gates||[],laya_input:result.decisionInput||null};routerTestResults.replaceChildren(element('strong','',text((selected.worker||'—')+' · '+(selected.model||'—'))));routerTestResults.append(element('div','subtle',text('route: '+(selected.route||'—'))),element('pre','',text(JSON.stringify(payload,null,2))));}catch(error){routerTestResults.replaceChildren(element('p','error-state',text('Router test failed: '+error.message)));}finally{rulesTest.disabled=false;}}
+async function testRouter(){rulesTest.disabled=true;routerTestResults.replaceChildren(element('p','subtle',text('Calling router with current status…')));try{if(!selectedJob||!selectedTaskId)throw new Error('Select a Job and Task first');const response=await fetch('/api/router-test',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({jobId:selectedJob,taskId:selectedTaskId})});if(!response.ok)throw new Error(response.status+' '+await response.text());const result=await response.json();const selected=result.selected||{};const payload={selected,proposed_fields:result.proposedFields||{},probabilities:result.probabilities||{},fallback:Boolean(result.fallback),hard_gates:result.gates||[],laya_input:result.decisionInput||null};routerTestResults.replaceChildren(element('strong','',text((selected.worker||'—')+' · '+(selected.model||'—'))));routerTestResults.append(element('div','subtle',text('route: '+(selected.route||'—'))),element('pre','',text(yamlDump(payload))));}catch(error){routerTestResults.replaceChildren(element('p','error-state',text('Router test failed: '+error.message)));}finally{rulesTest.disabled=false;}}
 async function saveRules(){rulesSave.disabled=true;rulesStatus.textContent='Saving…';try{const response=await fetch('/api/execution-router-rules',{method:'PUT',headers:{'content-type':'text/plain; charset=utf-8'},body:rulesText.value});if(!response.ok)throw new Error(response.status+' '+await response.text());const rules=await response.json();rulesMeta.textContent='Saved · '+rules.hash.slice(0,12);rulesStatus.textContent='Saved. New routing decisions will load these rules.';}catch(error){rulesStatus.textContent='Save failed: '+error.message;}finally{rulesSave.disabled=false;}}
 async function drawShortcuts(){shortcutsStatus.textContent='';shortcutsText.value=chatShortcutText();}
 function saveShortcuts(){const value=shortcutsText.value.trim();if(value)localStorage.setItem(CHAT_SHORTCUTS_KEY,value);else localStorage.removeItem(CHAT_SHORTCUTS_KEY);shortcutsText.value=chatShortcutText();shortcutsStatus.textContent='Saved.';}

package/dist/execution-routing.js

@@ -1,4 +1,3 @@
-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';
@@ -60,6 +59,115 @@ function modelGateReasons(candidate, constraints, excludedRoutes, policy) {
         reasons.push('reasoning_constraint');
     return reasons;
 }
+const REASONING_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+function setupName(worker, model) {
+    if (worker.adapter === 'chatgpt')
+        return 'account-defaults';
+    if (model.id.startsWith('default:') || model.id.startsWith('catalog:'))
+        return 'default';
+    return model.profile ?? model.provider;
+}
+function setupKey(worker, model) {
+    return worker.workerId + '/' + setupName(worker, model);
+}
+function configuredDefault(models, setup) {
+    if (setup === 'account-defaults')
+        return models[0];
+    if (setup === 'default')
+        return models.find(model => model.id.startsWith('default:'));
+    return models.find(model => model.profile === setup && model.id.startsWith(setup + ':'));
+}
+function resolveModelAlias(raw, models, familyHint) {
+    const normalized = raw.trim().toLowerCase();
+    const exact = models.find(model => model.model.toLowerCase() === normalized);
+    if (exact)
+        return exact.model;
+    if (familyHint) {
+        const sameFamily = models.find(model => model.model.toLowerCase() === familyHint.toLowerCase() + '-' + normalized);
+        if (sameFamily)
+            return sameFamily.model;
+    }
+    const suffix = [...new Set(models.filter(model => model.model.toLowerCase().endsWith('-' + normalized)).map(model => model.model))];
+    return suffix.length === 1 ? suffix[0] : raw.trim();
+}
+function userModelOverrides(rulesText, defaults, models) {
+    const result = [];
+    for (const line of rulesText.split(/\r?\n/)) {
+        const match = line.match(/^\s*([a-z0-9._-]+)\s*:\s*(.+)$/i);
+        if (!match)
+            continue;
+        const label = match[1].toLowerCase();
+        const base = defaults.find(model => (model.profile ?? (model.provider === 'openai' ? 'default' : model.provider)).toLowerCase() === label || model.provider.toLowerCase() === label);
+        if (!base)
+            continue;
+        const sameSetupModels = models.filter(model => model.provider === base.provider && (model.profile ?? null) === (base.profile ?? null));
+        const familyHint = match[2].match(/\b(gpt-\d+(?:\.\d+)?)-[a-z0-9.-]+/i)?.[1];
+        for (const segment of match[2].split(',')) {
+            const item = segment.trim().match(/^(.+?)\s+(low|medium|high|xhigh|max|ultra)(?:\s|$)/i);
+            if (!item)
+                continue;
+            const model = resolveModelAlias(item[1].trim(), sameSetupModels, familyHint);
+            const reasoning = item[2].toLowerCase();
+            if (result.some(candidate => candidate.provider === base.provider && candidate.model === model && (candidate.profile ?? null) === (base.profile ?? null) && candidate.reasoning === reasoning))
+                continue;
+            result.push({
+                ...base,
+                id: (base.profile ?? 'default') + ':user/' + model,
+                model,
+                reasoning,
+            });
+        }
+    }
+    return result;
+}
+function codePlan(model) {
+    return {
+        five_hour: model.resourceWindows?.fiveHour ? {
+            remaining_percent: model.resourceWindows.fiveHour.remainingPercent ?? null,
+            reset_at: model.resourceWindows.fiveHour.resetAt ?? null,
+            reset_in_minutes: model.resourceWindows.fiveHour.resetInMinutes ?? null,
+        } : null,
+        weekly: model.resourceWindows?.weekly ? {
+            remaining_percent: model.resourceWindows.weekly.remainingPercent ?? null,
+            reset_at: model.resourceWindows.weekly.resetAt ?? null,
+            reset_in_minutes: model.resourceWindows.weekly.resetInMinutes ?? null,
+        } : null,
+    };
+}
+function workerProviderFacts(routes) {
+    const workers = new Map();
+    for (const route of routes) {
+        const list = workers.get(route.worker.workerId) ?? [];
+        list.push(route);
+        workers.set(route.worker.workerId, list);
+    }
+    return [...workers.entries()].map(([workerId, workerRoutes]) => {
+        const providers = new Map();
+        for (const route of workerRoutes) {
+            const list = providers.get(route.model.provider) ?? [];
+            list.push(route);
+            providers.set(route.model.provider, list);
+        }
+        return {
+            id: workerId,
+            adapter: workerRoutes[0].worker.adapter,
+            providers: Object.fromEntries([...providers.entries()].map(([provider, providerRoutes]) => {
+                const models = providerRoutes.map(route => route.model);
+                const configured = models.find(model => !model.id.includes(':user/')) ?? models[0];
+                return [provider, {
+                        default: { model: configured.model, reasoning: configured.reasoning ?? null },
+                        code_plan: codePlan(configured),
+                    }];
+            })),
+        };
+    });
+}
+function decisionRouteLabel(route) {
+    const prefix = route.worker.workerId + '/' + route.model.provider + '/';
+    if (!route.model.id.includes(':user/'))
+        return prefix + 'default';
+    return prefix + route.model.model + (route.model.reasoning ? '@' + route.model.reasoning : '');
+}
 function routeId(worker, model) {
     return worker.workerId + '::' + model.id + (model.reasoning ? '@' + model.reasoning : '');
 }
@@ -95,7 +203,11 @@ export async function discoverExecutionRoutes(workers, requirements, options = {
     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);
+        const discoveredModels = await discoverModelCandidates(worker, registered, options.usage, undefined, options.rulesPath);
+        const configuredModels = discoveredModels.filter(model => !model.id.startsWith('catalog:'));
+        const defaults = configuredModels.filter(model => model.id.startsWith('default:') || (model.profile && model.id.startsWith(model.profile + ':')) || worker.adapter === 'chatgpt');
+        const advertised = userModelOverrides(policy.rules.text, defaults, discoveredModels);
+        const models = [...configuredModels, ...advertised];
         for (const model of models) {
             const rejectionReasons = [...workerReasons, ...modelGateReasons(model, options.routingConstraints, options.excludedRoutes, policy)];
             const route = { id: routeId(worker, model), worker, model };
@@ -136,36 +248,51 @@ export async function routeExecution(workers, requirements, options = {}) {
             chatgpt_running: chatgptRunning,
             preferred_chatgpt_concurrency: preferredChatgptConcurrency,
         },
-        eligible_routes: routes.map(route => ({
-            id: route.id,
-            worker: route.worker.adapter,
-            provider: route.model.provider,
-            model: route.model.model,
-            profile: route.model.profile ?? null,
-            reasoning: route.model.reasoning ?? null,
-            code_plan: {
-                five_hour: route.model.resourceWindows?.fiveHour ? {
-                    remaining_percent: route.model.resourceWindows.fiveHour.remainingPercent ?? null,
-                    reset_at: route.model.resourceWindows.fiveHour.resetAt ?? null,
-                    reset_in_minutes: route.model.resourceWindows.fiveHour.resetInMinutes ?? null,
-                } : null,
-                weekly: route.model.resourceWindows?.weekly ? {
-                    remaining_percent: route.model.resourceWindows.weekly.remainingPercent ?? null,
-                    reset_at: route.model.resourceWindows.weekly.resetAt ?? null,
-                    reset_in_minutes: route.model.resourceWindows.weekly.resetInMinutes ?? null,
-                } : null,
-            },
-        })),
+        worker_candidates: workerProviderFacts(routes),
+        routing_instruction: 'For each selected provider, use its default model and reasoning unless user_input_rules explicitly provides another model/reasoning option. Any override must be compatible with the selected worker/provider and pass runtime validation.',
     }));
+    const decisionChoices = routes.map(decisionRouteLabel);
     const decisionRequest = { facts };
     const decisionContract = {
         type: 'choice',
-        question: 'Choose one eligible complete execution route. Treat context.task_shape.preferred_worker as the default worker-fit signal; user_input_rules and concrete runtime or code-plan resource facts may override it. The choice identifies worker, provider, model, profile, and reasoning together.',
-        choices: routes.map(route => route.id),
+        question: 'Choose one legal route. Each provider default is available. Additional model/reasoning routes exist only when explicitly provided by user_input_rules. Use context, code-plan quota, runtime load, and user_input_rules.',
+        choices: decisionChoices,
     };
-    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';
+    let selected = fallback;
+    let evidence = { mode: options.decisionMode ?? 'off', fallback: true };
+    if ((options.decisionMode ?? 'off') !== 'off' && options.decisionEngine) {
+        try {
+            const decision = await options.decisionEngine.decide(decisionRequest, decisionContract);
+            if (decision.type !== 'choice')
+                throw new Error('Execution router expected a route choice result');
+            const index = decisionChoices.indexOf(decision.choice);
+            if (index < 0)
+                throw new Error('Execution router returned an unknown route');
+            selected = routes[index];
+            evidence = {
+                mode: options.decisionMode ?? 'active',
+                engine: options.decisionEngine.name,
+                proposed: decision.choice,
+                probabilities: decision.probabilities,
+                proposedFields: {
+                    worker: selected.worker.workerId,
+                    provider: selected.model.provider,
+                    model: selected.model.model,
+                    reasoning: selected.model.reasoning ?? '',
+                },
+                fallback: false,
+            };
+        }
+        catch (error) {
+            evidence = {
+                mode: options.decisionMode ?? 'active',
+                engine: options.decisionEngine.name,
+                fallback: true,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    const selectedBy = evidence.engine && !evidence.fallback ? 'execution-router:laya' : 'execution-router:fallback';
     const routing = {
         provider: selected.model.provider,
         model: selected.model.model,
@@ -173,7 +300,7 @@ export async function routeExecution(workers, requirements, options = {}) {
         reasoning: options.routingConstraints?.reasoning ?? selected.model.reasoning,
         decidedBy: selectedBy,
         decidedAt: new Date().toISOString(),
-        decisionEvidence: choice.evidence,
+        decisionEvidence: evidence,
     };
     const audit = makeExecutionDecisionAudit({
         task: options.auditTask,
@@ -200,7 +327,7 @@ export async function routeExecution(workers, requirements, options = {}) {
         await options.auditStore.append(audit);
     return {
         candidate: { ...selected.worker, routing },
-        selection: workerSelection(selected.worker, selectedBy, choice.evidence),
+        selection: workerSelection(selected.worker, selectedBy, evidence),
         model: selected.model,
         audit,
     };

package/dist/relayd.js

@@ -397,6 +397,7 @@ export async function runDaemon(argv) {
                 reasoning: result.candidate.routing.reasoning,
             },
             probabilities: result.candidate.routing.decisionEvidence?.probabilities ?? {},
+            proposedFields: result.candidate.routing.decisionEvidence?.proposedFields ?? {},
             fallback: result.candidate.routing.decisionEvidence?.fallback ?? false,
             current: {
                 chatgptRunning: runtime.workers.chatgpt,

package/dist/router-evals.js

@@ -12,12 +12,12 @@ export const ROUTER_EVAL_CASES = [
     { id: 'workspace-exhausted', storySize: 'S', task: 'Review a focused issue while Browser Workspace has no free slot.', chatgptAvailable: false, chatgptSlots: 0, expectedWorker: 'codex' },
     { id: 'large-workspace-available', storySize: 'L', task: 'Implement a large feature even though ChatGPT workspace capacity is healthy.', chatgptAvailable: true, expectedWorker: 'codex' },
 ];
-const CODEX_ROUTE = 'codex::default:openai/gpt-5.6-sol@medium';
-const CHATGPT_ROUTE = 'chatgpt/browser-worker::chatgpt/account-defaults';
+const CODEX_ROUTE = 'codex/openai/default';
+const CHATGPT_ROUTE = 'chatgpt/browser-worker/chatgpt/default';
 function workerForRoute(route) {
     if (route.startsWith('chatgpt/'))
         return 'chatgpt';
-    if (route.startsWith('codex::'))
+    if (route.startsWith('codex/'))
         return 'codex';
     return 'unknown';
 }
@@ -28,29 +28,31 @@ export async function runRouterEvals(engine, rulesPath) {
         const taskShape = executionTaskShape({ storySize: testCase.storySize });
         const available = testCase.chatgptAvailable;
         const choices = available ? [CODEX_ROUTE, CHATGPT_ROUTE] : [CODEX_ROUTE];
-        const eligibleRoutes = [
+        const workerCandidates = [
             {
-                id: CODEX_ROUTE,
-                worker: 'codex',
-                provider: 'openai',
-                model: 'gpt-5.6-sol',
-                profile: null,
-                reasoning: 'medium',
-                code_plan: { five_hour: null, weekly: null },
+                id: 'codex',
+                adapter: 'codex',
+                providers: {
+                    openai: {
+                        default: { model: 'gpt-5.6-sol', reasoning: 'medium' },
+                        code_plan: { five_hour: null, weekly: null },
+                    },
+                },
             },
             ...(available ? [{
-                    id: CHATGPT_ROUTE,
-                    worker: 'chatgpt',
-                    provider: 'chatgpt',
-                    model: 'account-defaults',
-                    profile: null,
-                    reasoning: null,
-                    code_plan: { five_hour: null, weekly: null },
+                    id: 'chatgpt/browser-worker',
+                    adapter: 'chatgpt',
+                    providers: {
+                        chatgpt: {
+                            default: { model: 'account-defaults', reasoning: null },
+                            code_plan: { five_hour: null, weekly: null },
+                        },
+                    },
                 }] : []),
         ];
-        const facts = {
+        const facts = JSON.parse(JSON.stringify({
             context: {
-                job: { id: 'router-eval', title: 'Router eval', objective: 'Evaluate worker and model route selection.' },
+                job: { id: 'router-eval', title: 'Router eval', objective: 'Evaluate worker and provider route selection.' },
                 task: { id: testCase.id, kind: 'work', storySize: testCase.storySize, input: testCase.task },
                 task_shape: {
                     story_size: taskShape.storySize,
@@ -62,13 +64,16 @@ export async function runRouterEvals(engine, rulesPath) {
             },
             user_input_rules: rules.text,
             runtime: { chatgpt_running: testCase.chatgptRunning ?? 0, preferred_chatgpt_concurrency: 10 },
-            eligible_routes: eligibleRoutes,
-        };
+            worker_candidates: workerCandidates,
+            routing_instruction: 'For each selected provider, use its default model and reasoning unless user_input_rules explicitly provides another model/reasoning option.',
+        }));
         const decision = await engine.decide({ facts }, {
             type: 'choice',
-            question: 'Choose one eligible complete execution route. Treat context.task_shape.preferred_worker as the default worker-fit signal; user_input_rules and concrete runtime or code-plan resource facts may override it. The choice identifies worker, provider, model, profile, and reasoning together.',
+            question: 'Choose one legal route. Each provider default is available. Additional model/reasoning routes exist only when explicitly provided by user_input_rules. Use context, code-plan quota, runtime load, and user_input_rules.',
             choices,
         });
+        if (decision.type !== 'choice')
+            throw new Error('Router eval expected a single-choice decision');
         const selectedWorker = workerForRoute(decision.choice);
         results.push({
             ...testCase,

package/package.json

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