@ggui-ai/ui-gen 0.20.0 → 0.22.0

package/src/harness/coding/generate-task-runner.ts

@@ -12,7 +12,7 @@
 
 import type { Classification } from "../../classifier/index.js";
 import type { JsonValue } from "@ggui-ai/protocol";
-import type { EvalResult } from "../../evaluation/types-public.js";
+import type { ContractFeedbackRecord, EvalResult } from "../../evaluation/types-public.js";
 import type { Harness, Task, TaskContext } from "../types-public.js";
 import type { SingleComponentParams } from "../runtime.js";
 import type { TaskRunner } from "../index.js";
@@ -20,8 +20,11 @@ import type { CodingSession } from "./init-session.js";
 import {
   runCodingTurn,
   type A1Phase,
+  type CodingTurnResult,
 } from "./run-coding-turn.js";
 import { runEvalRound } from "./run-eval-round.js";
+import type { TokenUsage } from "./run-eval-round.js";
+import type { SameExchangeBreak } from "../result-types.js";
 
 type PreWarmedEvalContext =
   import("../../evaluation/llm-evaluator.js").PreWarmedEvalContext;
@@ -64,15 +67,27 @@ export interface GenerateTelemetry {
   /** Total output tokens billed across coding + eval. */
   totalOut: number;
   /**
-   * Prompt-cache tokens accumulated across coding turns, when the
-   * provider reports them. Optional: stays `undefined` for providers
-   * that don't expose cache accounting (never defaulted to 0 here, so
-   * the boundary can distinguish "no cache reads" from "unreported").
+   * Prompt-cache tokens accumulated across coding turns AND eval rounds
+   * (ggui#1281), when the provider reports them. Optional: stays
+   * `undefined` for providers that don't expose cache accounting (never
+   * defaulted to 0 here, so the boundary can distinguish "no cache reads"
+   * from "unreported").
    */
   cacheReadTokens?: number;
   cacheCreationTokens?: number;
   /** Latest evalResult — undefined when eval was disabled or never ran. */
   evalResult: EvalResult | undefined;
+  /**
+   * ggui#1261 — the contract-feedback round, once one fired: kept across the
+   * rounds after it (each rebuilds `evalResult`) so the assembled result can
+   * carry the round's before beside the source the generation ends with.
+   */
+  contractFeedback: ContractFeedbackRecord | undefined;
+  /**
+   * The same-exchange guard's record (ggui#404), set by the turn it ended —
+   * undefined unless that guard is what stopped the loop.
+   */
+  sameExchangeBreak: SameExchangeBreak | undefined;
   /** Latest compiled code — empty string until the first self-check pass. */
   compiledCode: string;
   /**
@@ -111,6 +126,8 @@ export function createTelemetry(): GenerateTelemetry {
     totalIn: 0,
     totalOut: 0,
     evalResult: undefined,
+    contractFeedback: undefined,
+    sameExchangeBreak: undefined,
     compiledCode: "",
     pairedSource: "",
     selfCheckPassed: false,
@@ -120,6 +137,56 @@ export function createTelemetry(): GenerateTelemetry {
   };
 }
 
+/**
+ * Fold one call's (or one eval round's) tokens into the run's totals — the ONE
+ * rule for coding turns and eval rounds alike (ggui#1281: the eval path used to
+ * add input/output only, so `tokens.total` dropped every eval call's cached
+ * prefix). A cache counter is seeded on its first report and stays `undefined`
+ * while nothing has reported one: unreported, never zero.
+ */
+export function absorbTokens(telemetry: GenerateTelemetry, usage: TokenUsage): void {
+  telemetry.totalIn += usage.input;
+  telemetry.totalOut += usage.output;
+  if (usage.cacheRead !== undefined) {
+    telemetry.cacheReadTokens = (telemetry.cacheReadTokens ?? 0) + usage.cacheRead;
+  }
+  if (usage.cacheCreation !== undefined) {
+    telemetry.cacheCreationTokens = (telemetry.cacheCreationTokens ?? 0) + usage.cacheCreation;
+  }
+}
+
+/**
+ * Fold one coding turn's measurements into the run's telemetry — tokens (via
+ * {@link absorbTokens}), timings, the phase/outcome counters, and the
+ * same-exchange guard's record when that guard ended the turn (ggui#404). One
+ * function so every per-turn fact the result is assembled from lands in one
+ * place.
+ */
+export function absorbTurn(telemetry: GenerateTelemetry, turn: CodingTurnResult): void {
+  absorbTokens(telemetry, {
+    input: turn.tokens.input,
+    output: turn.tokens.output,
+    ...(turn.cacheReadTokens !== undefined ? { cacheRead: turn.cacheReadTokens } : {}),
+    ...(turn.cacheCreationTokens !== undefined ? { cacheCreation: turn.cacheCreationTokens } : {}),
+  });
+  telemetry.cumulativeLlmMs += turn.llmMs;
+  telemetry.cumulativeToolMs += turn.toolMs;
+  if (turn.phase) {
+    if (turn.phase === "scaffold") telemetry.counters.phases.scaffold++;
+    else if (turn.phase === "fill") telemetry.counters.phases.fill++;
+    else if (turn.phase === "impl") telemetry.counters.phases.impl++;
+    else if (turn.phase === "eval-fix") telemetry.counters.phases.evalFix++;
+    else telemetry.counters.phases.patch++;
+  }
+  if (turn.outcome) {
+    if (turn.outcome === "PASS") telemetry.counters.outcomes.pass++;
+    else if (turn.outcome === "PATCH_INVALID") telemetry.counters.outcomes.patchInvalid++;
+    else if (turn.outcome === "DIFF_FAIL") telemetry.counters.outcomes.diffFail++;
+    else telemetry.counters.outcomes.selfCheckFail++;
+  }
+  if (turn.sameExchangeBreak !== undefined) telemetry.sameExchangeBreak = turn.sameExchangeBreak;
+}
+
 export interface CreateGenerateRunnerInput {
   readonly session: CodingSession;
   readonly params: SingleComponentParams;
@@ -203,38 +270,10 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
         },
       );
 
