@ggui-ai/ui-gen 0.21.0 → 0.22.0

package/dist/adapters/generation-dispatch.d.ts

@@ -1,7 +1,7 @@
 import { EvaluationConfig } from '../evaluation/types.js';
 import { ModelRoles, GenerationResult } from '../harness/result-types.js';
 import { ProviderName, ToolDefinition } from './types.js';
-import { Q as QualityConfig } from '../types-public-CzYqZclY.js';
+import { Q as QualityConfig } from '../types-public-mM_-1Yk3.js';
 import { A as AgentConfig } from '../llm-router-DwwUK1bz.js';
 import { DataContract, JsonObject, GadgetDescriptor } from '@ggui-ai/protocol';
 import { C as CanvasClass, D as DesignMode } from '../design-mode-DLufhrNp.js';

package/dist/adapters/generation-dispatch.js

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { getCssTokens, fillFitRule, FORBIDDEN_IMPORT_SPECIFIERS } from '@ggui-ai/design/rendering';
 import * as esbuild from 'esbuild';
 import { build } from 'esbuild';
-import fs, { existsSync, mkdirSync, writeFileSync, unlinkSync, readFileSync, readdirSync, statSync } from 'fs';
+import fs, { existsSync, mkdtempSync, writeFileSync, rmSync, readFileSync, readdirSync, statSync } from 'fs';
 import { contentHash } from '@ggui-ai/protocol/content-hash';
 import { createRequire } from 'module';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -649,26 +649,51 @@ var init_client = __esm({
 });
 
 // src/adapters/claude/claude-code-login.ts
