agents-relay 1.0.129 → 1.0.130

package/dist/usage.js

@@ -4,6 +4,67 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { spawn } from 'node:child_process';
+export class BrowserWorkspaceUsageReader {
+    command;
+    timeoutMs;
+    now;
+    staleAfterMs;
+    constructor(command = 'browser-harness', timeoutMs = 10_000, now = () => new Date(), staleAfterMs = 15 * 60_000) {
+        this.command = command;
+        this.timeoutMs = timeoutMs;
+        this.now = now;
+        this.staleAfterMs = staleAfterMs;
+    }
+    async read() {
+        const observedAt = this.now().toISOString();
+        return await new Promise(resolve => {
+            const child = spawn(this.command, [], { stdio: ['pipe', 'pipe', 'ignore'] });
+            let output = '';
+            let settled = false;
+            const finish = (capacity) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                child.kill();
+                resolve(capacity);
+            };
+            const unavailable = (reason) => ({ name: 'Harness', poolSize: null, idle: null, leased: null, available: null, observedAt, reason });
+            const timer = setTimeout(() => finish(unavailable('Browser Workspace capacity probe timed out.')), this.timeoutMs);
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', chunk => { output += chunk; });
+            child.once('error', () => finish(unavailable('Browser Workspace capacity probe could not be started.')));
+            child.once('close', code => {
+                if (settled)
+                    return;
+                const lines = output.trim().split('\n').reverse();
+                for (const line of lines) {
+                    try {
+                        const raw = JSON.parse(line);
+                        const name = typeof raw.name === 'string' ? raw.name : 'Harness';
+                        const rawObservedAt = typeof raw.observedAt === 'string' && !Number.isNaN(Date.parse(raw.observedAt)) ? raw.observedAt : observedAt;
+                        if (Date.parse(observedAt) - Date.parse(rawObservedAt) > this.staleAfterMs) {
+                            finish(unavailable('Browser Workspace capacity probe is stale.'));
+                            return;
+                        }
+                        const numberOrNull = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+                        const idle = numberOrNull(raw.idle);
+                        const leased = numberOrNull(raw.leased);
+                        const poolSize = numberOrNull(raw.poolSize);
+                        const available = typeof raw.available === 'boolean' ? raw.available : idle === null ? null : idle > 0;
+                        if (idle !== null || leased !== null || poolSize !== null || available !== null) {
+                            finish({ name, poolSize, idle, leased, available, observedAt: rawObservedAt, reason: null });
+                            return;
+                        }
+                    }
+                    catch { /* browser-harness may print startup diagnostics before JSON */ }
+                }
+                finish(unavailable(code === 0 ? 'Browser Workspace capacity probe returned no usable capacity.' : `Browser Workspace capacity probe exited with code ${code ?? 'unknown'}.`));
+            });
+            child.stdin.end('import json\nprint(json.dumps(workspace_capacity()))\n');
+        });
+    }
+}
 function finiteNumber(value) {
     if (typeof value === 'number' && Number.isFinite(value))
         return value;
@@ -320,18 +381,21 @@ export class UsageRegistry {
     zaiReader;
     deepSeekReader;
     openRouterReader;
-    constructor(openaiReader, zaiReader = new ZaiUsageReader(), deepSeekReader = null, openRouterReader = null) {
+    browserWorkspaceReader;
+    constructor(openaiReader, zaiReader = new ZaiUsageReader(), deepSeekReader = null, openRouterReader = null, browserWorkspaceReader = null) {
         this.openaiReader = openaiReader;
         this.zaiReader = zaiReader;
         this.deepSeekReader = deepSeekReader;
         this.openRouterReader = openRouterReader;
+        this.browserWorkspaceReader = browserWorkspaceReader;
     }
     async snapshot() {
-        const [openai, zai, deepseek, openrouter] = await Promise.all([
+        const [openai, zai, deepseek, openrouter, browserWorkspace] = await Promise.all([
             this.openaiReader.read(),
             this.zaiReader.read(),
             this.deepSeekReader?.read() ?? Promise.resolve(null),
             this.openRouterReader?.read() ?? Promise.resolve(null),
+            this.browserWorkspaceReader?.read() ?? Promise.resolve(null),
         ]);
         const credits = [];
         if (deepseek)
@@ -345,6 +409,7 @@ export class UsageRegistry {
                 { id: 'zai', label: 'Z.ai', usage: zai },
             ],
             credits,
+            ...(browserWorkspace ? { browserWorkspace } : {}),
         };
     }
 }
@@ -370,5 +435,5 @@ export class UnavailableUsageReader {
     }
 }
 export function codexAndZaiUsageRegistry(codexHome, _legacyWindowDays) {
-    return new UsageRegistry(new CodexApiUsageReader(), new ZaiUsageReader(), process.env.DEEPSEEK_API_KEY ? new DeepSeekCreditReader() : null, process.env.OPENROUTER_API_KEY ? new OpenRouterCreditReader() : null);
+    return new UsageRegistry(new CodexApiUsageReader(), new ZaiUsageReader(), process.env.DEEPSEEK_API_KEY ? new DeepSeekCreditReader() : null, process.env.OPENROUTER_API_KEY ? new OpenRouterCreditReader() : null, new BrowserWorkspaceUsageReader());
 }

package/dist/worker-routing.js

@@ -68,6 +68,7 @@ export function workerCandidates(adapters, registered, snapshot) {
                 resourceResetAt: resource.resetAt,
                 resourceResetInMinutes: resource.resetInMinutes,
                 resourceWindows: resource.windows,
+                browserWorkspaceCapacity: adapter.name === 'chatgpt' ? snapshot?.browserWorkspace : undefined,
             };
         });
     });
