refactor: capture plain-text CLI output, drop hardcoded provider schemas

The adapters parsed each vendor's proprietary JSON stream (Claude json,
Codex JSONL, Gemini stream-json) to extract tokens/tool-calls, and a
per-model pricing table turned tokens into cost. That coupling was the
brittle hardcoding GStack 2 exists to avoid — it broke every time a vendor
reshuffled its output, and it duplicated what any tool that instruments the
real model call already does. Braintrust owns scoring; it can't see a CLI
subprocess's tokens anyway, so computing cost ourselves meant maintaining
both a parser and a price table forever.

Now each adapter runs the CLI in plain-text mode and returns stdout. Scoring
is unchanged (Braintrust reads the text). RunResult drops tokens/toolCalls;
the comparison table drops the Tokens/Cost columns. Deletes pricing.ts, all
three JSON parsers, and the Gemini stream-schema parser + its test. Gemini
auth detection (env/OAuth/.env) is kept — that's not schema parsing.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

lib/model-benchmark/providers/gpt.ts

@@ -1,16 +1,13 @@
-import type { ProviderAdapter, RunOpts, RunResult, AvailabilityCheck } from './types';
-import { estimateCostUsd } from '../pricing';
+import type { ProviderAdapter, RunOpts, RunResult, AvailabilityCheck, RunError } from './types';
 import { execFileSync, spawnSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 
 /**
- * GPT adapter — wraps the OpenAI `codex` CLI (codex exec with --json output).
+ * GPT adapter — wraps the OpenAI `codex` CLI (`codex exec`) in plain-text mode.
  *
- * Codex uses ~/.codex/ for auth (not OPENAI_API_KEY). The --json flag emits
- * JSONL events; we parse `turn.completed` for usage and `agent_message` / etc.
- * for output aggregation.
+ * Captures stdout as the answer; no JSON-event parsing. Scoring is Braintrust's job.
  */
 export class GptAdapter implements ProviderAdapter {
   readonly name = 'gpt';
@@ -36,7 +33,7 @@ export class GptAdapter implements ProviderAdapter {
     // often run in temp dirs / non-git paths), so the read-only sandbox is now
     // the only boundary preventing codex from mutating the workdir. If you ever
     // remove `-s read-only`, drop `--skip-git-repo-check` too.
-    const args = ['exec', opts.prompt, '-C', opts.workdir, '-s', 'read-only', '--skip-git-repo-check', '--json'];
+    const args = ['exec', opts.prompt, '-C', opts.workdir, '-s', 'read-only', '--skip-git-repo-check'];
     if (opts.model) args.push('-m', opts.model);
     if (opts.extraArgs) args.push(...opts.extraArgs);
 
@@ -47,81 +44,25 @@ export class GptAdapter implements ProviderAdapter {
         encoding: 'utf-8',
         maxBuffer: 32 * 1024 * 1024,
       });
-      const parsed = this.parseJsonl(out);
       return {
-        output: parsed.output,
-        tokens: parsed.tokens,
+        output: out.trim(),
         durationMs: Date.now() - start,
-        toolCalls: parsed.toolCalls,
-        modelUsed: parsed.modelUsed || opts.model || 'gpt-5.4',
+        modelUsed: opts.model ?? 'gpt',
       };
     } catch (err: unknown) {
-      const durationMs = Date.now() - start;
-      const e = err as { code?: string; stderr?: Buffer; signal?: string; message?: string };
-      const stderr = e.stderr?.toString() ?? '';
-      if (e.signal === 'SIGTERM' || e.code === 'ETIMEDOUT') {
-        return this.emptyResult(durationMs, { code: 'timeout', reason: `exceeded ${opts.timeoutMs}ms` }, opts.model);
-      }
-      if (/unauthorized|auth|login/i.test(stderr)) {
-        return this.emptyResult(durationMs, { code: 'auth', reason: stderr.slice(0, 400) }, opts.model);
-      }
-      if (/rate[- ]?limit|429/i.test(stderr)) {
-        return this.emptyResult(durationMs, { code: 'rate_limit', reason: stderr.slice(0, 400) }, opts.model);
-      }
-      return this.emptyResult(durationMs, { code: 'unknown', reason: (e.message ?? stderr ?? 'unknown').slice(0, 400) }, opts.model);
+      return this.errorResult(Date.now() - start, err, opts.model);
     }
   }
 
-  estimateCost(tokens: { input: number; output: number; cached?: number }, model?: string): number {
-    return estimateCostUsd(tokens, model ?? 'gpt-5.4');
-  }
-
-  /**
-   * Parse codex exec --json JSONL stream.
-   * Key events:
-   *   - item.completed with item.type === 'agent_message' → text output
-   *   - item.completed with item.type === 'command_execution' → tool call
-   *   - turn.completed → usage.input_tokens, usage.output_tokens
-   *   - thread.started → session id (not used here)
-   */
-  private parseJsonl(raw: string): { output: string; tokens: { input: number; output: number }; toolCalls: number; modelUsed?: string } {
-    let output = '';
-    let input = 0;
-    let out = 0;
-    let toolCalls = 0;
-    let modelUsed: string | undefined;
-    for (const line of raw.split('\n')) {
-      const s = line.trim();
-      if (!s) continue;
-      try {
-        const obj = JSON.parse(s);
-        if (obj.type === 'item.completed' && obj.item) {
-          if (obj.item.type === 'agent_message' && typeof obj.item.text === 'string') {
-            output += (output ? '\n' : '') + obj.item.text;
-          } else if (obj.item.type === 'command_execution') {
-            toolCalls += 1;
-          }
-        } else if (obj.type === 'turn.completed') {
-          const u = obj.usage ?? {};
-          input += u.input_tokens ?? 0;
-          out += u.output_tokens ?? 0;
-          if (obj.model) modelUsed = obj.model;
-        }
-      } catch {
-        // skip malformed lines — codex stderr can leak in
-      }
-    }
-    return { output, tokens: { input, output: out }, toolCalls, modelUsed };
-  }
-
-  private emptyResult(durationMs: number, error: RunResult['error'], model?: string): RunResult {
-    return {
-      output: '',
-      tokens: { input: 0, output: 0 },
-      durationMs,
-      toolCalls: 0,
-      modelUsed: model ?? 'gpt-5.4',
-      error,
-    };
+  private errorResult(durationMs: number, err: unknown, model?: string): RunResult {
+    const e = err as { code?: string; stderr?: Buffer; signal?: string; message?: string };
+    const stderr = e.stderr?.toString() ?? '';
+    let code: RunError;
+    if (e.signal === 'SIGTERM' || e.code === 'ETIMEDOUT') code = 'timeout';
+    else if (/unauthorized|auth|login/i.test(stderr)) code = 'auth';
+    else if (/rate[- ]?limit|429/i.test(stderr)) code = 'rate_limit';
+    else code = 'unknown';
+    const reason = code === 'timeout' ? 'exceeded timeout' : (e.message ?? stderr ?? 'unknown').slice(0, 400);
+    return { output: '', durationMs, modelUsed: model ?? 'gpt', error: { code, reason } };
   }
 }