agents-relay 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,91 @@
+name: Build, test, and publish
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+
+concurrency:
+  group: npm-publish-main
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+      - run: npm ci
+      - run: npm test
+      - run: chmod +x dist/cli.js dist/relayd.js
+      - name: Select next package version
+        id: version
+        shell: bash
+        run: |
+          error_file="$(mktemp)"
+          trap 'rm -f "$error_file"' EXIT
+          if current="$(npm view agents-relay version --registry=https://registry.npmjs.org 2>"$error_file")"; then
+            :
+          elif grep -q 'E404' "$error_file"; then
+            current=""
+          else
+            cat "$error_file" >&2
+            exit 1
+          fi
+          for attempt in 1 2 3 4 5; do
+            next="$(node scripts/npm-version.mjs "$current")"
+            if npm view "agents-relay@$next" version --registry=https://registry.npmjs.org >/dev/null 2>&1; then
+              current="$next"
+              continue
+            fi
+            break
+          done
+          if npm view "agents-relay@$next" version --registry=https://registry.npmjs.org >/dev/null 2>&1; then
+            echo 'Unable to find an unused npm patch version after five attempts' >&2
+            exit 1
+          fi
+          package_version="$(node -p "require('./package.json').version")"
+          if [ "$package_version" != "$next" ]; then
+            npm version "$next" --no-git-tag-version --ignore-scripts
+          else
+            echo "package.json is already $next; publishing the initial version without rewriting it."
+          fi
+          echo "version=$next" >> "$GITHUB_OUTPUT"
+      - name: Verify package contents
+        run: |
+          test -x dist/cli.js
+          test -x dist/relayd.js
+          npm pack --dry-run --json > pack.json
+          node -e 'const pack = require("./pack.json")[0]; const bins = new Map(pack.files.map(file => [file.path, file.mode])); for (const file of ["dist/cli.js", "dist/relayd.js"]) { if (bins.get(file) !== 0o755) throw new Error(`${file} is not executable in the package`); }'
+      - name: Publish package
+        shell: bash
+        run: |
+          set -o pipefail
+          publish_error="$(mktemp)"
+          trap 'rm -f "$publish_error"' EXIT
+          if npm publish --access public 2> >(tee "$publish_error" >&2); then
+            exit 0
+          fi
+          if grep -Eq 'EPUBLISH|previously published|cannot publish over' "$publish_error" \
+            && [ "$(npm view agents-relay version --registry=https://registry.npmjs.org 2>/dev/null || true)" = "${{ steps.version.outputs.version }}" ]; then
+            echo "agents-relay@${{ steps.version.outputs.version }} is already published; treating this run as idempotent."
+            exit 0
+          fi
+          exit 1
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Tag published version
+        shell: bash
+        run: |
+          tag="v${{ steps.version.outputs.version }}"
+          if git ls-remote --exit-code --refs origin "refs/tags/$tag" >/dev/null 2>&1; then
+            echo "$tag already exists; leaving the existing release tag in place."
+            exit 0
+          fi
+          git tag "$tag"
+          git push origin "refs/tags/$tag"

package/AGENTS.md

