agents-relay 1.0.0

package/test/adapters.test.js

@@ -0,0 +1,303 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile, chmod } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { buildCodexArgs, CodexAdapter } from '../dist/adapters.js';
+
+test('buildCodexArgs applies provider, model, reasoning, cwd, and profile in order', () => {
+  const args = buildCodexArgs({
+    provider: 'zai',
+    model: 'glm-5.3-flash',
+    reasoning: 'medium',
+    cwd: '/workspace/project',
+    profile: 'relay',
+  }, 'inspect runtime');
+  assert.deepEqual(args, [
+    'exec',
+    '--json',
+    '-p', 'relay',
+    '-m', 'glm-5.3-flash',
+    '-c', 'model_provider=zai',
+    '-c', 'model_reasoning_effort=medium',
+    '-C', '/workspace/project',
+    '--', 'inspect runtime',
+  ]);
+});
+
+test('buildCodexArgs omits absent optional routing fields', () => {
+  const args = buildCodexArgs({ provider: 'zai', model: 'glm-5.3-flash' }, 'prompt');
+  assert.deepEqual(args, [
+    'exec',
+    '--json',
+    '-m', 'glm-5.3-flash',
+    '-c', 'model_provider=zai',
+    '--', 'prompt',
+  ]);
+});
+
+test('CodexAdapter buffers a thread id emitted before callback attachment', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-codex-'));
+  try {
+    const command = join(root, 'codex');
+    await writeFile(command, [
+      '#!/bin/sh',
+      `printf '%s\\n' '${JSON.stringify({ type: 'thread.started', thread_id: 'early-thread' })}'`,
+      'while true; do sleep 0.1; done',
+    ].join('\n'), { mode: 0o700 });
+    await chmod(command, 0o700);
+    const adapter = new CodexAdapter(command);
+    const execution = adapter.launch({
+      id: 'task',
+      input: 'prompt',
+      routing: { provider: 'zai', model: 'glm-5.3-flash' },
+    }, new AbortController().signal);
+    let observedThreadId;
+    execution.onThreadStarted = threadId => { observedThreadId = threadId; };
+    execution.promise.catch(() => {});
+    for (let attempts = 0; attempts < 100 && observedThreadId === undefined; attempts += 1) {
+      await new Promise(resolve => setTimeout(resolve, 10));
+    }
+    assert.equal(execution.threadId, 'early-thread');
+    assert.equal(observedThreadId, 'early-thread');
+    execution.cancel();
+    await execution.promise.catch(() => {});
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('CodexAdapter persists only the final assistant message from large JSON output', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-codex-summary-'));
+  try {
+    const command = join(root, 'codex');
+    const noise = 'x'.repeat(70000);
+    const final = 'concise final result';
+    await writeFile(command, [
+      '#!/bin/sh',
+      `printf '%s\\n' '${JSON.stringify({ type: 'thread.started', thread_id: 'summary-thread' })}'`,
+      `printf '%s\\n' '${JSON.stringify({ type: 'item.completed', item: { type: 'command_execution', text: noise } })}'`,
+      `printf '%s\\n' '${JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: final } })}'`,
+    ].join('\n'), { mode: 0o700 });
+    await chmod(command, 0o700);
+    const adapter = new CodexAdapter(command);
+    const result = await adapter.launch({
+      id: 'task', input: 'prompt', routing: { provider: 'zai', model: 'glm-5.3-flash' },
+    }, new AbortController().signal).promise;
+    assert.equal(result.summary, final);
+    assert.ok(Buffer.byteLength(result.summary) < 1024);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('CodexAdapter bounds stderr retained for failed executions', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-codex-error-'));
+  try {
+    const command = join(root, 'codex');
+    await writeFile(command, [
+      '#!/bin/sh',
+      "python3 - <<'PY' >&2",
+      "print('e' * 70000)",
+      'PY',
+      'exit 1',
+    ].join('\n'), { mode: 0o700 });
+    await chmod(command, 0o700);
+    const adapter = new CodexAdapter(command);
+    await assert.rejects(adapter.launch({
+      id: 'task', input: 'prompt', routing: { provider: 'zai', model: 'glm-5.3-flash' },
+    }, new AbortController().signal).promise, error => {
+      assert.ok(Buffer.byteLength(error.message) <= 16384);
+      return true;
+    });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ChatGptAdapter treats configured MacBridge URL as an origin', async () => {
+  let requestedUrl = '';
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-origin-'));
+  const tokenFile = join(root, 'token'); await writeFile(tokenFile, 'test-token');
+  const { ChatGptAdapter } = await import('../dist/adapters.js');
+  const adapter = new ChatGptAdapter({
+    endpoint: 'http://127.0.0.1:8788/v1/responses',
+    tokenFile,
+    fetch: async input => {
+      requestedUrl = String(input);
+      return new Response(JSON.stringify({ complete: true, conversation_id: 'conv-origin', assistant_text: 'ok' }), { status: 200 });
+    },
+  });
+  const task = { id: 'origin', input: 'test', routing: { provider: 'openai', model: 'gpt-5.6-sol' } };
+  await adapter.launch(task, new AbortController().signal).promise;
+  assert.equal(requestedUrl, 'http://127.0.0.1:8788/experimental/chatgpt/conversation');
+  await rm(root, { recursive: true, force: true });
+});
+
+test('ChatGptAdapter launches through MacBridge and exposes conversation id as thread id', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-chatgpt-'));
+  try {
+    const tokenFile = join(root, 'http-token');
+    await writeFile(tokenFile, 'secret-token\n', { mode: 0o600 });
+    let request;
+    const adapter = new (await import('../dist/adapters.js')).ChatGptAdapter({
+      endpoint: 'http://127.0.0.1:9999',
+      tokenFile,
+      fetch: async (input, init) => {
+        request = { input: String(input), init };
+        return new Response(JSON.stringify({ complete: true, conversation_id: 'chat-thread-1', assistant_text: 'finished work' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      },
+    });
+    const execution = adapter.launch({
+      id: 'chat-task',
+      input: 'build the feature',
+      timeoutMs: 120000,
+      threadId: null,
+      routing: { provider: 'openai', model: 'gpt-5-6-sol', reasoning: 'high', projectId: 'g-p-12345678' },
+    }, new AbortController().signal);
+    let observedThreadId;
+    execution.onThreadStarted = threadId => { observedThreadId = threadId; };
+    const result = await execution.promise;
+    assert.equal(request.input, 'http://127.0.0.1:9999/experimental/chatgpt/conversation');
+    assert.equal(request.init.headers.authorization, 'Bearer secret-token');
+    const body = JSON.parse(request.init.body);
+    assert.deepEqual(body, {
+      prompt: 'build the feature',
+      model: 'gpt-5-6-sol',
+      thinking_effort: 'high',
+      max_runtime_seconds: 120,
+      project_id: 'g-p-12345678',
+    });
+    assert.equal(execution.threadId, 'chat-thread-1');
+    assert.equal(observedThreadId, 'chat-thread-1');
+    assert.equal(result.summary, 'finished work');
+    assert.equal(result.data.conversationId, 'chat-thread-1');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ChatGptAdapter continues an existing conversation on retry and normalizes medium reasoning', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-chatgpt-retry-'));
+  try {
+    const tokenFile = join(root, 'http-token');
+    await writeFile(tokenFile, 'token', { mode: 0o600 });
+    let body;
+    const { ChatGptAdapter } = await import('../dist/adapters.js');
+    const adapter = new ChatGptAdapter({
+      endpoint: 'http://127.0.0.1:9999/experimental/chatgpt/conversation',
+      tokenFile,
+      fetch: async (_input, init) => {
+        body = JSON.parse(init.body);
+        return new Response(JSON.stringify({ complete: true, conversation_id: 'existing-thread', assistant_text: 'continued' }), { status: 200 });
+      },
+    });
+    const result = await adapter.launch({
+      id: 'retry-task', input: 'continue', timeoutMs: 10000, threadId: 'existing-thread',
+      routing: { provider: 'openai', model: 'gpt-5-6', reasoning: 'medium' },
+    }, new AbortController().signal).promise;
+    assert.equal(body.conversation_id, 'existing-thread');
+    assert.equal(body.thinking_effort, 'standard');
+    assert.equal(body.max_runtime_seconds, 30);
+    assert.equal(result.summary, 'continued');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ChatGptAdapter exposes conversation id before the response body completes', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-chatgpt-early-thread-'));
+  try {
+    const tokenFile = join(root, 'http-token');
+    await writeFile(tokenFile, 'token', { mode: 0o600 });
+    let finishResponse;
+    const { ChatGptAdapter } = await import('../dist/adapters.js');
+    const adapter = new ChatGptAdapter({
+      endpoint: 'http://127.0.0.1:9999',
+      tokenFile,
+      fetch: async () => new Response(new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode('{"conversation_id":"early-chat-thread","complete":'));
+          finishResponse = () => {
+            controller.enqueue(new TextEncoder().encode('true,"assistant_text":"done"}'));
+            controller.close();
+          };
+        },
+      }), { status: 200 }),
+    });
+    const execution = adapter.launch({
+      id: 'early-chat-task', input: 'work', timeoutMs: 10000, threadId: null,
+      routing: { provider: 'openai', model: 'gpt-5-6' },
+    }, new AbortController().signal);
+    let observedThreadId;
+    execution.onThreadStarted = threadId => { observedThreadId = threadId; };
+    for (let attempts = 0; attempts < 100 && observedThreadId === undefined; attempts += 1) {
+      await new Promise(resolve => setTimeout(resolve, 5));
+    }
+    assert.equal(execution.threadId, 'early-chat-thread');
+    assert.equal(observedThreadId, 'early-chat-thread');
+    assert.equal(typeof finishResponse, 'function');
+    finishResponse();
+    assert.equal((await execution.promise).summary, 'done');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ChatGptAdapter keeps an exposed conversation id when response transport fails later', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-chatgpt-transport-fail-'));
+  try {
+    const tokenFile = join(root, 'http-token');
+    await writeFile(tokenFile, 'token', { mode: 0o600 });
+    let failResponse;
+    const { ChatGptAdapter } = await import('../dist/adapters.js');
+    const adapter = new ChatGptAdapter({
+      endpoint: 'http://127.0.0.1:9999',
+      tokenFile,
+      fetch: async () => new Response(new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode('{"conversation_id":"durable-chat-thread","complete":'));
+          failResponse = () => controller.error(new Error('transport lost after thread creation'));
+        },
+      }), { status: 200 }),
+    });
+    const execution = adapter.launch({
+      id: 'failed-chat-task', input: 'work', timeoutMs: 10000, threadId: null,
+      routing: { provider: 'openai', model: 'gpt-5-6' },
+    }, new AbortController().signal);
+    let observedThreadId;
+    execution.onThreadStarted = threadId => { observedThreadId = threadId; };
+    for (let attempts = 0; attempts < 100 && observedThreadId === undefined; attempts += 1) {
+      await new Promise(resolve => setTimeout(resolve, 5));
+    }
+    assert.equal(observedThreadId, 'durable-chat-thread');
+    assert.equal(typeof failResponse, 'function');
+    failResponse();
+    await assert.rejects(execution.promise, /transport lost after thread creation/);
+    assert.equal(execution.threadId, 'durable-chat-thread');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ChatGptAdapter deletes a durable conversation through the MacBridge wrapper', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-chatgpt-delete-'));
+  try {
+    const tokenFile = join(root, 'http-token');
+    await writeFile(tokenFile, 'delete-token', { mode: 0o600 });
+    let request;
+    const { ChatGptAdapter } = await import('../dist/adapters.js');
+    const adapter = new ChatGptAdapter({
+      endpoint: 'http://127.0.0.1:9999', tokenFile,
+      fetch: async (input, init) => { request={input:String(input),init}; return new Response(JSON.stringify({ deleted: true }), { status: 200 }); },
+    });
+    await adapter.deleteThread('chat-thread-delete');
+    assert.equal(request.input,'http://127.0.0.1:9999/experimental/chatgpt/conversation');
+    assert.equal(request.init.method,'DELETE');
+    assert.equal(request.init.headers.authorization,'Bearer delete-token');
+    assert.deepEqual(JSON.parse(request.init.body),{conversation_id:'chat-thread-delete'});
+  } finally { await rm(root,{recursive:true,force:true}); }
+});

