@vercel/agent-eval 1.1.0 → 1.2.0

package/dist/lib/agents/eval-helper.mjs

@@ -0,0 +1,222 @@
+/**
+ * In-sandbox eval helper — the EVAL.ts agentic-judge surface.
+ *
+ * Shipped INTO the sandbox by the orchestrator (like run.mjs) and aliased to
+ * `@vercel/agent-eval/eval` + registered as a vitest setup file by the generated
+ * vitest config. That lets EVAL.ts do:
+ *
+ *   import { environment, transcript } from '@vercel/agent-eval/eval';
+ *
+ *   test('quality', async () => {
+ *     await expect(environment).toSatisfyCriterion('uses Server Components for the list');
+ *     await expect(transcript).toSatisfyCriterion('diagnosed with DevTools, not guesswork');
+ *     await expect(environment).toScoreAtLeast('code quality', 0.8);
+ *   });
+ *
+ * It is AGENTIC and reuses the SAME harness: each assertion re-invokes the codegen
+ * agent's runner (`__agent_eval__/run.mjs`, already shipped) IN this sandbox. The
+ * judge explores the final state (cwd) or reads the materialized transcript file —
+ * no fresh sandbox, no copying evidence around, no new harness.
+ *
+ * Zero-dependency apart from `vitest` (already present in the fixture). Runs only
+ * in-sandbox. The path constants below mirror shared.ts (the orchestrator writes
+ * these files before validation).
+ */
+
+import { spawnSync } from 'node:child_process';
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { expect } from 'vitest';
+
+// Canonical sandbox paths (kept in sync with shared.ts).
+const RUNNER_PATH = '__agent_eval__/run.mjs';
+const JUDGE_CONFIG_PATH = '__agent_eval__/judge-config.json';
+const TRANSCRIPT_FILE = '__agent_eval__/transcript.txt';
+const JUDGE_IO_DIR = '__agent_eval__/judge';
+
+/**
+ * The two things you can judge — import sentinels, NOT paths. The matcher routes
+ * on which one you pass; the path/cwd resolution is an internal detail.
+ */
+export const environment = { __judgeSubject: 'environment' };
+export const transcript = { __judgeSubject: 'transcript' };
+
+/** Path to the materialized transcript. Rarely needed — prefer the `transcript` subject. */
+export function transcriptPath() {
+  return TRANSCRIPT_FILE;
+}
+
+/**
+ * Build the judge prompt for a subject + criterion. Framework-owned: you supply
+ * only the criterion; the scaffolding (skeptical stance, how to gather evidence,
+ * and the verdict output contract) is fixed so the verdict parses reliably.
+ */
+export function buildJudgePrompt(subject, criterion, verdictPath, opts = {}) {
+  const lines = [];
+  lines.push(
+    "You are a strict, skeptical judge evaluating an AI coding agent's work. " +
+      'Decide the criterion ONLY on clear evidence; when in doubt, FAIL it.'
+  );
+  lines.push('');
+  if (subject === 'transcript') {
+    lines.push(
+      `Read the agent's transcript at ${TRANSCRIPT_FILE} (open it with your tools) to ` +
+        'see how the agent worked. Cite what the transcript actually shows; do not assume.'
+    );
+  } else {
+    lines.push(
+      'Inspect the project in the current directory — read files, grep, run commands as ' +
+        'needed — to gather concrete evidence.'
+    );
+  }
+  lines.push('');
+  lines.push(`Criterion: ${criterion}`);
+  lines.push('');
+  if (opts.numeric) {
+    lines.push(
+      'Also give a score from 0 to 1 (1 = fully satisfies the criterion). Set pass=true ' +
+        'iff the criterion is satisfied.'
+    );
+  }
+  lines.push(`When done, write your verdict to ${verdictPath} as JSON of exactly this shape:`);
+  lines.push(
+    '{"pass": true|false,' +
+      (opts.numeric ? ' "score": <0-1>,' : '') +
+      ' "reason": "<1-2 sentences citing concrete evidence>"}'
+  );
+  lines.push('Then print that same JSON as your final message.');
+  return lines.join('\n');
+}
+
+/**
+ * Parse a verdict from the verdict file or the agent's final output. Tolerant of
+ * surrounding prose / ```json fences. Returns null when nothing parseable is found.
+ */
+export function parseJudgeVerdict(raw) {
+  if (!raw) return null;
+  const match = raw.match(/\{[\s\S]*"pass"[\s\S]*\}/);
+  if (!match) return null;
+  try {
+    const obj = JSON.parse(match[0]);
+    return {
+      pass: !!obj.pass,
+      score: typeof obj.score === 'number' ? obj.score : undefined,
+      reason: typeof obj.reason === 'string' ? obj.reason : '',
+    };
+  } catch {
+    return null;
+  }
+}
+
+/* ───────────────────────────── judge invocation ───────────────────────────── */
+
+let counter = 0;
+function nextId() {
+  counter += 1;
+  return `${process.pid}-${counter}`;
+}
+
+function readJudgeConfig() {
+  try {
+    return JSON.parse(readFileSync(JUDGE_CONFIG_PATH, 'utf8'));
+  } catch {
+    // No config (e.g. run outside the orchestrator) → let the agent CLI default.
+    return { model: null, extra: null };
+  }
+}
+
+/**
+ * Run one agentic judgment IN this sandbox by re-invoking the codegen agent's
+ * runner. Blocking (spawnSync) — the test has nothing else to do while the judge
+ * works, and the sandbox-level timeout bounds it. Returns {pass, score?, reason}.
+ */
+function runJudge(subject, criterion, opts = {}) {
+  const id = nextId();
+  mkdirSync(JUDGE_IO_DIR, { recursive: true });
+  const verdictPath = `${JUDGE_IO_DIR}/${id}-verdict.json`;
+  const resultPath = `${JUDGE_IO_DIR}/${id}-result.json`;
+  const cfg = readJudgeConfig();
+
+  // Same AgentRunInput contract run.mjs already understands. Reuse the codegen
+  // model + host-computed extra (e.g. codex's resolved model/effort) so the judge
+  // is the SAME agent. No secrets here — the key rides in process.env (inherited).
+  const input = {
+    prompt: buildJudgePrompt(subject, criterion, verdictPath, opts),
+    model: cfg.model ?? undefined,
+    cwd: process.cwd(),
+    resultPath,
+    extra: cfg.extra ?? undefined,
+  };
+
+  const res = spawnSync('node', [RUNNER_PATH, JSON.stringify(input)], {
+    cwd: process.cwd(),
+    env: process.env,
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+  });
+
+  // Prefer the verdict file the judge agent wrote; then the runner result's output
+  // (the agent's final message); then raw stdout.
+  let verdict = existsSync(verdictPath) ? parseJudgeVerdict(readFileSync(verdictPath, 'utf8')) : null;
+  if (!verdict && existsSync(resultPath)) {
+    try {
+      const rr = JSON.parse(readFileSync(resultPath, 'utf8'));
+      verdict = parseJudgeVerdict(rr.output);
+      if (!verdict && !rr.ok) {
+        return { pass: false, reason: `judge agent failed: ${rr.error || 'unknown error'}` };
+      }
+    } catch {
+      /* fall through */
+    }
+  }
+  if (!verdict) verdict = parseJudgeVerdict(res.stdout || '');
+  if (!verdict) {
+    const tail = (res.stdout || res.stderr || '').slice(-300);
+    return { pass: false, reason: `could not parse a judge verdict (node exit ${res.status}). Tail: ${tail}` };
+  }
+  return verdict;
+}
+
+function subjectOf(received) {
+  return received && typeof received === 'object' ? received.__judgeSubject : undefined;
+}
+
+// Sync matchers: spawnSync blocks, so these work whether or not you `await` them.
+expect.extend({
+  toSatisfyCriterion(received, criterion) {
+    const subject = subjectOf(received);
+    if (!subject) {
+      return {
+        pass: false,
+        message: () =>
+          'toSatisfyCriterion expects `environment` or `transcript` from @vercel/agent-eval/eval',
+      };
+    }
+    const v = runJudge(subject, criterion);
+    return {
+      pass: v.pass,
+      message: () =>
+        `[judge:${subject}] ${v.pass ? 'PASS' : 'FAIL'}` +
+        (typeof v.score === 'number' ? ` (score ${v.score})` : '') +
+        ` — ${criterion}\n  reason: ${v.reason}`,
+    };
+  },
+
+  toScoreAtLeast(received, criterion, threshold) {
+    const subject = subjectOf(received);
+    if (!subject) {
+      return {
+        pass: false,
+        message: () =>
+          'toScoreAtLeast expects `environment` or `transcript` from @vercel/agent-eval/eval',
+      };
+    }
+    const v = runJudge(subject, criterion, { numeric: true });
+    const score = typeof v.score === 'number' ? v.score : v.pass ? 1 : 0;
+    const pass = score >= threshold;
+    return {
+      pass,
+      message: () =>
+        `[judge:${subject}] score ${score} ${pass ? '>=' : '<'} ${threshold} — ${criterion}\n  reason: ${v.reason}`,
+    };
+  },
+});