-function stripProviderKeyEnv(env) {
+function loginChildEnv(env) {
   const out = {};
-  const drop = new Set(PROVIDER_KEY_ENV_NAMES);
   for (const [k, v] of Object.entries(env)) {
-    if (v !== void 0 && !drop.has(k)) out[k] = v;
+    if (v !== void 0 && (LOGIN_CHILD_ENV.has(k) || k.startsWith("LC_"))) out[k] = v;
   }
   return out;
 }
 function claudeCodeLoginQueryOptions() {
   return { tools: [], settingSources: [] };
 }
-var PROVIDER_KEY_ENV_NAMES;
+var LOGIN_CHILD_ENV_NAMES, LOGIN_CHILD_ENV;
 var init_claude_code_login = __esm({
   "src/adapters/claude/claude-code-login.ts"() {
-    PROVIDER_KEY_ENV_NAMES = [
-      "ANTHROPIC_API_KEY",
-      "CLAUDE_API_KEY",
-      "ANTHROPIC_AUTH_TOKEN",
-      "ANTHROPIC_BASE_URL"
+    LOGIN_CHILD_ENV_NAMES = [
+      "PATH",
+      "HOME",
+      "USER",
+      "LOGNAME",
+      "SHELL",
+      "TMPDIR",
+      "TMP",
+      "TEMP",
+      "TERM",
+      "TZ",
+      "LANG",
+      "CLAUDE_CONFIG_DIR",
+      "CLAUDE_CODE_OAUTH_TOKEN",
+      "XDG_CONFIG_HOME",
+      "XDG_DATA_HOME",
+      "XDG_CACHE_HOME",
+      "XDG_STATE_HOME",
+      "XDG_RUNTIME_DIR",
+      "HTTPS_PROXY",
+      "https_proxy",
+      "HTTP_PROXY",
+      "http_proxy",
+      "NO_PROXY",
+      "no_proxy",
+      "ALL_PROXY",
+      "all_proxy",
+      "NODE_EXTRA_CA_CERTS",
+      "SSL_CERT_FILE",
+      "SSL_CERT_DIR"
     ];
+    LOGIN_CHILD_ENV = new Set(LOGIN_CHILD_ENV_NAMES);
   }
 });
 
@@ -815,7 +840,7 @@ function buildLoginQueryOptions(params) {
     systemPrompt: params.systemPrompt,
     maxTurns: 1,
     thinking: { type: "disabled" },
-    env: stripProviderKeyEnv(params.env ?? process.env),
+    env: loginChildEnv(params.env ?? process.env),
     ...claudeCodeLoginQueryOptions(),
     ...params.tools !== void 0 ? {
       mcpServers: { [MCP_SERVER_NAME]: params.tools.server },
@@ -5891,6 +5916,14 @@ function getDefaultEvalModel(provider) {
       return "claude-haiku-4-5-20251001";
   }
 }
+function callTokens(response) {
+  return {
+    in: response.inputTokens,
+    out: response.outputTokens,
+    ...response.cacheReadTokens !== void 0 ? { cacheRead: response.cacheReadTokens } : {},
+    ...response.cacheCreationTokens !== void 0 ? { cacheCreation: response.cacheCreationTokens } : {}
+  };
+}
 async function evalCriterion(criterion, tier, motherPrompt, numberedSource, agent, model, designMode) {
   const start = Date.now();
   const tool = tier === 1 ? makeTier1Tool(criterion) : makeTier2Tool(criterion);
@@ -5914,7 +5947,7 @@ async function evalCriterion(criterion, tier, motherPrompt, numberedSource, agen
         pass: true,
         coverage: "skipped",
         skipReason: "no tool call returned",
-        tokens: { in: response.inputTokens, out: response.outputTokens },
+        tokens: callTokens(response),
         durationMs
       };
     }
@@ -5967,7 +6000,7 @@ async function evalCriterion(criterion, tier, motherPrompt, numberedSource, agen
       issues,
       pass,
       coverage: "ran",
-      tokens: { in: response.inputTokens, out: response.outputTokens },
+      tokens: callTokens(response),
       durationMs
     };
   } catch (e) {
@@ -6050,7 +6083,8 @@ async function runLLMEvaluation(context, config, preWarmedContext) {
   const passCategories = [];
   let totalIn = 0;
   let totalOut = 0;
-  let cachedTokensEstimate = 0;
+  let cacheRead;
+  let cacheCreation;
   for (const r of results) {
     allIssues.push(...r.issues);
     if (r.pass) {
@@ -6058,10 +6092,8 @@ async function runLLMEvaluation(context, config, preWarmedContext) {
     }
     totalIn += r.tokens.in;
     totalOut += r.tokens.out;
-  }
-  const firstResult = results[0];
-  if (firstResult && firstResult.tokens.in > 0) {
-    cachedTokensEstimate = firstResult.tokens.in * (totalCriteriaCount - 1);
+    if (r.tokens.cacheRead !== void 0) cacheRead = (cacheRead ?? 0) + r.tokens.cacheRead;
+    if (r.tokens.cacheCreation !== void 0) cacheCreation = (cacheCreation ?? 0) + r.tokens.cacheCreation;
   }
   const wallMs = Date.now() - evalStart;
   const criteriaCoverage = results.map((r) => ({
@@ -6078,14 +6110,16 @@ async function runLLMEvaluation(context, config, preWarmedContext) {
     console.log(`[eval] ${r.criterion}: ${status}${issueLabel} ${(r.durationMs / 1e3).toFixed(1)}s`);
   }
   console.log(
-    `[eval] total: ${(wallMs / 1e3).toFixed(1)}s wall (${totalCriteriaCount} parallel) | in=${totalIn} out=${totalOut} cached~=${cachedTokensEstimate} | issues=${allIssues.length} pass=${passCategories.length}` + (skippedCount > 0 ? ` skipped=${skippedCount}` : "")
+    `[eval] total: ${(wallMs / 1e3).toFixed(1)}s wall (${totalCriteriaCount} parallel) | in=${totalIn} out=${totalOut} cacheRead=${cacheRead ?? "unreported"} cacheWrite=${cacheCreation ?? "unreported"} | issues=${allIssues.length} pass=${passCategories.length}` + (skippedCount > 0 ? ` skipped=${skippedCount}` : "")
   );
   return {
     issues: allIssues,
     pass: passCategories,
     criteriaCoverage,
     inputTokens: totalIn,
-    outputTokens: totalOut
+    outputTokens: totalOut,
+    ...cacheRead !== void 0 ? { cacheReadTokens: cacheRead } : {},
+    ...cacheCreation !== void 0 ? { cacheCreationTokens: cacheCreation } : {}
   };
 }
 var FREE_STYLING_RULES, CONSTRAINED_STYLING_RULES, CONSTRAINED_VISUAL_REFERENCE, FREE_VISUAL_REFERENCE, CONSTRAINED_RAW_CLICK_TARGET_GAP, FREE_RAW_CLICK_TARGET_GAP, TIER_1_CRITERIA, TIER_2_CRITERIA, TIER_1_CATEGORIES, TIER_2_CATEGORIES, VALID_CATEGORIES;
@@ -6339,8 +6373,7 @@ function resolveDesignPackageDir() {
   }
 }
 async function bundleForRendering(compiledCode, sampleProps, designSrc = resolve(resolveDesignPackageDir(), "src")) {
-  const tmpDir = resolve(tmpdir(), "ggui-visual-eval-" + Date.now());
-  mkdirSync(tmpDir, { recursive: true });
+  const tmpDir = mkdtempSync(resolve(tmpdir(), "ggui-visual-eval-"));
   const componentFile = resolve(tmpDir, "component.tsx");
   const entryFile = resolve(tmpDir, "entry.tsx");
   const designPkgDir = resolve(designSrc, "..");
@@ -6415,14 +6448,7 @@ try {
     });
     return result.outputFiles[0]?.text ?? "";
   } finally {
-    try {
-      unlinkSync(entryFile);
-    } catch {
-    }
-    try {
-      unlinkSync(componentFile);
-    } catch {
-    }
+    rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function buildRenderHTML(bundledCode, cssTokens, fit) {
@@ -14344,7 +14370,11 @@ async function assembleGenerationResult(input) {
     generationTimeMs: totalMs,
     turnsUsed: telemetry.turnsUsed,
     passesUsed: 1,
-    evalResult: telemetry.evalResult,
+    // ggui#1261 — the contract-feedback round's record rides the result the
+    // generation ends with (whose probe stamp is the post-round verdict).
+    evalResult: telemetry.evalResult !== void 0 && telemetry.contractFeedback !== void 0 ? { ...telemetry.evalResult, contractFeedback: telemetry.contractFeedback } : telemetry.evalResult,
+    // ggui#404 — present only when the same-exchange guard ended the run.
+    ...telemetry.sameExchangeBreak !== void 0 ? { sameExchangeBreak: telemetry.sameExchangeBreak } : {},
     needsBackgroundImprovement,
     selfCheckPassed: telemetry.selfCheckPassed,
     timing,
@@ -15107,7 +15137,8 @@ ${iconNamesCache}`;
         lastDiffFailed: false,
         isEvalFeedback: false,
         iconNamesCache,
-        preWarmedContext
+        preWarmedContext,
+        sameExchangeBreak: { tool: call.name, repeats: iconRepeats }
       };
     }
     return {
@@ -15307,7 +15338,8 @@ Repeated error: ${errText}
       lastDiffFailed: false,
       isEvalFeedback: false,
       iconNamesCache,
-      preWarmedContext
+      preWarmedContext,
+      sameExchangeBreak: { tool: call.name, repeats: sameExchangeRepeats }
     };
   }
   const turnDiffFailed = !!result.error && result.result.includes("DIFF");
@@ -15496,6 +15528,20 @@ function formatRuntimeProbeFeedback(issue) {
   return `[runtime] ${issue.category}${subcat}: ${issue.description}
   Fix: ${issue.fix ?? ""}`;
 }
+var FEEDBACK_PROBE_CHECKS = ["prop-sensitivity"];
+var CONTRACT_FEEDBACK_BONUS = 1;
+function isFeedbackProbeFail(issue) {
+  const sub = issue.subcategory;
+  if (issue.result !== "fail" || typeof sub !== "string") return false;
+  return FEEDBACK_PROBE_CHECKS.some((check) => sub === `runtime:${check}` || sub.startsWith(`runtime:${check}:`));
+}
+function contractFeedbackRecord(fails, sourceBefore) {
+  return { firedOn: fails.flatMap((i) => i.subcategory !== void 0 ? [i.subcategory] : []), sourceBefore };
+}
+function contractFeedbackFails(exitProbe, alreadyFedBack) {
+  if (!exitProbe.fired) return [];
+  return exitProbe.probeIssues.filter((i) => isFeedbackProbeFail(i) && !alreadyFedBack.has(fingerprintFail(i)));
+}
 async function runEvalRound(ctx, input) {
   const {
     workspace,
@@ -15685,7 +15731,9 @@ async function runEvalRound(ctx, input) {
       costTracker.record(evaluationAgent.model, llmResult.inputTokens, llmResult.outputTokens);
       evalTokens = {
         input: llmResult.inputTokens,
-        output: llmResult.outputTokens
+        output: llmResult.outputTokens,
+        ...llmResult.cacheReadTokens !== void 0 ? { cacheRead: llmResult.cacheReadTokens } : {},
+        ...llmResult.cacheCreationTokens !== void 0 ? { cacheCreation: llmResult.cacheCreationTokens } : {}
       };
     }
     const allIssues = [
@@ -15770,6 +15818,34 @@ async function runEvalRound(ctx, input) {
           lastDiffFailed: false
         };
       }
+      const contractFails = contractFeedbackFails(exitProbe, prevFailFingerprints);
+      if (contractFails.length > 0 && evalRoundsUsed < maxEvalRounds + CONTRACT_FEEDBACK_BONUS) {
+        const lines = contractFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        evalResult = {
+          ...evalResult,
+          issues: [...allIssues, ...exitProbe.probeIssues],
+          pass: allPass,
+          runtimeProbe: exitProbe.meta
+        };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: tier-1/2 clean BUT contract probe fail \u2014 granting +1 turn (ggui#1261; ${contractFails.map((i) => i.subcategory).join(", ")})`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: /* @__PURE__ */ new Set([...currFailFingerprints, ...contractFails.map(fingerprintFail)]),
+          preWarmedContext,
+          evalTokens,
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false,
+          contractFeedback: contractFeedbackRecord(contractFails, currentSource)
+        };
+      }
       evalResult = {
         ...evalResult,
         issues: [...allIssues, ...exitProbe.probeIssues],
@@ -15809,6 +15885,28 @@ async function runEvalRound(ctx, input) {
         issues: [...evalResult.issues, ...stuckExitProbe.probeIssues],
         runtimeProbe: stuckExitProbe.meta
       };
+      const stuckContractFails = contractFeedbackFails(stuckExitProbe, prevFailFingerprints);
+      if (stuckContractFails.length > 0 && evalRoundsUsed < maxEvalRounds + CONTRACT_FEEDBACK_BONUS) {
+        const lines = stuckContractFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: stuck BUT contract probe fail never delivered \u2014 granting +1 turn (ggui#1261; ${stuckContractFails.map((i) => i.subcategory).join(", ")})`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: /* @__PURE__ */ new Set([...currFailFingerprints, ...stuckContractFails.map(fingerprintFail)]),
+          preWarmedContext,
+          evalTokens,
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false,
+          contractFeedback: contractFeedbackRecord(stuckContractFails, currentSource)
+        };
+      }
       return {
         control: "break",
         evalDone: false,
@@ -15863,6 +15961,33 @@ async function runEvalRound(ctx, input) {
           lastDiffFailed: false
         };
       }
+      const capContractFails = allowRuntimeExtension ? [] : contractFeedbackFails(exitProbe, prevFailFingerprints);
+      if (capContractFails.length > 0 && evalRoundsUsed < maxEvalRounds + CONTRACT_FEEDBACK_BONUS) {
+        const contractLines = capContractFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        evalResult = {
+          ...evalResult,
+          issues: [...evalResult.issues, ...exitProbe.probeIssues],
+          runtimeProbe: exitProbe.meta
+        };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: contract probe fail active at cap \u2014 granting +1 retry (ggui#1261; ${capContractFails.map((i) => i.subcategory).join(", ")})`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: /* @__PURE__ */ new Set([...currFailFingerprints, ...capContractFails.map(fingerprintFail)]),
+          preWarmedContext,
+          evalTokens,
+          evalLlmMs,
+          lastResultText: contractLines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false,
+          contractFeedback: contractFeedbackRecord(capContractFails, currentSource)
+        };
+      }
       if (!allowRuntimeExtension) {
         evalResult = {
           ...evalResult,
@@ -16005,6 +16130,8 @@ function createTelemetry() {
     totalIn: 0,
     totalOut: 0,
     evalResult: void 0,
+    contractFeedback: void 0,
+    sameExchangeBreak: void 0,
     compiledCode: "",
     pairedSource: "",
     selfCheckPassed: false,
@@ -16013,6 +16140,40 @@ function createTelemetry() {
     codingMs: 0
   };
 }
+function absorbTokens(telemetry, usage) {
+  telemetry.totalIn += usage.input;
+  telemetry.totalOut += usage.output;
+  if (usage.cacheRead !== void 0) {
+    telemetry.cacheReadTokens = (telemetry.cacheReadTokens ?? 0) + usage.cacheRead;
+  }
+  if (usage.cacheCreation !== void 0) {
+    telemetry.cacheCreationTokens = (telemetry.cacheCreationTokens ?? 0) + usage.cacheCreation;
+  }
+}
+function absorbTurn(telemetry, turn) {
+  absorbTokens(telemetry, {
+    input: turn.tokens.input,
+    output: turn.tokens.output,
+    ...turn.cacheReadTokens !== void 0 ? { cacheRead: turn.cacheReadTokens } : {},
+    ...turn.cacheCreationTokens !== void 0 ? { 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 !== void 0) telemetry.sameExchangeBreak = turn.sameExchangeBreak;
+}
 function createGenerateTaskRunner(input) {
   const { session, params, classification, telemetry } = input;
   const maxTurns = input.maxTurns ?? 30;
@@ -16065,31 +16226,9 @@ function createGenerateTaskRunner(input) {
           preWarmPromise: session.preWarmPromise
         }
       );
-      telemetry.totalIn += turn.tokens.input;
-      telemetry.totalOut += turn.tokens.output;
-      if (turn.cacheReadTokens !== void 0) {
-        telemetry.cacheReadTokens = (telemetry.cacheReadTokens ?? 0) + turn.cacheReadTokens;
-      }
-      if (turn.cacheCreationTokens !== void 0) {
-        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;
@@ -16165,9 +16304,9 @@ function createGenerateTaskRunner(input) {
         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;
         lastResultText = round.lastResultText;
         isEvalFeedback = round.isEvalFeedback;