package/test/autonomous.test.js

@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { mkdtemp, writeFile, chmod, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { InMemoryStore } from '../dist/store.js';
+import { marker, JOB_MARKER, TASK_MARKER, parseJob, parseTask, renderJobComment } from '../dist/markers.js';
+import { AgentObjectivePlanner, parsePlannerOutput, parsePlannerResult } from '../dist/planner.js';
+import { Reconciler } from '../dist/reconciler.js';
+import { schedule } from '../dist/scheduler.js';
+import { executionMode } from '../dist/cli.js';
+import { dashboardHtml } from '../dist/dashboard.js';
+
+const now = () => new Date().toISOString();
+const task = (id, state = 'QUEUED') => ({ jobId: 'auto', id, kind: 'work', parentTaskId: null, dependencies: [], capabilities: [], adapter: 'shell', input: 'true', state, attempt: 0, maxAttempts: 1, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, error: null, timeoutMs: 1000, createdAt: now(), updatedAt: now(), continuation: null, continuationDeliveredAt: null });
+const job = (tasks = [], executionMode = 'autonomous') => ({ id: 'auto', title: 'Objective', objective: 'finish the objective', executionMode, prNumber: 0, repository: '', state: 'OPEN', continuation: null, createdAt: now(), updatedAt: now(), tasks });
+const adapter = { name: 'shell', id: 'test-shell', capabilities: ['shell'], launch: current => ({ id: `exec-${current.id}`, promise: Promise.resolve({ summary: 'done' }), cancel: () => {} }) };
+async function settle(reconciler, count = 8) { for (let index = 0; index < count; index += 1) { await reconciler.reconcile('auto'); await reconciler.idle(); } }
+
+test('execution mode and planner result markers round-trip, with legacy jobs fixed by default', () => {
+  const autonomous = job();
+  assert.equal(parseJob(renderJobComment(autonomous)).executionMode, 'autonomous');
+  const legacy = { ...autonomous }; delete legacy.executionMode;
+  assert.equal(parseJob(marker(JOB_MARKER, legacy)).executionMode, 'fixed');
+  const planner = { ...task('planner-1'), kind: 'planner', plannerResult: { objective_status: 'in_progress', assessment: 'need work', next_tasks: [{ id: 'work-1', input: 'true' }] } };
+  assert.equal(parseTask(marker(TASK_MARKER, planner)).plannerResult.next_tasks[0].id, 'work-1');
+  assert.equal(parsePlannerOutput('```json\n{"objective_status":"satisfied","assessment":"done","next_tasks":[]}\n```').objective_status, 'satisfied');
+  assert.throws(() => parsePlannerResult({ objective_status: 'satisfied', assessment: 'bad', next_tasks: [{ id: 'duplicate', input: 'x' }, { id: 'duplicate', input: 'y' }] }), /duplicate/);
+  assert.equal(executionMode(['--mode', 'autonomous']), 'autonomous');
+  assert.equal(executionMode([]), 'fixed');
+  assert.match(dashboardHtml, /Execution mode/);
+  assert.match(dashboardHtml, /executionMode\|\|'fixed'/);
+});
+
+test('default planner agent loads markdown instructions and returns typed planning JSON', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'agents-relay-planner-agent-'));
+  try {
+    const command = join(root, 'model-runtime');
+    const agentFile = join(root, 'planner.agent.md');
+    await writeFile(agentFile, '# Planner Agent\nReturn JSON only.\n');
+    await writeFile(command, [
+      '#!/bin/sh',
+      "printf '%s\\n' '{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"{\\\"objective_status\\\":\\\"satisfied\\\",\\\"assessment\\\":\\\"done\\\",\\\"next_tasks\\\":[]}\"}}'",
+    ].join('\n'), { mode: 0o700 });
+    await chmod(command, 0o700);
+    const planner = new AgentObjectivePlanner(command, agentFile);
+    const result = await planner.plan({ job: job(), tasks: [], objective: 'finish', previousPlannerTaskId: null }, new AbortController().signal);
+    assert.deepEqual(result, { objective_status: 'satisfied', assessment: 'done', next_tasks: [] });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('fixed jobs remain backward compatible and never create planner tasks', async () => {
+  const fixed = job([task('fixed-work')], 'fixed');
+  const store = new InMemoryStore(fixed);
+  let plannerCalls = 0;
+  const reconciler = new Reconciler(store, { owner: 'fixed-test', adapters: [adapter], planner: { plan: async () => { plannerCalls += 1; return { objective_status: 'satisfied', assessment: 'unexpected', next_tasks: [] }; } } });
+  await settle(reconciler, 2);
+  const result = await store.load('auto');
+  assert.equal(result.executionMode, 'fixed');
+  assert.equal(result.tasks.some(item => item.kind === 'planner'), false);
+  assert.equal(plannerCalls, 0);
+  assert.equal(result.tasks[0].state, 'SUCCEEDED');
+});
+
+test('autonomous reconciliation grows the real parent/subtask tree and completes after satisfaction', async () => {
+  const store = new InMemoryStore(job());
+  let calls = 0;
+  const planner = { plan: async () => { calls += 1; return calls === 1 ? { objective_status: 'in_progress', assessment: 'work remains', next_tasks: [{ id: 'work-1', input: 'true' }] } : { objective_status: 'satisfied', assessment: 'objective complete', next_tasks: [] }; } };
+  const reconciler = new Reconciler(store, { owner: 'auto-test', adapters: [adapter], planner });
+  await settle(reconciler);
+  const result = await store.load('auto');
+  const plannerOne = result.tasks.find(item => item.id === 'planner-1');
+  const work = result.tasks.find(item => item.id === 'work-1');
+  const plannerTwo = result.tasks.find(item => item.id === 'planner-2');
+  assert.equal(result.state, 'COMPLETED');
+  assert.equal(calls, 2);
+  assert.equal(plannerOne?.kind, 'planner');
+  assert.equal(plannerOne?.agentName, 'planner');
+  assert.equal(work?.parentTaskId, 'planner-1');
+  assert.equal(plannerTwo?.parentTaskId, 'planner-1');
+  assert.equal(plannerTwo?.plannerResult?.objective_status, 'satisfied');
+});
+
+test('autonomous planner creation and stable next task IDs are idempotent', async () => {
+  const store = new InMemoryStore(job());
+  let calls = 0;
+  const planner = { plan: async () => { calls += 1; return calls === 1 ? { objective_status: 'in_progress', assessment: 'work remains', next_tasks: [{ id: 'stable-work', input: 'true' }] } : { objective_status: 'satisfied', assessment: 'done', next_tasks: [{ id: 'stable-work', input: 'true' }] }; } };
+  const reconciler = new Reconciler(store, { owner: 'idempotency-test', adapters: [adapter], planner });
+  await settle(reconciler, 3);
+  const first = await store.load('auto');
+  await settle(reconciler, 3);
+  const second = await store.load('auto');
+  assert.equal(calls, 2);
+  assert.equal(second.tasks.filter(item => item.id === 'stable-work').length, 1);
+  assert.equal(first.tasks.filter(item => item.kind === 'planner').length, second.tasks.filter(item => item.kind === 'planner').length);
+});
+
+test('restart recovery reclaims a durable planner lease without relaunching duplicate work', async () => {
+  const plannerTask = { ...task('planner-1', 'RUNNING'), kind: 'planner', parentTaskId: null, attempt: 1, maxAttempts: 2, leaseOwner: 'old-daemon', leaseExpiresAt: new Date(Date.now() + 600000).toISOString(), executionId: 'old-execution', input: '{}', capabilities: ['planner'] };
+  const store = new InMemoryStore({ ...job([plannerTask]), state: 'RUNNING' });
+  let calls = 0;
+  const reconciler = new Reconciler(store, { owner: 'new-daemon', adapters: [adapter], planner: { plan: async () => { calls += 1; return { objective_status: 'satisfied', assessment: 'recovered', next_tasks: [] }; } } });
+  await settle(reconciler, 3);
+  const result = await store.load('auto');
+  assert.equal(calls, 1);
+  assert.equal(result.state, 'COMPLETED');
+  assert.equal(result.tasks.filter(item => item.kind === 'planner').length, 1);
+  assert.equal(result.tasks[0].attempt, 2);
+});
+
+test('planner satisfaction cannot bypass failed or blocked completion gates', () => {
+  const satisfied = { ...task('planner-1', 'SUCCEEDED'), kind: 'planner', plannerResult: { objective_status: 'satisfied', assessment: 'done', next_tasks: [] } };
+  const failed = schedule({ ...job([satisfied, { ...task('failed', 'FAILED'), error: 'unresolved' }]), state: 'RUNNING' });
+  assert.equal(failed.state, 'FAILED');
+  const blocked = schedule({ ...job([satisfied, { ...task('blocked', 'BLOCKED') }]), state: 'RUNNING' });
+  assert.equal(blocked.state, 'BLOCKED');
+});