@@ -0,0 +1,16 @@
+# Working on Agents Relay
+
+Agents Relay is a generic, shareable async-agent runtime and skill.
+
+## Principles
+
+- GitHub PR state is durable truth. Events are wake-up/observability signals, never durable truth.
+- Reconcile desired durable state into ephemeral worker executions.
+- One top-level objective maps to one PR; child tasks live inside that PR.
+- Agents may submit child tasks; task lineage is explicit.
+- Workers are replaceable and recoverable. Results and state must survive worker or daemon death.
+- Keep provider/model routing separate from roles and capabilities.
+- Prefer standard library and small dependencies; do not build a second database when GitHub already holds the durable state.
+- TypeScript must use explicit types and avoid `any`.
+- UI must remain usable without a frontend framework unless a framework becomes necessary.
+- Tests must cover state transitions, parser/serialization, reconciliation, and recovery-sensitive logic.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cheng Li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+# Agents Relay
+
+Agents Relay is a generic TypeScript runtime for durable asynchronous agent jobs coordinated through GitHub pull requests. GitHub PR comments are the source of truth; events only wake the reconciler and update the dashboard.
+
+## Quick start
+
+For GitHub-backed work, create or adopt the PR through Agents Relay itself. This guarantees the durable job marker exists before any managed task is submitted.
+
+~~~sh
+npx agents-relay job create --repo OWNER/REPO --head feat/example --base main \
+  --id job-1 --title "Objective" --body "PR description" --mode fixed
+
+npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 \
+  --task-id child --input "echo hello" --adapter shell
+
+npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id job-1
+npx agents-relay status --repo OWNER/REPO --pr 12 --id job-1
+~~~
+
+Jobs default to `fixed`, preserving the original submit-and-run behavior. Use
+`--mode autonomous` with `init` or `job create` to make reconciliation own
+planner progress. The durable status JSON and dashboard show the mode. An
+autonomous runtime needs `--planner-command`; it receives the objective/task
+snapshot as JSON on stdin and must return `{ "objective_status": "in_progress"|"satisfied", "assessment": "...", "next_tasks": [...] }`.
+Planner-created tasks use stable IDs and the existing parent/subtask tree, so
+retries and daemon restarts do not create duplicate work.
+
+job create first resolves an existing open PR with the same head/base, then creates it only when needed. Re-running it is idempotent: it reuses the PR and maintains exactly one trusted agents-relay:job:v1 marker.
+
+To adopt an existing unmanaged PR, including a PR with no comments:
+
+~~~sh
+npx agents-relay job adopt --repo OWNER/REPO --pr 6 --id job-6 --title "Existing objective"
+~~~
+
+Use job repair with the same arguments to repair duplicate same-job markers. A conflicting marker for another job is rejected rather than overwritten.
+
+~~~sh
+npx agents-relay job repair --repo OWNER/REPO --pr 6 --id job-6
+~~~
+
+Managed GitHub submit/status/reconcile/retry/cancel/serve commands require the durable job marker. If it is missing, the CLI fails with a message directing the caller to job adopt. Orchestrators do not need raw gh PR/comment commands: Agents Relay uses GhApiClient and GitHubStore internally.
+
+The original init command remains supported for backward compatibility:
+
+~~~sh
+npx agents-relay init --repo OWNER/REPO --pr 1 --id job-1 --title "Objective"
+~~~
+
+## npm publishing
+
+Pushes to `main` run `.github/workflows/publish.yml`: install, test, choose the next npm version, pack-check, publish, and create the matching `vX.Y.Z` tag. Feature branches do not edit `package.json` versions. If `agents-relay` is not published yet the first release is `1.0.0`; later releases increment only the patch version from the npm registry. The repository must provide an `NPM_TOKEN` Actions secret with permission to publish the public `agents-relay` package.
+
+Normal consumers should invoke the CLI with `npx agents-relay ...` (or `npx agents-relayd ...`).
+
+For explicit local demo/test mode:
+
+~~~sh
+npm install
+npm run build
+node dist/cli.js init --file .agents-relay.json --title "Dogfood" --id demo
+node dist/cli.js submit --file .agents-relay.json --task-id hello --input "echo hello" --adapter shell
+node dist/cli.js reconcile --file .agents-relay.json
+npx agents-relay serve --file .agents-relay.json
+~~~
+
+Open the dashboard on localhost port 8787. The marker format is intentionally public and append-friendly; the CLI uses GitHubStore with the authenticated gh client in operational mode.
+
+reconcile leases and launches ready tasks without waiting inside the runtime scheduler; the CLI waits only long enough for its launched workers to persist results. agents-relayd (or the equivalent npx agents-relay serve) is the watchdog/dashboard mode and can use --events nats --subject-prefix PREFIX for optional wakeups. See [docs/service.md](docs/service.md). --file PATH is explicit local demo/test mode only.
+
+`agents-relayd` without `--pr`/`--id` runs in workspace mode by default: it discovers nested Git repositories under `~/Workspace`, keeps only GitHub `origin` remotes, and aggregates their managed PR jobs into one dashboard and worker pool. Pass `--workspace PATH` to use another root. `--repo OWNER/REPO` remains the single-repository pool mode.
+
+For automation, Agents Relay can use GitHub App installation authentication via `AGENTS_RELAY_GITHUB_APP_ID`, `AGENTS_RELAY_GITHUB_APP_INSTALLATION_ID`, and `AGENTS_RELAY_GITHUB_APP_PRIVATE_KEY_FILE` (or matching CLI flags). Webhook mode is cache-first: targeted webhook reconciliation is primary, dashboard auto-refresh reads cached job state, and the broad watchdog drops to a 30-minute fallback. See [docs/github-app-rate-limit.md](docs/github-app-rate-limit.md).
+
+V1 assumes one active runner/daemon per job. Use a distributed atomic lease before running multiple reconcilers. Do not put secrets, credentials, private prompts, or large private payloads in PR marker comments; store only summaries and artifact references.
+
+Codex/model-backed tasks require --provider and --model (or equivalent routing metadata) before launch. See [docs/architecture.md](docs/architecture.md) and [skills/agents-relay/SKILL.md](skills/agents-relay/SKILL.md).
+
+The minimal agent-network surface is machine-driven registration and discovery. `agent-register` persists an agent identity, responsibility boundary, claimed capabilities, endpoint/runtime, availability, and routing metadata in a trusted PR marker; `agent-discover` applies hard filters and returns evidence-backed candidates. Adapters remain runtimes, not agent identities. See [docs/architecture.md](docs/architecture.md) for the constrained future remote submission contract.
+
+### ChatGPT workers through MacBridge
+
+Use the chatgpt adapter to make a relay task create a real ChatGPT web conversation through the local MacBridge runtime. The returned ChatGPT conversation_id is stored as the task threadId, so lineage is durable and a retry continues the same conversation.
+
+Managed Codex and ChatGPT worker prompts automatically receive the durable PR URL plus job/task/parent/project context before the original task input. The stored task input is not rewritten.
+
+Each ChatGPT task owns its own conversation. Retries reuse that task's conversation; sibling tasks never share a conversation merely because they use the same adapter. When the job reaches COMPLETED, or GitHub reports the PR merged, Agents Relay deletes every ChatGPT task conversation through MacBridge. The durable threadId remains in the task marker with threadDeletedAt for audit history. Failed deletion records threadCleanupError and is retried on later reconciliation without reopening the terminal job.
+
+~~~sh
+npx agents-relay submit --repo OWNER/REPO --pr 5 --id job-1 \
+  --task-id research-ui --adapter chatgpt \
+  --capabilities model,chatgpt,macbridge \
+  --provider openai --model gpt-5-6-sol --reasoning high \
+  --chatgpt-project g-p-EXACT_PROJECT_ID \
+  --input "Research the dashboard UX and return implementation guidance."
+~~~
+
+The adapter calls MacBridge's loopback-only /experimental/chatgpt/conversation endpoint. Configure it with --macbridge-url and --macbridge-token-file, or AGENTS_RELAY_MACBRIDGE_URL / AGENTS_RELAY_MACBRIDGE_TOKEN_FILE. By default it uses loopback port MAC_DEV_BRIDGE_HTTP_PORT (or 8788) and the MacBridge menu app token file under ~/Library/Application Support/MacDeveloperBridge/http-token. Secrets are read locally and are never stored in PR markers.
+
+GitHub PR state is authoritative for terminal lifecycle: a merged PR reconciles its managed job to `COMPLETED`; a closed, unmerged PR reconciles to `CANCELLED` and cannot launch queued work. The dashboard exposes `/api/jobs` and shows repository-wide managed PR state beside each durable Agents Relay job state so stale markers are visible instead of being mistaken for current truth.
+
+For work that was completed outside the relay but must be represented truthfully in durable history, use `npx agents-relay record --task-id <id> --summary <summary> --commit <sha>`. Recorded tasks use the `orchestrator` adapter and terminal `SUCCEEDED` state; they do not pretend a shell/model worker executed the work. This is a repair/backfill mechanism—normal work should be submitted before execution. Managed jobs also retain the GitHub PR body as the job description for dashboard display.