package/dist/lib/agents/gemini/agent.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Gemini CLI agent — host-side definition + the thin Agent wrapper.
+ *
+ * Mirrors the Claude Code exemplar: the definition is pure data/auth, while the
+ * actual CLI invocation + transcript capture live in ./run.mjs (shipped into the
+ * sandbox by the orchestrator). The wrapper keeps the public Agent interface
+ * identical so the registry / runner are untouched.
+ *
+ * Gemini uses DIRECT Google Gemini API access only (no AI Gateway variant in the
+ * old adapter), configured purely via env — no config files.
+ */
+import type { Agent } from '../types.js';
+import type { AgentDefinition } from '../plugin/contract.js';
+/**
+ * Build the Gemini CLI plugin definition.
+ *
+ * Auth is a single mode, preserved exactly from the old adapter: the resolved
+ * apiKey is exported as GEMINI_API_KEY. getApiKeyEnvVar() and authEnv() agree on
+ * that env var so the host's key resolution and the sandbox env stay consistent.
+ */
+export declare function createGeminiDefinition(): AgentDefinition;
+/**
+ * Create the Gemini CLI Agent. Thin wrapper over the generic orchestrator so the
+ * Agent interface (and thus registry.ts / index.ts / runner.ts) is unchanged.
+ */
+export declare function createGeminiAgent(): Agent;
+//# sourceMappingURL=agent.d.ts.map

