agents-relay 2.0.57 → 2.0.58

package/README.md

@@ -230,9 +230,9 @@ Managed tasks are descriptive work for agents, not shell commands. Use `codex` o
 
 Every model-backed task declares a durable output with `--output task-pr` or `--output file --output-path PATH`. Agents Relay bootstraps workers with the managed PR URL, durable task-comment URL, job/task identity, project, output contract, and mandatory terminal-event contract; workers retrieve the task intent from GitHub rather than receiving a duplicate copy of the stored task prompt.
 
-For Codex and ChatGPT, **correlated worker events are authoritative lifecycle inputs**, not a separate durable store. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay subscribes, validates correlation, applies graph transitions, persists results in RelayStore, and projects them to GitHub. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The ChatGPT worker-owned tab follows the configured close policy: `after-start` waits for the correlated start acknowledgement, `never` keeps it open for debug, and `after-terminal` waits for a new exact-task terminal event; start-ack failure closes only the owned tab after 60 seconds. The executing agent must publish exactly one correlated terminal event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
+For Codex and ChatGPT, **correlated worker events are authoritative lifecycle inputs**, not a separate durable store. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay subscribes, validates correlation, applies graph transitions, persists results in RelayStore, and projects them to GitHub. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its one-shot submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The executing agent must publish exactly one correlated terminal event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
 
-The ChatGPT adapter uses Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and Browser Workspace `platforms/chatgpt` for all ChatGPT browser mechanics. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, and applies `--chatgpt-tab-close-policy` (or `AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY`): `after-start` by default, `never` for test/debug, or `after-terminal` after a new exact-task terminal event. It never closes a user tab and does not poll for the assistant response, resume/reopen a thread, or use conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
+The ChatGPT adapter uses Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and invokes Browser Workspace exactly as a one-shot platform action: `browser-workspace platform run chatgpt temporary-submit --auto-session --config <file>`. Browser Workspace owns creation/release of the fresh Temporary Chat session, selectors, attachments, and submit verification; Relay does not self-heal browser failures and instead lets delivery failures enter its normal retry/recovery lifecycle. Legacy `--chatgpt-tab-close-policy` values remain accepted for compatibility around Relay's event barriers, but they do not control the Browser Workspace auto-session lifetime. The adapter never uses a pre-existing user tab, polls for the assistant response, resumes/reopens a thread, or treats conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
 
 ~~~sh
 npx agents-relay task create --repo OWNER/REPO --pr 5 --id job-1 \
@@ -283,4 +283,4 @@ For autonomous Jobs, `UNBLOCKED` is historical: Relay does not retry that old Ta
 
 ### Browser Workspace product boundary
 
-Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `browser-workspace status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary worker/session activity remains on the public Browser Workspace CLI (`session start/exec/stop` and platform commands). Relay does not create or delete workspaces through CLI lifecycle commands.
+Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `browser-workspace status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary ChatGPT worker activity uses the public Browser Workspace one-shot `platform run ... --auto-session` command; orchestrator-owned self-healing flows may still use explicit session commands. Relay does not create or delete workspaces through CLI lifecycle commands.

package/agents/chatgpt-worker.agent.md

@@ -11,14 +11,12 @@ You execute one complete Relay task by submitting it to a fresh worker-owned Cha
 ## Contract
 
 - Browser Workspace `platforms/chatgpt` is the sole owner of ChatGPT selectors, readiness checks, attachments, Temporary Chat mechanics, and submit verification.
-- Relay owns worker lifecycle, task/event barriers, routing, cancellation, and tab/session close policy.
-- Execute only a one-shot submission. Do not expose a create/resume/status/result conversation lifecycle.
-- Always use a fresh worker-owned Browser Workspace session/tab. Never submit through a pre-existing user tab.
+- Relay owns worker lifecycle, task/event barriers, routing, and cancellation; Browser Workspace owns the one-shot auto-session lifecycle.
+- Execute only a one-shot submission with `platform run chatgpt temporary-submit --auto-session`. Do not expose a create/resume/status/result conversation lifecycle.
+- Let Browser Workspace create and release the fresh Temporary Chat session/tab for the action. Never submit through a pre-existing user tab.
 - Preserve the account's current default model/thinking settings.
 - A submission is accepted only after Browser Workspace returns a verified submit receipt.
 - Treat observed conversation/thread identity as diagnostic only, never as a resumable handle.
-- `after-start` releases the Browser Workspace session after the exact worker `task.started` barrier.
-- `after-terminal` releases it after the exact task terminal barrier.
-- `never` leaves the owned session open for test/debug.
+- Legacy ChatGPT tab-close policy values remain accepted by Relay for compatibility, but they do not control Browser Workspace's auto-session lifetime or add self-heal.
 - Do not wait for the assistant response. Durable task success/failure is event-owned by Relay and the executing task.
 - Stop on authentication, MFA, consent, or ambiguous browser state rather than bypassing it.