@@ -82,6 +83,8 @@ export function satisfiesWorker(candidate, requirements) {
         return false;
     if (requirements.runtime && candidate.runtime !== requirements.runtime)
         return false;
+    if (candidate.adapter === 'chatgpt' && candidate.browserWorkspaceCapacity?.idle === 0)
+        return false;
     return true;
 }
 export function eligibleWorkerCandidates(candidates, requirements) {
@@ -104,6 +107,7 @@ function selection(selected, selectedBy, decisionEvidence) {
         resourceResetAt: selected.resourceResetAt,
         resourceResetInMinutes: selected.resourceResetInMinutes,
         resourceWindows: selected.resourceWindows,
+        browserWorkspaceCapacity: selected.browserWorkspaceCapacity,
         decisionEvidence,
     };
 }
@@ -111,15 +115,21 @@ function selection(selected, selectedBy, decisionEvidence) {
 export function selectWorker(candidates, requirements) {
     const eligible = eligibleWorkerCandidates(candidates, requirements);
     if (eligible.length === 0)
-        throw new Error('No eligible worker satisfies the authoritative worker constraints');
+        throw new Error(noEligibleWorkerReason(candidates));
     const selected = deterministicWorker(eligible);
     return { candidate: selected, selection: selection(selected, 'worker-router:fallback') };
 }
+function noEligibleWorkerReason(candidates) {
+    if (candidates.some(candidate => candidate.adapter === 'chatgpt' && candidate.browserWorkspaceCapacity?.idle === 0)) {
+        return 'No eligible worker: ChatGPT Browser Workspace has no idle capacity.';
+    }
+    return 'No eligible worker satisfies the authoritative worker constraints';
+}
 /** Gather factual worker/task/resource context, then let decide() choose among legal workers. */
 export async function routeWorker(candidates, requirements, options = {}) {
     const eligible = eligibleWorkerCandidates(candidates, requirements);
     if (eligible.length === 0)
-        throw new Error('No eligible worker satisfies the authoritative worker constraints');
+        throw new Error(noEligibleWorkerReason(candidates));
     const preferredChatgptConcurrency = options.preferredChatgptConcurrency ?? DEFAULT_CHATGPT_PREFERRED_CONCURRENCY;
     const chatgptRunning = options.chatgptRunning ?? 0;
     const deterministic = deterministicWorker(eligible);
@@ -152,6 +162,7 @@ export async function routeWorker(candidates, requirements, options = {}) {
             resourceResetAt: item.resourceResetAt ?? null,
             resourceResetInMinutes: item.resourceResetInMinutes ?? null,
             resourceWindows: item.resourceWindows ?? null,
+            browserWorkspaceCapacity: item.browserWorkspaceCapacity ?? null,
         })),
     }));
     const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', { facts }, {

package/package.json

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