package/dist/lib/agents/gemini/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../../src/lib/agents/gemini/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAmB,MAAM,aAAa,CAAC;AAG1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D;;;;;;GAMG;AACH,wBAAgB,sBAAsB,IAAI,eAAe,CAkCxD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,KAAK,CAWzC"}

package/dist/lib/agents/gemini/agent.js

@@ -0,0 +1,69 @@
+/**
+ * Gemini CLI agent — host-side definition + the thin Agent wrapper.
+ *
+ * Mirrors the Claude Code exemplar: the definition is pure data/auth, while the
+ * actual CLI invocation + transcript capture live in ./run.mjs (shipped into the
+ * sandbox by the orchestrator). The wrapper keeps the public Agent interface
+ * identical so the registry / runner are untouched.
+ *
+ * Gemini uses DIRECT Google Gemini API access only (no AI Gateway variant in the
+ * old adapter), configured purely via env — no config files.
+ */
+import { fileURLToPath } from 'node:url';
+import { GEMINI_DIRECT } from '../shared.js';
+import { runWithDefinition } from '../plugin/orchestrator.js';
+/**
+ * Build the Gemini CLI plugin definition.
+ *
+ * Auth is a single mode, preserved exactly from the old adapter: the resolved
+ * apiKey is exported as GEMINI_API_KEY. getApiKeyEnvVar() and authEnv() agree on
+ * that env var so the host's key resolution and the sandbox env stay consistent.
+ */
+export function createGeminiDefinition() {
+    return {
+        name: 'gemini',
+        displayName: 'Gemini CLI',
+        defaultModel: 'gemini-3-pro-preview',
+        o11yAgentName: 'gemini',
+        // Resolve run.mjs next to this file (works in src during dev and in dist after
+        // the build copies run.mjs alongside the compiled agent.js).
+        runnerPath: fileURLToPath(new URL('./run.mjs', import.meta.url)),
+        getApiKeyEnvVar() {
+            return GEMINI_DIRECT.apiKeyEnvVar;
+        },
+        install(_options) {
+            // Project deps (retried once), then the Gemini CLI globally.
+            // Error wording matches the old adapter verbatim:
+            //   npm install   → `npm install failed (exit code N):\n<last 10 lines>`
+            //   gemini-cli    → `Gemini CLI install failed: <stderr>`
+            return [
+                { kind: 'command', cmd: 'npm', args: ['install'], retryOnce: true, errorPrefix: 'npm install failed', errorBody: 'last10' },
+                { kind: 'command', cmd: 'npm', args: ['install', '-g', '@google/gemini-cli'], errorPrefix: 'Gemini CLI install failed', errorBody: 'stderr' },
+            ];
+        },
+        // Gemini CLI is configured purely via env — no config files.
+        configFiles() {
+            return [];
+        },
+        authEnv(options) {
+            return { [GEMINI_DIRECT.apiKeyEnvVar]: options.apiKey };
+        },
+    };
+}
+/**
+ * Create the Gemini CLI Agent. Thin wrapper over the generic orchestrator so the
+ * Agent interface (and thus registry.ts / index.ts / runner.ts) is unchanged.
+ */
+export function createGeminiAgent() {
+    const definition = createGeminiDefinition();
+    return {
+        name: definition.name,
+        displayName: definition.displayName,
+        getApiKeyEnvVar: definition.getApiKeyEnvVar,
+        getDefaultModel() {
+            return definition.defaultModel;
+        },
+        run: (fixturePath, options) => runWithDefinition(definition, fixturePath, options),
+    };
+}
+//# sourceMappingURL=agent.js.map