package/dist/adapters.js

@@ -151,20 +151,28 @@ function parseDriverJson(output) {
 function browserWorkspaceCli(override = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
     return override ? { command: override, prefix: [] } : { command: 'npx', prefix: ['browser-workspace'] };
 }
-function browserWorkspaceCommand(cli, args, stdin) {
+function browserWorkspaceCommand(cli, args, stdin, signal) {
     return new Promise((resolve, reject) => {
         const child = spawn(cli.command, [...cli.prefix, ...args], { shell: false, stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
+        const abort = () => terminateChild(child);
         child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
         child.stderr?.on('data', (chunk) => { stderr = appendTail(stderr, chunk.toString()); });
         child.on('error', reject);
         child.on('close', code => {
+            signal?.removeEventListener('abort', abort);
             if (code === 0)
                 resolve(stdout.trim());
+            else if (signal?.aborted)
+                reject(new Error('browser-worker execution aborted'));
             else
                 reject(new Error(stderr.trim() || stdout.trim() || `browser-workspace exited ${code}`));
         });
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener('abort', abort, { once: true });
         if (stdin !== undefined) {
             child.stdin?.end(stdin);
         }
@@ -191,86 +199,26 @@ export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
-function sessionBrowserWorkerRunner() {
+function autoSessionBrowserWorkerRunner() {
     const cli = browserWorkspaceCli();
     return (_definition, request, _route, signal) => {
-        const policy = request.tabClosePolicy ?? 'after-start';
-        let activeSessionId;
-        let released = false;
-        let releaseResolve;
-        const releaseBarrier = new Promise(resolve => { releaseResolve = resolve; });
-        const release = () => {
-            if (released)
-                return;
-            released = true;
-            releaseResolve();
-        };
-        let submittedResolve;
-        let submittedReject;
-        const submitted = new Promise((resolve, reject) => {
-            submittedResolve = resolve;
-            submittedReject = reject;
-        });
         const promise = (async () => {
             const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
             try {
                 await writeFile(configFile, JSON.stringify({
                     prompt: request.prompt,
                     file: request.files ?? [],
-                    close_policy: 'never',
                 }));
-                const startOutput = await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE]);
-                const started = parseWorkspaceJson(startOutput);
-                if (typeof started.session_id !== 'string') {
-                    throw new Error('browser-workspace session start returned no session_id');
-                }
-                activeSessionId = started.session_id;
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                const source = await browserWorkspaceCommand(cli, ['platform', 'source', 'chatgpt', 'temporary-submit', '--config', configFile]);
-                const execOutput = await browserWorkspaceCommand(cli, ['session', 'exec', activeSessionId], source);
-                const wrapper = parseWorkspaceJson(execOutput);
-                if (wrapper.ok !== true) {
-                    throw new Error(typeof wrapper.error === 'string' ? wrapper.error : 'browser-workspace session exec failed');
-                }
-                const receipt = parseDriverJson(typeof wrapper.stdout === 'string' ? wrapper.stdout : '');
-                const result = JSON.stringify(receipt);
-                submittedResolve(result);
-                if (policy === 'never') {
-                    await unlink(configFile).catch(() => { });
-                    activeSessionId = undefined;
-                    return result;
-                }
-                await releaseBarrier;
-                if (activeSessionId) {
-                    await browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]);
-                    activeSessionId = undefined;
-                }
-                return result;
+                const output = await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', 'temporary-submit', '--auto-session', '--config', configFile], undefined, signal);
+                return JSON.stringify(parseDriverJson(output));
             }
-            catch (failure) {
-                if (activeSessionId) {
-                    await browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]).catch(() => { });
-                    activeSessionId = undefined;
-                }
+            finally {
                 await unlink(configFile).catch(() => { });
-                const error = failure instanceof Error ? failure : new Error(String(failure));
-                submittedReject(error);
-                throw error;
             }
         })();
-        const cancel = () => {
-            release();
-            if (activeSessionId) {
-                void browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]);
-                activeSessionId = undefined;
-            }
-        };
-        if (signal.aborted)
-            cancel();
-        else
-            signal.addEventListener('abort', cancel, { once: true });
-        return { promise, submitted, release, cancel };
+        return { promise, submitted: promise, cancel: () => { } };
     };
 }
 function parseBrowserWorkerResponse(output) {
@@ -326,7 +274,7 @@ export class ChatGptAdapter {
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? sessionBrowserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? autoSessionBrowserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);
@@ -335,7 +283,7 @@ export class ChatGptAdapter {
                     await context.waitForWorkerStart;
                 else if (policy === 'after-terminal') {
                     if (!context.waitForTerminal)
-                        throw new Error('ChatGPT after-terminal tab close policy requires a terminal event barrier');
+                        throw new Error('ChatGPT after-terminal compatibility policy requires a terminal event barrier');
                     await context.waitForTerminal;
                 }
                 if (policy !== 'never')

package/package.json

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