agents-relay 2.0.43 → 2.0.44

package/README.md

@@ -227,7 +227,7 @@ Every model-backed task declares a durable output with `--output task-pr` or `--
 
 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.
 
-The ChatGPT adapter uses the `chatgpt-browser-worker` path selected by the shared execution-context resolver; Relay does not bundle its own copy. The resolver applies project-local > Neo shared > global `~/.agents` precedence at execution time, so durable tasks store names/intent rather than stale absolute skill paths. 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 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.
 
 ~~~sh
 npx agents-relay task create --repo OWNER/REPO --pr 5 --id job-1 \

package/dist/adapters.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-import { access, readFile, writeFile, unlink } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { readFile, writeFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 export function buildCodexArgs(route, input) {
     const args = ['exec', '--json'];
@@ -132,24 +132,6 @@ export class LaunchFailure extends Error {
 }
 export class StartAckTimeout extends LaunchFailure {
 }
-async function loadBrowserWorkerRuntime(context, explicit) {
-    const resolvedSkill = context?.skills.find(skill => skill.name === 'chatgpt-browser-worker');
-    // Once a worker receives a resolved execution context, that context owns
-    // skill discovery. The explicit path remains the fallback for direct
-    // adapter use, where no shared context has been resolved yet.
-    const candidate = resolvedSkill
-        ? join(dirname(resolvedSkill.path), 'agents', 'browser-worker.agent.md')
-        : explicit;
-    if (!candidate)
-        throw new Error('chatgpt-browser-worker is not visible in the resolved execution context');
-    try {
-        await access(candidate);
-        return { definition: await readFile(candidate, 'utf8'), root: dirname(dirname(candidate)) };
-    }
-    catch {
-        throw new Error(`chatgpt-browser-worker agent definition not found at resolved path: ${candidate}`);
-    }
-}
 function parseDriverJson(output) {
     const lines = output.trim().split(/\r?\n/).filter(Boolean);
     for (let index = lines.length - 1; index >= 0; index -= 1) {
@@ -200,7 +182,7 @@ function parseWorkspaceJson(output) {
 export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
     await browserWorkspaceCommand(browserWorkspaceCli(command), ['create', CHATGPT_BROWSER_WORKSPACE, String(CHATGPT_BROWSER_WORKSPACE_POOL_SIZE)]);
 }
-function sessionBrowserWorkerRunner(root) {
+function sessionBrowserWorkerRunner() {
     const cli = browserWorkspaceCli();
     return (_definition, request, _route, signal) => {
         const policy = request.tabClosePolicy ?? 'after-start';
@@ -223,16 +205,10 @@ function sessionBrowserWorkerRunner(root) {
         const promise = (async () => {
             const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
             try {
-                const [readiness, submitSource, temporarySource] = await Promise.all([
-                    readFile(join(root, 'scripts', '_submit_readiness.py'), 'utf8'),
-                    readFile(join(root, 'scripts', '_submit_bh.py'), 'utf8'),
-                    readFile(join(root, 'scripts', '_temporary_bh.py'), 'utf8'),
-                ]);
                 await writeFile(configFile, JSON.stringify({
                     prompt: request.prompt,
                     file: request.files ?? [],
-                    close_policy: policy,
-                    release_file: '',
+                    close_policy: 'never',
                 }));
                 const startOutput = await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE]);
                 const started = parseWorkspaceJson(startOutput);
@@ -242,12 +218,7 @@ function sessionBrowserWorkerRunner(root) {
                 activeSessionId = started.session_id;
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                const escapedConfig = configFile.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
-                const source = [
-                    readiness,
-                    submitSource.replace(/^from browser_harness import \*\s*$/m, ''),
-                    temporarySource.replace(/^_wait_for_release\(\)\s*$/m, ''),
-                ].join('\n\n').replaceAll('__CFG_PATH__', escapedConfig);
+                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) {
@@ -316,11 +287,9 @@ export class ChatGptAdapter {
     name = 'chatgpt';
     id = 'chatgpt/browser-worker';
     capabilities = ['model', 'chatgpt', 'browser-workspace'];
-    agentPath;
     runner;
     tabClosePolicy;
     constructor(options = {}) {
-        this.agentPath = options.agentPath ?? process.env.AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT;
         this.runner = options.agentRunner;
         this.tabClosePolicy = chatGptTabClosePolicy(options.tabClosePolicy ?? process.env.AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY);
     }
@@ -344,11 +313,11 @@ export class ChatGptAdapter {
         execution.launched = new Promise((resolve, reject) => { launchResolve = resolve; launchReject = reject; });
         execution.launched.catch(() => { });
         execution.promise = (async () => {
-            const runtime = await loadBrowserWorkerRuntime(context.executionContext, this.agentPath);
+            const definition = await readFile(new URL('../agents/chatgpt-worker.agent.md', import.meta.url), 'utf8');
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? sessionBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? sessionBrowserWorkerRunner())(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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.43",
+  "version": "2.0.44",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {
@@ -10,7 +10,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli.js dist/relayd.js dist/relayd-main.js",
     "test": "npm run build && node --test 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\"",
+    "test:chatgpt-temp-quality": "AGENTS_RELAY_RUN_CHATGPT_TEMP_QUALITY=1 sh -c \"npm run build && node test/quality/run-temporary-chat.mjs\"",
     "dev": "tsx src/cli.ts",
     "test:publish": "npm run build && node --test --test-force-exit test/*.test.js"
   },

package/skills/agents-relay/SKILL.md

@@ -91,7 +91,7 @@ Leaf workers consume the resolved instruction/skill/agent paths, not the full to
 
 ## ChatGPT worker
 
-The ChatGPT adapter uses the `chatgpt-browser-worker` path from the shared execution context; Relay does not bundle or independently rediscover that skill. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, applies the configured `after-start` (default), `never`, or `after-terminal` owned-tab close policy, and returns a submission receipt.
+The ChatGPT adapter uses Relay's `chatgpt-worker` agent contract and Browser Workspace ChatGPT platform; it does not depend on a Neo worker skill. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, applies the configured `after-start` (default), `never`, or `after-terminal` owned-tab close policy, and returns a submission receipt.
 
 ChatGPT thread identity is diagnostic only. It is not persisted as a resumable task handle, and Relay does not poll, resume, retrieve a result from, or delete a ChatGPT conversation as part of task lifecycle.