package/dist/lib/agents/gemini/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../../../src/lib/agents/gemini/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAIzC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,WAAW,EAAE,YAAY;QACzB,YAAY,EAAE,sBAAsB;QACpC,aAAa,EAAE,QAAQ;QACvB,+EAA+E;QAC/E,6DAA6D;QAC7D,UAAU,EAAE,aAAa,CAAC,IAAI,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEhE,eAAe;YACb,OAAO,aAAa,CAAC,YAAY,CAAC;QACpC,CAAC;QAED,OAAO,CAAC,QAAyB;YAC/B,6DAA6D;YAC7D,kDAAkD;YAClD,yEAAyE;YACzE,0DAA0D;YAC1D,OAAO;gBACL,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,oBAAoB,EAAE,SAAS,EAAE,QAAQ,EAAE;gBAC3H,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,SAAS,EAAE,IAAI,EAAE,oBAAoB,CAAC,EAAE,WAAW,EAAE,2BAA2B,EAAE,SAAS,EAAE,QAAQ,EAAE;aAC9I,CAAC;QACJ,CAAC;QAED,6DAA6D;QAC7D,WAAW;YACT,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,CAAC,OAAwB;YAC9B,OAAO,EAAE,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;QAC1D,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,MAAM,UAAU,GAAG,sBAAsB,EAAE,CAAC;IAC5C,OAAO;QACL,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,eAAe,EAAE,UAAU,CAAC,eAAe;QAC3C,eAAe;YACb,OAAO,UAAU,CAAC,YAAY,CAAC;QACjC,CAAC;QACD,GAAG,EAAE,CAAC,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC,iBAAiB,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO,CAAC;KACnF,CAAC;AACJ,CAAC"}

package/dist/lib/agents/gemini/run.mjs

