@wix/evalforge-evaluator 0.202.0 → 0.203.0

package/build/index.js

@@ -2407,9 +2407,9 @@ var require_debug = __commonJS({
 var require_follow_redirects = __commonJS({
   "../../node_modules/follow-redirects/index.js"(exports2, module2) {
     var url = require("url");
-    var URL2 = url.URL;
-    var http = require("http");
-    var https = require("https");
+    var URL3 = url.URL;
+    var http2 = require("http");
+    var https2 = require("https");
     var Writable = require("stream").Writable;
     var assert = require("assert");
     var debug = require_debug();
@@ -2423,7 +2423,7 @@ var require_follow_redirects = __commonJS({
     })();
     var useNativeURL = false;
     try {
-      assert(new URL2(""));
+      assert(new URL3(""));
     } catch (error) {
       useNativeURL = error.code === "ERR_INVALID_URL";
     }
@@ -2803,7 +2803,7 @@ var require_follow_redirects = __commonJS({
     function parseUrl(input) {
       var parsed;
       if (useNativeURL) {
-        parsed = new URL2(input);
+        parsed = new URL3(input);
       } else {
         parsed = validateUrl(url.parse(input));
         if (!isString(parsed.protocol)) {
@@ -2813,7 +2813,7 @@ var require_follow_redirects = __commonJS({
       return parsed;
     }
     function resolveUrl2(relative2, base) {
-      return useNativeURL ? new URL2(relative2, base) : parseUrl(url.resolve(base, relative2));
+      return useNativeURL ? new URL3(relative2, base) : parseUrl(url.resolve(base, relative2));
     }
     function validateUrl(input) {
       if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
@@ -2892,9 +2892,9 @@ var require_follow_redirects = __commonJS({
       return typeof value === "object" && "length" in value;
     }
     function isURL(value) {
-      return URL2 && value instanceof URL2;
+      return URL3 && value instanceof URL3;
     }
-    module2.exports = wrap({ http, https });
+    module2.exports = wrap({ http: http2, https: https2 });
     module2.exports.wrap = wrap;
   }
 });
@@ -2997,8 +2997,8 @@ var require_http = __commonJS({
     var settle = require_settle();
     var buildFullPath = require_buildFullPath();
     var buildURL = require_buildURL();
-    var http = require("http");
-    var https = require("https");
+    var http2 = require("http");
+    var https2 = require("https");
     var httpFollow = require_follow_redirects().http;
     var httpsFollow = require_follow_redirects().https;
     var url = require("url");
@@ -3137,7 +3137,7 @@ var require_http = __commonJS({
         if (config.transport) {
           transport = config.transport;
         } else if (config.maxRedirects === 0) {
-          transport = isHttpsProxy ? https : http;
+          transport = isHttpsProxy ? https2 : http2;
         } else {
           if (config.maxRedirects) {
             options.maxRedirects = config.maxRedirects;
@@ -3282,8 +3282,8 @@ var require_helpers = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.req = exports2.json = exports2.toBuffer = void 0;
-    var http = __importStar2(require("http"));
-    var https = __importStar2(require("https"));
+    var http2 = __importStar2(require("http"));
+    var https2 = __importStar2(require("https"));
     async function toBuffer(stream) {
       let length = 0;
       const chunks = [];
@@ -3308,7 +3308,7 @@ var require_helpers = __commonJS({
     exports2.json = json;
     function req(url, opts = {}) {
       const href = typeof url === "string" ? url : url.href;
-      const req2 = (href.startsWith("https:") ? https : http).request(url, opts);
+      const req2 = (href.startsWith("https:") ? https2 : http2).request(url, opts);
       const promise = new Promise((resolve3, reject) => {
         req2.once("response", resolve3).once("error", reject).end();
       });
@@ -3356,11 +3356,11 @@ var require_dist = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Agent = void 0;
     var net = __importStar2(require("net"));
-    var http = __importStar2(require("http"));
+    var http2 = __importStar2(require("http"));
     var https_1 = require("https");
     __exportStar2(require_helpers(), exports2);
     var INTERNAL = /* @__PURE__ */ Symbol("AgentBaseInternalState");
-    var Agent = class extends http.Agent {
+    var Agent = class extends http2.Agent {
       constructor(opts) {
         super(opts);
         this[INTERNAL] = {};
@@ -3432,7 +3432,7 @@ var require_dist = __commonJS({
         const fakeSocket = this.incrementSockets(name);
         Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
           this.decrementSockets(name, fakeSocket);
-          if (socket instanceof http.Agent) {
+          if (socket instanceof http2.Agent) {
             try {
               return socket.addRequest(req, connectOpts);
             } catch (err) {
@@ -9650,14 +9650,12 @@ function toCanonicalModelId(modelId) {
   const slashIndex = modelId.indexOf("/");
   return slashIndex > 0 ? modelId.slice(slashIndex + 1) : modelId;
 }
-function buildLLMTrace(timestampedEvents, totalDurationMs, model, provider, executionStartTime) {
-  const canonicalModel = toCanonicalModelId(model);
+function isValidCost(cost) {
+  return typeof cost === "number" && Number.isFinite(cost);
+}
+function groupEventsIntoTurns(timestampedEvents) {
   const turns = [];
-  let current = {
-    textParts: [],
-    reasoningParts: [],
-    toolCalls: []
-  };
+  let current = { textParts: [], reasoningParts: [], toolCalls: [] };
   for (const { event: evt, receivedAt } of timestampedEvents) {
     switch (evt.type) {
       case "text":
@@ -9679,160 +9677,197 @@ function buildLLMTrace(timestampedEvents, totalDurationMs, model, provider, exec
         current.stepFinish = sf.part;
         current.receivedAt = receivedAt;
         turns.push(current);
-        current = {
-          textParts: [],
-          reasoningParts: [],
-          toolCalls: []
-        };
+        current = { textParts: [], reasoningParts: [], toolCalls: [] };
         break;
       }
     }
   }
-  if (current.textParts.length > 0 || current.reasoningParts.length > 0 || current.toolCalls.length > 0) {
+  const hasTrailingContent = current.textParts.length > 0 || current.reasoningParts.length > 0 || current.toolCalls.length > 0;
+  if (hasTrailingContent) {
     if (timestampedEvents.length > 0) {
       current.receivedAt = timestampedEvents[timestampedEvents.length - 1].receivedAt;
     }
     turns.push(current);
   }
-  const executionStartMs = executionStartTime.getTime();
-  const allSteps = turns.flatMap((turn, turnIndex) => {
-    const sf = turn.stepFinish;
-    const stepInputTokens = sf?.tokens.input ?? 0;
-    const stepOutputTokens = sf?.tokens.output ?? 0;
-    const stepCost = sf?.cost ?? 0;
-    const finishReason = sf?.reason ?? "unknown";
-    const stepModel = toCanonicalModelId(sf?.modelID || model);
-    const stepProvider = sf?.providerID || provider;
-    const turnEndMs = turn.receivedAt ?? executionStartMs + totalDurationMs;
-    const prevEndMs = turnIndex > 0 ? turns[turnIndex - 1].receivedAt ?? executionStartMs : executionStartMs;
-    const durationMs = Math.max(0, turnEndMs - prevEndMs);
-    const startedAt = new Date(prevEndMs).toISOString();
-    const text = turn.textParts.join("");
-    const thinking = turn.reasoningParts.join("");
-    const toolCallCount = turn.toolCalls.length;
-    const hasThinking = !!thinking;
-    const hasText = !!text;
-    const isSuccess = finishReason !== "error";
-    const errorMsg = finishReason === "error" ? "Generation failed" : void 0;
-    const subSteps = [];
-    const thinkingSubSteps = hasThinking && (hasText || toolCallCount > 0) ? 1 : 0;
-    const toolSubSteps = toolCallCount;
-    const textSubSteps = hasText && toolCallCount > 0 ? 1 : 0;
-    const totalSubSteps = thinkingSubSteps + toolSubSteps + textSubSteps || 1;
-    if (hasThinking && (hasText || toolCallCount > 0)) {
+  return turns;
+}
+function resolveTurnCosts(turns, gatewayCosts) {
+  const turnCosts = turns.map((turn, i) => {
+    if (!turn.stepFinish) return 0;
+    const capturedCost = gatewayCosts?.[i];
+    return isValidCost(capturedCost) ? capturedCost : turn.stepFinish.cost;
+  });
+  if (!gatewayCosts || gatewayCosts.length === 0) return turnCosts;
+  const requestTurnIndexes = turns.flatMap(
+    (turn, i) => turn.stepFinish ? [i] : []
+  );
+  const missingCount = requestTurnIndexes.filter(
+    (i) => !isValidCost(gatewayCosts[i])
+  ).length;
+  if (missingCount > 0) {
+    console.warn(
+      `[opencode] gateway cost missing for ${missingCount}/${requestTurnIndexes.length} turn(s); using OpenCode-reported cost for those`
+    );
+  }
+  let extraCallsCost = 0;
+  for (let i = requestTurnIndexes.length; i < gatewayCosts.length; i++) {
+    const capturedCost = gatewayCosts[i];
+    if (isValidCost(capturedCost)) extraCallsCost += capturedCost;
+  }
+  if (extraCallsCost > 0 && requestTurnIndexes.length > 0) {
+    const lastTurnIndex = requestTurnIndexes[requestTurnIndexes.length - 1];
+    turnCosts[lastTurnIndex] += extraCallsCost;
+    console.warn(
+      `[opencode] ${gatewayCosts.length} gateway call(s) for ${requestTurnIndexes.length} turn(s); folded $${extraCallsCost} of extra calls into the last turn`
+    );
+  }
+  return turnCosts;
+}
+function buildTurnSteps(turn, turnIndex, ctx) {
+  const {
+    turns,
+    turnCosts,
+    totalDurationMs,
+    executionStartMs,
+    model,
+    provider
+  } = ctx;
+  const sf = turn.stepFinish;
+  const stepInputTokens = sf?.tokens.input ?? 0;
+  const stepOutputTokens = sf?.tokens.output ?? 0;
+  const stepCost = turnCosts[turnIndex];
+  const finishReason = sf?.reason ?? "unknown";
+  const stepModel = toCanonicalModelId(sf?.modelID || model);
+  const stepProvider = sf?.providerID || provider;
+  const turnEndMs = turn.receivedAt ?? executionStartMs + totalDurationMs;
+  const prevEndMs = turnIndex > 0 ? turns[turnIndex - 1].receivedAt ?? executionStartMs : executionStartMs;
+  const durationMs = Math.max(0, turnEndMs - prevEndMs);
+  const startedAt = new Date(prevEndMs).toISOString();
+  const text = turn.textParts.join("");
+  const thinking = turn.reasoningParts.join("");
+  const toolCallCount = turn.toolCalls.length;
+  const hasThinking = !!thinking;
+  const hasText = !!text;
+  const isSuccess = finishReason !== "error";
+  const errorMsg = finishReason === "error" ? "Generation failed" : void 0;
+  const subSteps = [];
+  const thinkingSubSteps = hasThinking && (hasText || toolCallCount > 0) ? 1 : 0;
+  const toolSubSteps = toolCallCount;
+  const textSubSteps = hasText && toolCallCount > 0 ? 1 : 0;
+  const totalSubSteps = thinkingSubSteps + toolSubSteps + textSubSteps || 1;
+  if (hasThinking && (hasText || toolCallCount > 0)) {
+    subSteps.push({
+      id: (0, import_crypto3.randomUUID)(),
+      stepNumber: 0,
+      turnIndex,
+      type: import_evalforge_types7.LLMStepType.THINKING,
+      model: stepModel,
+      provider: stepProvider,
+      startedAt,
+      durationMs: Math.round(durationMs / totalSubSteps),
+      tokenUsage: {
+        prompt: Math.round(stepInputTokens / totalSubSteps),
+        completion: Math.round(stepOutputTokens / totalSubSteps),
+        total: Math.round((stepInputTokens + stepOutputTokens) / totalSubSteps)
+      },
+      costUsd: stepCost / totalSubSteps,
+      outputPreview: thinking.slice(0, 200),
+      success: isSuccess,
+      error: errorMsg
+    });
+  }
+  if (toolCallCount > 0) {
+    for (let tcIdx = 0; tcIdx < toolCallCount; tcIdx++) {
+      const tc = turn.toolCalls[tcIdx];
+      const isLast = tcIdx === toolCallCount - 1 && textSubSteps === 0;
+      const toolBudgetSteps = toolSubSteps + textSubSteps;
+      const toolFraction = toolBudgetSteps > 0 ? 1 / toolBudgetSteps : 1;
+      const remainingFraction = (totalSubSteps - thinkingSubSteps) / totalSubSteps;
       subSteps.push({
         id: (0, import_crypto3.randomUUID)(),
         stepNumber: 0,
         turnIndex,
-        type: import_evalforge_types7.LLMStepType.THINKING,
+        type: import_evalforge_types7.LLMStepType.TOOL_USE,
         model: stepModel,
         provider: stepProvider,
         startedAt,
-        durationMs: Math.round(durationMs / totalSubSteps),
+        durationMs: isLast ? durationMs - subSteps.reduce((s, ss) => s + ss.durationMs, 0) : Math.round(durationMs * remainingFraction * toolFraction),
         tokenUsage: {
-          prompt: Math.round(stepInputTokens / totalSubSteps),
-          completion: Math.round(stepOutputTokens / totalSubSteps),
+          prompt: Math.round(
+            stepInputTokens * remainingFraction * toolFraction
+          ),
+          completion: Math.round(
+            stepOutputTokens * remainingFraction * toolFraction
+          ),
           total: Math.round(
-            (stepInputTokens + stepOutputTokens) / totalSubSteps
+            (stepInputTokens + stepOutputTokens) * remainingFraction * toolFraction
           )
         },
-        costUsd: stepCost / totalSubSteps,
-        outputPreview: thinking.slice(0, 200),
-        success: isSuccess,
-        error: errorMsg
-      });
-    }
-    if (toolCallCount > 0) {
-      for (let tcIdx = 0; tcIdx < toolCallCount; tcIdx++) {
-        const tc = turn.toolCalls[tcIdx];
-        const isLast = tcIdx === toolCallCount - 1 && textSubSteps === 0;
-        const toolBudgetSteps = toolSubSteps + textSubSteps;
-        const toolFraction = toolBudgetSteps > 0 ? 1 / toolBudgetSteps : 1;
-        const remainingFraction = (totalSubSteps - thinkingSubSteps) / totalSubSteps;
-        subSteps.push({
-          id: (0, import_crypto3.randomUUID)(),
-          stepNumber: 0,
-          turnIndex,
-          type: import_evalforge_types7.LLMStepType.TOOL_USE,
-          model: stepModel,
-          provider: stepProvider,
-          startedAt,
-          durationMs: isLast ? durationMs - subSteps.reduce((s, ss) => s + ss.durationMs, 0) : Math.round(durationMs * remainingFraction * toolFraction),
-          tokenUsage: {
-            prompt: Math.round(
-              stepInputTokens * remainingFraction * toolFraction
-            ),
-            completion: Math.round(
-              stepOutputTokens * remainingFraction * toolFraction
-            ),
-            total: Math.round(
-              (stepInputTokens + stepOutputTokens) * remainingFraction * toolFraction
-            )
-          },
-          costUsd: stepCost * remainingFraction * toolFraction,
-          toolName: tc.toolName,
-          toolArguments: JSON.stringify(tc.args),
-          outputPreview: tcIdx === 0 && !hasText ? (text || thinking)?.slice(0, 200) : void 0,
-          success: isSuccess,
-          error: errorMsg
-        });
-      }
-    }
-    if (hasText && toolCallCount > 0) {
-      subSteps.push({
-        id: (0, import_crypto3.randomUUID)(),
-        stepNumber: 0,
-        turnIndex,
-        type: import_evalforge_types7.LLMStepType.COMPLETION,
-        model: stepModel,
-        provider: stepProvider,
-        startedAt,
-        durationMs: durationMs - subSteps.reduce((s, ss) => s + ss.durationMs, 0),
-        tokenUsage: {
-          prompt: stepInputTokens - subSteps.reduce((s, ss) => s + ss.tokenUsage.prompt, 0),
-          completion: stepOutputTokens - subSteps.reduce((s, ss) => s + ss.tokenUsage.completion, 0),
-          total: stepInputTokens + stepOutputTokens - subSteps.reduce((s, ss) => s + ss.tokenUsage.total, 0)
-        },
-        costUsd: stepCost - subSteps.reduce((s, ss) => s + ss.costUsd, 0),
-        outputPreview: text.slice(0, 200),
-        success: isSuccess,
-        error: errorMsg
-      });
-    }
-    if (subSteps.length === 0) {
-      const stepType = hasThinking && !hasText ? import_evalforge_types7.LLMStepType.THINKING : import_evalforge_types7.LLMStepType.COMPLETION;
-      subSteps.push({
-        id: (0, import_crypto3.randomUUID)(),
-        stepNumber: 0,
-        turnIndex,
-        type: stepType,
-        model: stepModel,
-        provider: stepProvider,
-        startedAt,
-        durationMs,
-        tokenUsage: {
-          prompt: stepInputTokens,
-          completion: stepOutputTokens,
-          total: stepInputTokens + stepOutputTokens
-        },
-        costUsd: stepCost,
-        outputPreview: (text || thinking)?.slice(0, 200),
+        costUsd: stepCost * remainingFraction * toolFraction,
+        toolName: tc.toolName,
+        toolArguments: JSON.stringify(tc.args),
+        outputPreview: tcIdx === 0 && !hasText ? (text || thinking)?.slice(0, 200) : void 0,
         success: isSuccess,
         error: errorMsg
       });
     }
-    return subSteps;
-  }).map((s, i) => ({ ...s, stepNumber: i + 1 }));
+  }
+  if (hasText && toolCallCount > 0) {
+    subSteps.push({
+      id: (0, import_crypto3.randomUUID)(),
+      stepNumber: 0,
+      turnIndex,
+      type: import_evalforge_types7.LLMStepType.COMPLETION,
+      model: stepModel,
+      provider: stepProvider,
+      startedAt,
+      durationMs: durationMs - subSteps.reduce((s, ss) => s + ss.durationMs, 0),
+      tokenUsage: {
+        prompt: stepInputTokens - subSteps.reduce((s, ss) => s + ss.tokenUsage.prompt, 0),
+        completion: stepOutputTokens - subSteps.reduce((s, ss) => s + ss.tokenUsage.completion, 0),
+        total: stepInputTokens + stepOutputTokens - subSteps.reduce((s, ss) => s + ss.tokenUsage.total, 0)
+      },
+      costUsd: stepCost - subSteps.reduce((s, ss) => s + ss.costUsd, 0),
+      outputPreview: text.slice(0, 200),
+      success: isSuccess,
+      error: errorMsg
+    });
+  }
+  if (subSteps.length === 0) {
+    const stepType = hasThinking && !hasText ? import_evalforge_types7.LLMStepType.THINKING : import_evalforge_types7.LLMStepType.COMPLETION;
+    subSteps.push({
+      id: (0, import_crypto3.randomUUID)(),
+      stepNumber: 0,
+      turnIndex,
+      type: stepType,
+      model: stepModel,
+      provider: stepProvider,
+      startedAt,
+      durationMs,
+      tokenUsage: {
+        prompt: stepInputTokens,
+        completion: stepOutputTokens,
+        total: stepInputTokens + stepOutputTokens
+      },
+      costUsd: stepCost,
+      outputPreview: (text || thinking)?.slice(0, 200),
+      success: isSuccess,
+      error: errorMsg
+    });
+  }
+  return subSteps;
+}
+function buildSummary(allSteps, turns, turnCosts, totalDurationMs, canonicalModel) {
   let totalPrompt = 0;
   let totalCompletion = 0;
   let totalCost = 0;
-  for (const turn of turns) {
+  turns.forEach((turn, turnIndex) => {
     if (turn.stepFinish) {
       totalPrompt += turn.stepFinish.tokens.input;
       totalCompletion += turn.stepFinish.tokens.output;
-      totalCost += turn.stepFinish.cost;
+      totalCost += turnCosts[turnIndex];
     }
-  }
+  });
   const totalTokens = {
     prompt: totalPrompt,
     completion: totalCompletion,
@@ -9853,7 +9888,7 @@ function buildLLMTrace(timestampedEvents, totalDurationMs, model, provider, exec
     stepTypeBreakdown[step.type] = entry;
   }
   const modelUsed = allSteps[0]?.model || canonicalModel;
-  const summary = {
+  return {
     totalSteps: allSteps.length,
     totalTurns: turns.length,
     totalDurationMs,
@@ -9870,11 +9905,97 @@ function buildLLMTrace(timestampedEvents, totalDurationMs, model, provider, exec
     modelsUsed: [modelUsed],
     stepTypeBreakdown
   };
-  return {
-    id: (0, import_crypto3.randomUUID)(),
-    steps: allSteps,
-    summary
+}
+function buildLLMTrace(timestampedEvents, totalDurationMs, model, provider, executionStartTime, gatewayCosts) {
+  const canonicalModel = toCanonicalModelId(model);
+  const turns = groupEventsIntoTurns(timestampedEvents);
+  const turnCosts = resolveTurnCosts(turns, gatewayCosts);
+  const ctx = {
+    turns,
+    turnCosts,
+    totalDurationMs,
+    executionStartMs: executionStartTime.getTime(),
+    model,
+    provider
   };
+  const allSteps = turns.flatMap((turn, turnIndex) => buildTurnSteps(turn, turnIndex, ctx)).map((step, i) => ({ ...step, stepNumber: i + 1 }));
+  const summary = buildSummary(
+    allSteps,
+    turns,
+    turnCosts,
+    totalDurationMs,
+    canonicalModel
+  );
+  return { id: (0, import_crypto3.randomUUID)(), steps: allSteps, summary };
+}
+
+// src/run-scenario/agents/opencode/gateway-cost-interceptor.ts
+var import_node_http = __toESM(require("node:http"));
+var import_node_https = __toESM(require("node:https"));
+var import_node_url = require("node:url");
+var TAIL_BYTES = 64 * 1024;
+var COST_RE = /"total_cost_usd"\s*:\s*(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/g;
+function extractLastCost(text) {
+  let match;
+  let last = null;
+  COST_RE.lastIndex = 0;
+  while ((match = COST_RE.exec(text)) !== null) {
+    const value = Number(match[1]);
+    if (Number.isFinite(value)) last = value;
+  }
+  return last;
+}
+function startGatewayCostInterceptor(realGatewayUrl) {
+  const base = realGatewayUrl.replace(/\/$/, "");
+  const captured = [];
+  const server = import_node_http.default.createServer((clientReq, clientRes) => {
+    const slot = captured.length;
+    captured.push(null);
+    const target = new import_node_url.URL(base + (clientReq.url ?? ""));
+    const transport = target.protocol === "https:" ? import_node_https.default : import_node_http.default;
+    const headers = { ...clientReq.headers };
+    delete headers.host;
+    headers["accept-encoding"] = "identity";
+    const proxyReq = transport.request(
+      {
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port,
+        path: target.pathname + target.search,
+        method: clientReq.method,
+        headers
+      },
+      (proxyRes) => {
+        clientRes.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+        let tail = "";
+        proxyRes.on("data", (chunk) => {
+          clientRes.write(chunk);
+          tail = (tail + chunk.toString("utf8")).slice(-TAIL_BYTES);
+        });
+        proxyRes.on("end", () => {
+          clientRes.end();
+          captured[slot] = extractLastCost(tail);
+        });
+        proxyRes.on("error", () => clientRes.destroy());
+      }
+    );
+    proxyReq.on("error", () => {
+      if (!clientRes.headersSent) clientRes.writeHead(502);
+      clientRes.end();
+    });
+    clientReq.pipe(proxyReq);
+  });
+  return new Promise((resolve3) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      resolve3({
+        url: `http://127.0.0.1:${port}`,
+        getCapturedCosts: () => captured.slice(),
+        close: () => new Promise((r) => server.close(() => r()))
+      });
+    });
+  });
 }
 
 // src/run-scenario/agents/opencode/build-conversation.ts
@@ -10150,6 +10271,7 @@ function spawnOpenCodeProcess(opts) {
   return new Promise((resolve3) => {
     let resolved = false;
     let stderr = "";
+    let rawStdout = "";
     let lineBuffer = "";
     let lastOutputTime = Date.now();
     let traceStepNumber = initialStepNumber;
@@ -10271,6 +10393,7 @@ function spawnOpenCodeProcess(opts) {
     child.stdout?.on("data", (data) => {
       const text = data.toString();
       lastOutputTime = Date.now();
+      rawStdout += text;
       lineBuffer += text;
       const lines = lineBuffer.split("\n");
       lineBuffer = lines.pop() || "";
@@ -10314,7 +10437,7 @@ function spawnOpenCodeProcess(opts) {
       stderr += text;
       lastOutputTime = Date.now();
     });
-    child.on("close", (code) => {
+    child.on("close", (code, signal) => {
       if (lineBuffer.trim()) {
         const evt = tryParseJson(lineBuffer);
         if (evt && evt.type) {
@@ -10322,8 +10445,18 @@ function spawnOpenCodeProcess(opts) {
         }
       }
       console.log(
-        `[executeWithOpenCode] Process exited with code ${code}, ${events.length} events collected`
+        `[executeWithOpenCode] Process exited with code ${code}, signal ${signal}, ${events.length} events collected`
       );
+      if (events.length === 0) {
+        console.error(
+          `[executeWithOpenCode] No events. exitCode=${code} signal=${signal}
+--- raw stdout (first 4000) ---
+${rawStdout.slice(0, 4e3)}
+--- raw stderr (first 4000) ---
+${stderr.slice(0, 4e3)}
+--- end raw output ---`
+        );
+      }
       if (code === 0) {
         finalize(true, false);
       } else {
@@ -10346,7 +10479,7 @@ Stderr: ${stderr.slice(0, 1e3)}`
     });
   });
 }
-async function executeWithOpenCode(skills, scenario, options) {
+async function executeWithOpenCodeInner(skills, scenario, options, interceptor) {
   const skillNames = skills.map((s) => s.name).join(", ");
   console.log("[executeWithOpenCode] Starting execution", {
     skillCount: skills.length,
@@ -10365,7 +10498,9 @@ async function executeWithOpenCode(skills, scenario, options) {
     temperature: options.temperature,
     topP: options.topP,
     maxTurns,
-    aiGatewayUrl: options.aiGatewayUrl,
+    // Point OpenCode at the local interceptor (which forwards to the real
+    // gateway and captures the true cost); fall back to the gateway directly.
+    aiGatewayUrl: interceptor?.url ?? options.aiGatewayUrl,
     aiGatewayHeaders: options.aiGatewayHeaders,
     mcps: options.mcps,
     rules: options.rules,
@@ -10518,13 +10653,11 @@ Attempt: ${attempt}, Events: ${accumulatedEvents.length}`
   }
   let inputTokens = 0;
   let outputTokens = 0;
-  let costUsd = 0;
   for (const { event: evt } of accumulatedEvents) {
     if (evt.type === "step_finish") {
       const sf = evt;
       inputTokens += sf.part.tokens.input;
       outputTokens += sf.part.tokens.output;
-      costUsd += sf.part.cost;
     }
   }
   if (traceContext) {
@@ -10550,7 +10683,8 @@ Attempt: ${attempt}, Events: ${accumulatedEvents.length}`
     totalDurationMs,
     modelStr,
     providerID,
-    startTime
+    startTime,
+    interceptor?.getCapturedCosts()
   );
   const conversation = buildConversation2(accumulatedEvents);
   return {
@@ -10562,12 +10696,26 @@ Attempt: ${attempt}, Events: ${accumulatedEvents.length}`
         outputTokens,
         totalTokens: inputTokens + outputTokens
       },
-      costUsd
+      // Single source of truth: gateway-derived cost aggregated in the trace.
+      costUsd: llmTrace.summary.totalCostUsd
     },
     llmTrace,
     conversation
   };
 }
+async function executeWithOpenCode(skills, scenario, options) {
+  const interceptor = options.aiGatewayUrl ? await startGatewayCostInterceptor(options.aiGatewayUrl) : void 0;
+  try {
+    return await executeWithOpenCodeInner(
+      skills,
+      scenario,
+      options,
+      interceptor
+    );
+  } finally {
+    await interceptor?.close();
+  }
+}
 
 // src/run-scenario/agents/opencode/opencode-adapter.ts
 var OpenCodeAdapter = class {