-      telemetry.totalIn += turn.tokens.input;
-      telemetry.totalOut += turn.tokens.output;
-      // Accumulate prompt-cache counters only when the provider reported
-      // them this turn. Seeding from `undefined` on first report keeps the
-      // "unreported" providers' totals absent rather than 0.
-      if (turn.cacheReadTokens !== undefined) {
-        telemetry.cacheReadTokens =
-          (telemetry.cacheReadTokens ?? 0) + turn.cacheReadTokens;
-      }
-      if (turn.cacheCreationTokens !== undefined) {
-        telemetry.cacheCreationTokens =
-          (telemetry.cacheCreationTokens ?? 0) + turn.cacheCreationTokens;
-      }
-      telemetry.cumulativeLlmMs += turn.llmMs;
-      telemetry.cumulativeToolMs += turn.toolMs;
+      absorbTurn(telemetry, turn);
       iconNamesCache = turn.iconNamesCache;
       preWarmedContext = turn.preWarmedContext;
 
-      if (turn.phase) {
-        if (turn.phase === "scaffold") telemetry.counters.phases.scaffold++;
-        else if (turn.phase === "fill") telemetry.counters.phases.fill++;
-        else if (turn.phase === "impl") telemetry.counters.phases.impl++;
-        else if (turn.phase === "eval-fix") telemetry.counters.phases.evalFix++;
-        else telemetry.counters.phases.patch++;
-      }
-      if (turn.outcome) {
-        if (turn.outcome === "PASS") telemetry.counters.outcomes.pass++;
-        else if (turn.outcome === "PATCH_INVALID") telemetry.counters.outcomes.patchInvalid++;
-        else if (turn.outcome === "DIFF_FAIL") telemetry.counters.outcomes.diffFail++;
-        else telemetry.counters.outcomes.selfCheckFail++;
-      }
-
       if (turn.control === "break") break;
       if (turn.control === "continue") {
         lastResultText = turn.lastResultText;
@@ -334,9 +373,9 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
         prevFailFingerprints = round.prevFailFingerprints;
         preWarmedContext = round.preWarmedContext;
         if (round.evalResult) telemetry.evalResult = round.evalResult;
+        if (round.contractFeedback) telemetry.contractFeedback = round.contractFeedback;
         evalDone = round.evalDone;
-        telemetry.totalIn += round.evalTokens.input;
-        telemetry.totalOut += round.evalTokens.output;
+        absorbTokens(telemetry, round.evalTokens);
 
         if (round.control === "break") break;
         // round.control === "feedback" — set next coding turn input.

package/src/harness/coding/run-coding-turn.ts

@@ -21,6 +21,7 @@ import { executeTool } from "../../coding-agent/tools.js";
 import type { CostTracker } from "../../evaluation/cost-tracker.js";
 import type { LLMAgent } from "../llm-router.js";
 import type { Harness } from "../types-public.js";
+import type { SameExchangeBreak } from "../result-types.js";
 import {
   APPLY_CHANGES_HASHLINE_TOOL,
   APPLY_CHANGES_HASHLINE_TOOL_FLAT,
@@ -244,6 +245,12 @@ export interface CodingTurnResult {
   readonly isEvalFeedback: boolean;
   readonly iconNamesCache: string | null;
   readonly preWarmedContext: PreWarmedEvalContext | null | undefined;
+  /**
+   * Set only on the `break` the same-exchange guard returns (ggui#404) — the
+   * one way a caller can tell this guard ended the run, since `break` is a
+   * control value many exits share. No key on any other turn.
+   */
+  readonly sameExchangeBreak?: SameExchangeBreak;
 }
 
 /**
@@ -637,6 +644,7 @@ ${closingInstruction}`;
         isEvalFeedback: false,
         iconNamesCache,
         preWarmedContext,
+        sameExchangeBreak: { tool: call.name, repeats: iconRepeats },
       };
     }
     return {
@@ -964,6 +972,7 @@ ${closingInstruction}`;
       isEvalFeedback: false,
       iconNamesCache,
       preWarmedContext,
+      sameExchangeBreak: { tool: call.name, repeats: sameExchangeRepeats },
     };
   }