@@ -0,0 +1,180 @@
+/**
+ * Gemini CLI in-sandbox runner.
+ *
+ * This file is shipped INTO the sandbox by the orchestrator and executed there as
+ * `node __agent_eval__/run.mjs '<AgentRunInput JSON>'`. It is intentionally
+ * ZERO-DEPENDENCY (only `node:*` builtins) because the sandbox only has the
+ * fixture's own deps + the installed `gemini` CLI — it cannot import anything from
+ * the @vercel/agent-eval package.
+ *
+ * Dual mode:
+ *   - runnable: invoked directly → reads argv, runs the agent, writes the result
+ *     file + prints a status line, exits 0.
+ *   - importable: `import { runAgent } from './run.mjs'` → returns a RunnerResult
+ *     (no file write, no exit). This is what a future in-sandbox judge reuses.
+ *
+ * The pure helpers below are exported (not just `runAgent`) so they can be
+ * unit-tested directly — the same code the sandbox runs.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Build the Gemini CLI argument list.
+ *
+ * Order is preserved verbatim from the old adapter:
+ *   `--prompt <prompt>` [ `--model <model>` ] `--approval-mode yolo`
+ *   `--output-format stream-json`
+ *
+ * `--output-format stream-json` makes Gemini emit JSONL (newline-delimited JSON)
+ * so we can capture a detailed event transcript (similar to Codex's --json).
+ * `--approval-mode yolo` auto-approves tool actions (non-interactive sandbox run).
+ *
+ * @param {{prompt:string, model?:string}} input
+ * @returns {string[]}
+ */
+export function buildGeminiCliArgs(input) {
+  const geminiArgs = ['--prompt', input.prompt];
+  if (input.model) {
+    geminiArgs.push('--model', input.model);
+  }
+  geminiArgs.push('--approval-mode', 'yolo', '--output-format', 'stream-json');
+  return geminiArgs;
+}
+
+/**
+ * Extract transcript from Gemini stream-json output.
+ *
+ * Preserved verbatim from the old adapter. When run with
+ * `--output-format stream-json`, Gemini outputs JSONL (one JSON object per line);
+ * we keep only the lines that look like a JSON object ({ ... }) and re-join them.
+ *
+ * @param {string|undefined|null} output combined stdout+stderr
+ * @returns {string|undefined}
+ */
+export function extractTranscriptFromOutput(output) {
+  if (!output || !output.trim()) {
+    return undefined;
+  }
+
+  // The --output-format stream-json output contains JSON events, one per line.
+  // Filter to only include lines that look like JSON objects.
+  const lines = output.split('\n').filter((line) => {
+    const trimmed = line.trim();
+    return trimmed.startsWith('{') && trimmed.endsWith('}');
+  });
+
+  if (lines.length === 0) {
+    return undefined;
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Run Gemini CLI over the workspace at `input.cwd` and return a RunnerResult.
+ *
+ * Auth (GEMINI_API_KEY) arrives via process.env — the orchestrator sets it on the
+ * `node run.mjs` invocation, and we pass process.env straight through to the CLI.
+ * The runner never handles secrets itself.
+ *
+ * @param {import('../plugin/contract.js').AgentRunInput} input
+ * @returns {Promise<import('../plugin/contract.js').RunnerResult>}
+ */
+export async function runAgent(input) {
+  const args = buildGeminiCliArgs(input);
+
+  // spawnSync (not a shell string): the prompt is a plain argv element, so there is
+  // no shell quoting/escaping to get wrong. Blocking is fine — the runner has
+  // nothing else to do while the agent works. The sandbox-level timeout bounds it.
+  const res = spawnSync('gemini', args, {
+    cwd: input.cwd,
+    env: process.env,
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+  });
+
+  const stdout = res.stdout || '';
+  const stderr = res.stderr || '';
+  // Preserve the old concatenation order: stdout THEN stderr.
+  const output = stdout + stderr;
+  // spawnSync sets status=null + error when the binary can't be spawned at all.
+  const agentExitCode = res.status == null ? -1 : res.status;
+
+  // Transcript from the stream-json output. Gemini exposes no observable model,
+  // so observedModel is always null (matches the old adapter exactly).
+  const transcript = extractTranscriptFromOutput(output) ?? null;
+  const observedModel = null;
+
+  if (res.error || agentExitCode !== 0) {
+    // Mirror the old error string: last 5 lines of output, else a coded fallback.
+    const errorLines = output.trim().split('\n').slice(-5).join('\n');
+    const fallback = res.error
+      ? `Failed to run gemini: ${res.error.message}`
+      : `Gemini CLI exited with code ${agentExitCode}`;
+    return {
+      ok: false,
+      output,
+      transcript,
+      observedModel,
+      error: errorLines || fallback,
+      agentExitCode,
+    };
+  }
+
+  return { ok: true, output, transcript, observedModel, error: null, agentExitCode };
+}
+
+/* ─────────────────────────── runnable (CLI) entry ─────────────────────────── */
+
+// True when this file is executed directly (`node run.mjs ...`), false when imported.
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+
+if (isMain) {
+  // argv[2] is the AgentRunInput JSON (never contains secrets).
+  const input = JSON.parse(process.argv[2]);
+
+  // Always produce a RunnerResult, even if the runner itself throws, so the host
+  // always has a result file to read (node exit code stays 0 except on a truly
+  // unrecoverable crash before we can write).
+  let result;
+  try {
+    result = await runAgent(input);
+  } catch (e) {
+    result = {
+      ok: false,
+      output: '',
+      transcript: null,
+      observedModel: null,
+      error: e && e.message ? e.message : String(e),
+      agentExitCode: -1,
+    };
+  }
+
+  // Source of truth: the result file the host reads back via sandbox.readFile.
+  try {
+    mkdirSync(dirname(input.resultPath), { recursive: true });
+    writeFileSync(input.resultPath, JSON.stringify(result));
+  } catch {
+    // If the file can't be written, the host falls back to the marker line below.
+  }
+
+  // Fallback channel: a compact status line (no transcript — it can be huge).
+  process.stdout.write(
+    '__AGENT_RESULT__ ' +
+      JSON.stringify({
+        ok: result.ok,
+        observedModel: result.observedModel,
+        error: result.error,
+        agentExitCode: result.agentExitCode,
+      }) +
+      '\n'
+  );
+
+  // Exit 0: "the runner ran". Agent success/failure is conveyed via result.ok, not
+  // the node exit code (the host distinguishes the two).
+  process.exit(0);
+}

package/dist/lib/agents/index.js

@@ -2,11 +2,11 @@
  * Agent registry with built-in agents.
  */
 import { registerAgent, getAgent, listAgents, hasAgent } from './registry.js';
-import { createClaudeCodeAgent } from './claude-code.js';
-import { createCodexAgent } from './codex.js';
-import { createOpenCodeAgent } from './opencode.js';
-import { createGeminiAgent } from './gemini.js';
-import { createCursorAgent } from './cursor.js';
+import { createClaudeCodeAgent } from './claude-code/agent.js';
+import { createCodexAgent } from './codex/agent.js';
+import { createOpenCodeAgent } from './opencode/agent.js';
+import { createGeminiAgent } from './gemini/agent.js';
+import { createCursorAgent } from './cursor/agent.js';
 // Register all agent variants (Vercel AI Gateway + Direct API)
 registerAgent(createClaudeCodeAgent({ useVercelAiGateway: true })); // vercel-ai-gateway/claude-code
 registerAgent(createClaudeCodeAgent({ useVercelAiGateway: false })); // claude-code

package/dist/lib/agents/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/agents/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,+DAA+D;AAC/D,aAAa,CAAC,qBAAqB,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAG,gCAAgC;AACtG,aAAa,CAAC,qBAAqB,CAAC,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAE,cAAc;AACpF,aAAa,CAAC,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAQ,0BAA0B;AAChG,aAAa,CAAC,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAO,QAAQ;AAC9E,aAAa,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAiC,6BAA6B;AACnG,aAAa,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAmC,SAAS;AAC/E,aAAa,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAmC,SAAS;AAE/E,+BAA+B;AAC/B,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/agents/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,+DAA+D;AAC/D,aAAa,CAAC,qBAAqB,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAG,gCAAgC;AACtG,aAAa,CAAC,qBAAqB,CAAC,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAE,cAAc;AACpF,aAAa,CAAC,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAQ,0BAA0B;AAChG,aAAa,CAAC,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAO,QAAQ;AAC9E,aAAa,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAiC,6BAA6B;AACnG,aAAa,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAmC,SAAS;AAC/E,aAAa,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAmC,SAAS;AAE/E,+BAA+B;AAC/B,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC"}

package/dist/lib/agents/opencode/agent.d.ts

@@ -0,0 +1,68 @@
+/**
+ * OpenCode agent — host-side definition + the thin Agent wrapper.
+ *
+ * The definition is pure data/auth/config; the actual CLI invocation + transcript
+ * capture live in ./run.mjs (shipped into the sandbox by the orchestrator). The
+ * wrapper keeps the public Agent interface identical so the registry / runner are
+ * untouched.
+ *
+ * OpenCode only supports the Vercel AI Gateway (no direct provider APIs), so there
+ * is a single variant: `vercel-ai-gateway/opencode`.
+ *
+ * `generateOpenCodeConfig` (the pure host-side config generator) STAYS in this file
+ * and is exported so the existing unit tests keep importing it. The transcript /
+ * observed-model parsing helpers (`extractObservedModelFromOpenCodeOutput`,
+ * `extractSessionIdFromTranscript`, `extractObservedModelFromSessionExport`) moved
+ * INTO ./run.mjs (so the tested logic is exactly what the sandbox runs) and the
+ * test now imports them from there — see the test import change in the migration
+ * notes.
+ */
+import type { Agent } from '../types.js';
+import type { AgentDefinition } from '../plugin/contract.js';
+/**
+ * Additional provider configuration for models not yet available in the
+ * default Vercel AI Gateway (e.g., early access / unreleased models).
+ *
+ * Preserved verbatim from the old adapter — passed through agentOptions.extraProviders.
+ */
+export interface OpenCodeProviderConfig {
+    npm?: string;
+    options?: Record<string, unknown>;
+    models?: Record<string, {
+        name?: string;
+        tool_call?: boolean;
+        reasoning?: boolean;
+        attachment?: boolean;
+        temperature?: boolean;
+        limit?: {
+            context: number;
+            output: number;
+        };
+    }>;
+}
+/**
+ * Generate OpenCode config file content.
+ * Configures the Vercel AI Gateway provider, plus any additional providers.
+ *
+ * STAYS host-side + exported (the unit test imports it). The content is written
+ * verbatim into `opencode.json` in the sandbox by the orchestrator. Behavior is
+ * identical to the old adapter, including writing the resolved apiKey into the
+ * config (falling back to the `{env:AI_GATEWAY_API_KEY}` placeholder).
+ */
+export declare function generateOpenCodeConfig(extraProviders?: Record<string, OpenCodeProviderConfig>, apiKey?: string, timeoutMs?: number, webResearch?: boolean): string;
+/**
+ * Build the OpenCode plugin definition.
+ *
+ * Auth is single-mode: the Vercel AI Gateway. authEnv() also carries the Exa
+ * websearch toggle (OPENCODE_ENABLE_EXA) when webResearch is on — it rides in
+ * process.env alongside the gateway key, exactly as the old adapter set it on the
+ * CLI's spawn env. The matching tool permissions are written into opencode.json by
+ * generateOpenCodeConfig.
+ */
+export declare function createOpenCodeDefinition(): AgentDefinition;
+/**
+ * Create the OpenCode Agent. Thin wrapper over the generic orchestrator so the
+ * Agent interface (and thus registry.ts / index.ts / runner.ts) is unchanged.
+ */
+export declare function createOpenCodeAgent(): Agent;
+//# sourceMappingURL=agent.d.ts.map

package/dist/lib/agents/opencode/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../../src/lib/agents/opencode/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAmB,MAAM,aAAa,CAAC;AAG1D,OAAO,KAAK,EAAE,eAAe,EAA2B,MAAM,uBAAuB,CAAC;AAGtF;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QACtB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,KAAK,CAAC,EAAE;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;KAC7C,CAAC,CAAC;CACJ;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,EACvD,MAAM,CAAC,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,OAAO,GACpB,MAAM,CA8BR;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,eAAe,CA2F1D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,KAAK,CAW3C"}