package/dist/adapters.js

@@ -0,0 +1,311 @@
+import { spawn } from 'node:child_process';
+import { readFile, readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+function commandExecution(child, output, signal, id) { const promise = new Promise((resolve, reject) => { child.on('error', reject); child.on('close', code => code === 0 ? resolve({ summary: output().trim() || 'Command completed' }) : reject(new Error(output().trim() || `Command exited ${code}`))); signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true }); }); return { id, promise, cancel: () => { child.kill('SIGTERM'); } }; }
+export function buildCodexArgs(route, input) {
+    const args = ['exec', '--json'];
+    if (route.profile)
+        args.push('-p', route.profile);
+    if (route.model)
+        args.push('-m', route.model);
+    if (route.provider)
+        args.push('-c', `model_provider=${route.provider}`);
+    if (route.reasoning)
+        args.push('-c', `model_reasoning_effort=${route.reasoning}`);
+    if (route.cwd)
+        args.push('-C', route.cwd);
+    args.push('--', input);
+    return args;
+}
+function parseThreadStarted(line) { try {
+    const value = JSON.parse(line);
+    return value.type === 'thread.started' && typeof value.thread_id === 'string' ? value.thread_id : undefined;
+}
+catch {
+    return undefined;
+} }
+function parseCodexAssistantMessage(line) {
+    try {
+        const value = JSON.parse(line);
+        const payload = value.payload;
+        if (value.type === 'event_msg' && payload?.type === 'task_complete' && typeof payload.last_agent_message === 'string')
+            return payload.last_agent_message.trim() || undefined;
+        const item = value.item;
+        if (value.type === 'item.completed' && item?.type === 'agent_message' && typeof item.text === 'string')
+            return item.text.trim() || undefined;
+    }
+    catch { /* non-JSON diagnostic output is ignored on successful Codex runs */ }
+    return undefined;
+}
+function appendTail(current, chunk, maxBytes = 16384) {
+    const combined = current + chunk;
+    return Buffer.byteLength(combined) <= maxBytes ? combined : Buffer.from(combined).subarray(-maxBytes).toString('utf8');
+}
+export class ShellAdapter {
+    shell;
+    name = 'shell';
+    id = 'shell';
+    capabilities = ['shell', 'command'];
+    constructor(shell = false) {
+        this.shell = shell;
+    }
+    launch(task, signal) { const parts = task.input.split(' ').filter(Boolean); const child = this.shell ? spawn(task.input, { shell: true }) : spawn(parts[0] ?? 'true', parts.slice(1)); let output = ''; child.stdout?.on('data', (x) => { output += x.toString(); }); child.stderr?.on('data', (x) => { output += x.toString(); }); return commandExecution(child, () => output, signal, randomUUID()); }
+}
+export class CodexAdapter {
+    command;
+    sessionsRoot;
+    name = 'codex';
+    id = 'codex';
+    capabilities = ['model', 'codex'];
+    constructor(command = 'codex', sessionsRoot = join(homedir(), '.codex', 'sessions')) {
+        this.command = command;
+        this.sessionsRoot = sessionsRoot;
+    }
+    launch(task, signal) {
+        if (!task.routing)
+            throw new Error(`Task ${task.id} requires routing metadata before Codex launch`);
+        const route = task.routing;
+        const args = buildCodexArgs(route, task.input);
+        const child = spawn(this.command, args, { shell: false, cwd: route.cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdoutBuffer = '';
+        let finalAssistantMessage = '';
+        let stderrTail = '';
+        let bufferedThreadId;
+        let execution;
+        const consumeLine = (line) => {
+            const threadId = parseThreadStarted(line);
+            if (threadId) {
+                bufferedThreadId = threadId;
+                if (execution) {
+                    execution.threadId = threadId;
+                    execution.onThreadStarted?.(threadId);
+                }
+            }
+            const assistantMessage = parseCodexAssistantMessage(line);
+            if (assistantMessage)
+                finalAssistantMessage = assistantMessage;
+        };
+        child.stdout?.on('data', (x) => {
+            stdoutBuffer += x.toString();
+            const lines = stdoutBuffer.split(/\r?\n/);
+            stdoutBuffer = lines.pop() ?? '';
+            for (const line of lines)
+                consumeLine(line);
+        });
+        child.stderr?.on('data', (x) => { stderrTail = appendTail(stderrTail, x.toString()); });
+        const id = randomUUID();
+        const promise = new Promise((resolve, reject) => {
+            child.on('error', reject);
+            child.on('close', code => {
+                if (stdoutBuffer)
+                    consumeLine(stdoutBuffer);
+                if (code === 0)
+                    resolve({ summary: finalAssistantMessage || 'Codex task completed' });
+                else
+                    reject(new Error(stderrTail.trim() || `Codex exited ${code}`));
+            });
+            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+        });
+        execution = { id, promise, cancel: () => { child.kill('SIGTERM'); } };
+        execution.threadId = bufferedThreadId;
+        return execution;
+    }
+    async recover(task) {
+        if (!task.threadId)
+            return null;
+        let entries;
+        try {
+            entries = await readdir(this.sessionsRoot, { recursive: true, encoding: 'utf8' });
+        }
+        catch {
+            return null;
+        }
+        const filename = entries.find(entry => entry.endsWith(`${task.threadId}.jsonl`));
+        if (!filename)
+            return null;
+        let lines;
+        try {
+            lines = (await readFile(join(this.sessionsRoot, filename), 'utf8')).split(/\r?\n/);
+        }
+        catch {
+            return null;
+        }
+        for (let index = lines.length - 1; index >= 0; index -= 1) {
+            const line = lines[index];
+            if (!line)
+                continue;
+            try {
+                const value = JSON.parse(line);
+                if (value.type !== 'event_msg')
+                    continue;
+                const payload = value.payload;
+                if (payload?.type !== 'task_complete')
+                    continue;
+                const summary = typeof payload.last_agent_message === 'string' ? payload.last_agent_message.trim() : '';
+                return { summary: summary || 'Codex task completed', data: { recoveredFromThread: task.threadId } };
+            }
+            catch { /* ignore malformed session rows */ }
+        }
+        return null;
+    }
+}
+function chatGptThinkingEffort(reasoning) {
+    if (reasoning === 'minimal' || reasoning === 'low' || reasoning === 'standard' || reasoning === 'high' || reasoning === 'max')
+        return reasoning;
+    if (reasoning === 'medium')
+        return 'standard';
+    if (reasoning === 'xhigh' || reasoning === 'extra-high')
+        return 'max';
+    return 'standard';
+}
+function chatGptEndpoint(base) {
+    const configured = (base ?? process.env.AGENTS_RELAY_MACBRIDGE_URL ?? `http://127.0.0.1:${process.env.MAC_DEV_BRIDGE_HTTP_PORT ?? '8788'}`).replace(/\/+$/, '');
+    const url = new URL(configured);
+    if (url.pathname === '/experimental/chatgpt/conversation')
+        return url.toString().replace(/\/$/, '');
+    // --macbridge-url is a service origin. Do not inherit an unrelated API path
+    // such as /v1/responses from a model-router endpoint.
+    url.pathname = '/experimental/chatgpt/conversation';
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+}
+function chatGptTokenFile(file) {
+    return file ?? process.env.AGENTS_RELAY_MACBRIDGE_TOKEN_FILE ?? process.env.MAC_DEV_BRIDGE_HTTP_TOKEN_FILE ?? join(homedir(), 'Library', 'Application Support', 'MacDeveloperBridge', 'http-token');
+}
+function chatGptConversationId(text) {
+    const match = /\"conversation_id\"\s*:\s*\"((?:\\.|[^\"\\])*)\"/.exec(text);
+    if (!match)
+        return undefined;
+    try {
+        const value = JSON.parse(`\"${match[1]}\"`);
+        return typeof value === 'string' ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readChatGptResponse(response, onConversationId) {
+    if (!response.body) {
+        const text = await response.text();
+        const conversationId = chatGptConversationId(text);
+        if (conversationId)
+            onConversationId(conversationId);
+        return text;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let text = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        text += decoder.decode(value, { stream: true });
+        const conversationId = chatGptConversationId(text);
+        if (conversationId)
+            onConversationId(conversationId);
+    }
+    text += decoder.decode();
+    const conversationId = chatGptConversationId(text);
+    if (conversationId)
+        onConversationId(conversationId);
+    return text;
+}
+export class ChatGptAdapter {
+    name = 'chatgpt';
+    id = 'chatgpt/macbridge';
+    capabilities = ['model', 'chatgpt', 'macbridge'];
+    endpoint;
+    tokenFile;
+    fetchImpl;
+    constructor(options = {}) {
+        this.endpoint = chatGptEndpoint(options.endpoint);
+        this.tokenFile = chatGptTokenFile(options.tokenFile);
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async deleteThread(threadId) {
+        const token = (await readFile(this.tokenFile, 'utf8')).trim();
+        if (!token)
+            throw new Error(`MacBridge token file is empty: ${this.tokenFile}`);
+        const response = await this.fetchImpl(this.endpoint, {
+            method: 'DELETE',
+            headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+            body: JSON.stringify({ conversation_id: threadId }),
+        });
+        if (response.status === 404)
+            return;
+        if (!response.ok) {
+            let detail = '';
+            try {
+                const payload = await response.json();
+                detail = typeof payload.error === 'string' ? payload.error : '';
+            }
+            catch { }
+            throw new Error(detail || `MacBridge ChatGPT conversation delete failed (${response.status})`);
+        }
+    }
+    launch(task, signal) {
+        if (!task.routing)
+            throw new Error(`Task ${task.id} requires routing metadata before ChatGPT launch`);
+        const route = task.routing;
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        if (signal.aborted)
+            abort();
+        else
+            signal.addEventListener('abort', abort, { once: true });
+        const execution = { id: randomUUID(), promise: Promise.resolve({ summary: '' }), cancel: abort };
+        execution.promise = (async () => {
+            const token = (await readFile(this.tokenFile, 'utf8')).trim();
+            if (!token)
+                throw new Error(`MacBridge token file is empty: ${this.tokenFile}`);
+            const body = {
+                prompt: task.input,
+                model: route.model,
+                thinking_effort: chatGptThinkingEffort(route.reasoning),
+                max_runtime_seconds: Math.max(30, Math.min(3600, Math.ceil(task.timeoutMs / 1000))),
+            };
+            if (route.projectId)
+                body.project_id = route.projectId;
+            if (task.threadId)
+                body.conversation_id = task.threadId;
+            const response = await this.fetchImpl(this.endpoint, {
+                method: 'POST',
+                headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            let exposedConversationId;
+            const exposeConversationId = (conversationId) => {
+                if (exposedConversationId === conversationId)
+                    return;
+                exposedConversationId = conversationId;
+                execution.threadId = conversationId;
+                execution.onThreadStarted?.(conversationId);
+            };
+            const text = await readChatGptResponse(response, exposeConversationId);
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                throw new Error(`MacBridge returned unreadable ChatGPT response (${response.status})`);
+            }
+            const conversationId = typeof payload.conversation_id === 'string' ? payload.conversation_id : exposedConversationId;
+            if (conversationId)
+                exposeConversationId(conversationId);
+            if (!response.ok)
+                throw new Error(typeof payload.error === 'string' ? payload.error : `MacBridge ChatGPT request failed (${response.status})`);
+            if (payload.complete !== true)
+                throw new Error('MacBridge ChatGPT conversation did not complete');
+            const assistantText = typeof payload.assistant_text === 'string' ? payload.assistant_text.trim() : '';
+            return {
+                summary: assistantText || 'ChatGPT conversation completed',
+                data: { conversationId, provider: route.provider, model: route.model },
+            };
+        })();
+        return execution;
+    }
+}