libretto 0.3.2 → 0.4.0

package/dist/cli/commands/ai.js

@@ -2,16 +2,14 @@ import { runAiConfigure } from "../core/ai-config.js";
 function registerAICommands(yargs) {
   return yargs.command(
     "ai configure [preset]",
-    "Configure AI runtime",
+    "Configure AI model for snapshot analysis",
     (cmd) => cmd.option("clear", { type: "boolean", default: false }),
     (argv) => {
-      const customPrefix = Array.isArray(argv["--"]) ? argv["--"] : [];
       runAiConfigure({
         clear: Boolean(argv.clear),
-        preset: argv.preset,
-        customPrefix
+        preset: argv.preset
       }, {
-        configureCommandName: "libretto-cli ai configure"
+        configureCommandName: "npx libretto ai configure"
       });
     }
   );

package/dist/cli/commands/init.js

@@ -1,67 +1,169 @@
-import { accessSync, constants, statSync } from "node:fs";
-import { join, delimiter, extname } from "node:path";
+import { createInterface } from "node:readline";
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { join } from "node:path";
 import {
-  AI_CONFIG_PRESETS,
-  AiPresetSchema,
-  formatCommandPrefix,
   readAiConfig
 } from "../core/ai-config.js";
-const AI_RUNTIME_PRESETS = AiPresetSchema.options;
-function getPresetCommand(preset) {
-  return AI_CONFIG_PRESETS[preset][0] ?? "";
+import { REPO_ROOT } from "../core/context.js";
+import {
+  loadSnapshotEnv,
+  resolveSnapshotApiModel
+} from "../core/snapshot-api-config.js";
+import { hasProviderCredentials } from "../../shared/llm/client.js";
+const PROVIDER_CHOICES = [
+  {
+    key: "1",
+    label: "OpenAI",
+    envVar: "OPENAI_API_KEY",
+    envHint: "Get your key at https://platform.openai.com/api-keys"
+  },
+  {
+    key: "2",
+    label: "Anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    envHint: "Get your key at https://console.anthropic.com/settings/keys"
+  },
+  {
+    key: "3",
+    label: "Google Gemini",
+    envVar: "GEMINI_API_KEY",
+    envHint: "Get your key at https://aistudio.google.com/apikey"
+  },
+  {
+    key: "4",
+    label: "Google Vertex AI",
+    envVar: "GOOGLE_CLOUD_PROJECT",
+    envHint: "Requires gcloud auth application-default login and a GCP project ID"
+  }
+];
+function promptUser(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
 }
-function isRunnableFile(filePath) {
+function safeReadAiConfig() {
   try {
-    const stats = statSync(filePath);
-    if (!stats.isFile()) return false;
-    if (process.platform === "win32") {
-      const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-      const extensions = pathExt.split(";").map((ext) => ext.trim().toUpperCase()).filter(Boolean);
-      const fileExt = extname(filePath).toUpperCase();
-      return extensions.includes(fileExt);
-    }
-    accessSync(filePath, constants.X_OK);
-    return true;
+    return readAiConfig();
   } catch {
-    return false;
+    return null;
   }
 }
-function isCommandDefined(command) {
-  if (!command) return false;
-  if (command.includes("/") || command.includes("\\")) {
-    return isRunnableFile(command);
-  }
-  const pathEnv = process.env.PATH ?? "";
-  if (!pathEnv) return false;
-  const pathEntries = pathEnv.split(delimiter).filter(Boolean);
-  if (process.platform === "win32") {
-    const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-    const extensions = pathExt.split(";").map((ext) => ext.trim()).filter(Boolean);
-    const hasExtension = /\.[^./\\]+$/.test(command);
-    const candidates = hasExtension ? [command] : extensions.map(
-      (ext) => ext.startsWith(".") ? `${command}${ext}` : `${command}.${ext}`
-    );
-    return pathEntries.some(
-      (dir) => candidates.some((candidate) => isRunnableFile(join(dir, candidate)))
+function printSnapshotApiStatus() {
+  const config = safeReadAiConfig();
+  const selection = resolveSnapshotApiModel(config);
+  const envPath = join(REPO_ROOT, ".env");
+  console.log("\nSnapshot analysis:");
+  console.log(
+    "  Libretto uses direct API calls for snapshot analysis when supported credentials are available."
+  );
+  console.log(`  Credentials are loaded from process env and ${envPath}.`);
+  if (selection && hasProviderCredentials(selection.provider)) {
+    console.log(
+      `  \u2713 Ready: ${selection.model} (${selection.source})`
     );
+    console.log("    Snapshot objectives will use the API analyzer by default.");
+    console.log("    No further action required.");
+    return;
   }
-  return pathEntries.some((dir) => isRunnableFile(join(dir, command)));
-}
-function detectAvailableAiRuntimeCommands() {
-  return AI_RUNTIME_PRESETS.filter(
-    (preset) => isCommandDefined(getPresetCommand(preset))
+  console.log("  \u2717 No snapshot API credentials detected.");
+  console.log("    Add one provider to .env:");
+  console.log("      OPENAI_API_KEY=...");
+  console.log("      ANTHROPIC_API_KEY=...");
+  console.log("      GEMINI_API_KEY=...  # or GOOGLE_GENERATIVE_AI_API_KEY");
+  console.log(
+    "      GOOGLE_CLOUD_PROJECT=...  # plus application default credentials for Vertex"
   );
+  console.log(
+    "    Or run `npx libretto ai configure <provider>` to set a specific model."
+  );
+  console.log("    Run `npx libretto init` interactively to set up credentials.");
 }
-function printAiConfigureCommands(prefix = "    ") {
-  for (const preset of AI_RUNTIME_PRESETS) {
-    console.log(`${prefix}npx libretto ai configure ${preset}`);
-  }
-}
-function printDifferentAnalyzerHint(prefix = "    ") {
+async function runInteractiveApiSetup() {
+  const config = safeReadAiConfig();
+  const selection = resolveSnapshotApiModel(config);
+  const envPath = join(REPO_ROOT, ".env");
+  console.log("\nSnapshot analysis setup:");
   console.log(
-    `${prefix}Use npx libretto ai configure <gemini|claude|codex> to configure a different AI analyzer.`
+    "  Libretto uses direct API calls for snapshot analysis."
   );
+  console.log(`  Credentials are loaded from process env and ${envPath}.`);
+  if (selection && hasProviderCredentials(selection.provider)) {
+    console.log(
+      `  \u2713 Ready: ${selection.model} (${selection.source})`
+    );
+    console.log("    Snapshot objectives will use the API analyzer by default.");
+    return;
+  }
+  console.log("  \u2717 No snapshot API credentials detected.\n");
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log("  Which API provider would you like to use for snapshot analysis?\n");
+    for (const choice of PROVIDER_CHOICES) {
+      console.log(`    ${choice.key}) ${choice.label}`);
+    }
+    console.log("    s) Skip for now\n");
+    const answer = await promptUser(rl, "  Choice: ");
+    if (answer.toLowerCase() === "s" || !answer) {
+      console.log("\n  Skipped. You can set up API credentials later by rerunning `npx libretto init`.");
+      console.log("  Or add credentials directly to your .env file:");
+      console.log("    OPENAI_API_KEY=...");
+      console.log("    ANTHROPIC_API_KEY=...");
+      console.log("    GEMINI_API_KEY=...");
+      console.log(
+        "    Or run `npx libretto ai configure <provider>` to set a specific model."
+      );
+      return;
+    }
+    const selected = PROVIDER_CHOICES.find((c) => c.key === answer);
+    if (!selected) {
+      console.log(`
+  Unknown choice "${answer}". Skipping API setup.`);
+      return;
+    }
+    console.log(`
+  ${selected.label} selected.`);
+    console.log(`  ${selected.envHint}
+`);
+    const apiKeyValue = await promptUser(rl, `  Enter your ${selected.envVar}: `);
+    if (!apiKeyValue) {
+      console.log("\n  No value entered. Skipping API key setup.");
+      return;
+    }
+    let envContent = "";
+    if (existsSync(envPath)) {
+      envContent = readFileSync(envPath, "utf-8");
+    }
+    const envLine = `${selected.envVar}=${apiKeyValue}`;
+    if (envContent.includes(`${selected.envVar}=`)) {
+      const updated = envContent.replace(
+        new RegExp(`^${selected.envVar}=.*$`, "m"),
+        () => envLine
+      );
+      writeFileSync(envPath, updated);
+      console.log(`
+  \u2713 Updated ${selected.envVar} in ${envPath}`);
+    } else {
+      const separator = envContent && !envContent.endsWith("\n") ? "\n" : "";
+      appendFileSync(envPath, `${separator}${envLine}
+`);
+      console.log(`
+  \u2713 Added ${selected.envVar} to ${envPath}`);
+    }
+    loadSnapshotEnv();
+    process.env[selected.envVar] = apiKeyValue;
+    const newSelection = resolveSnapshotApiModel(safeReadAiConfig());
+    if (newSelection && hasProviderCredentials(newSelection.provider)) {
+      console.log(`  \u2713 Snapshot API ready: ${newSelection.model}`);
+    }
+  } finally {
+    rl.close();
+  }
 }
 function installBrowsers() {
   console.log("\nInstalling Playwright Chromium...");
@@ -77,69 +179,6 @@ function installBrowsers() {
     );
   }
 }
-function checkAiRuntimeConfiguration() {
-  let config = null;
-  let configReadError = null;
-  try {
-    config = readAiConfig();
-  } catch (error) {
-    configReadError = error instanceof Error ? error.message : String(error);
-  }
-  const availableCommands = detectAvailableAiRuntimeCommands();
-  console.log("\nAI runtime configuration:");
-  console.log(
-    "  Libretto can use your coding agent as a subagent to analyze snapshots and other page signals."
-  );
-  console.log(
-    "  This is optional, but it significantly improves page understanding and debugging performance."
-  );
-  if (configReadError) {
-    console.log(`  \u2717 Could not read AI config: ${configReadError}`);
-    console.log("    Reconfigure with:");
-    printAiConfigureCommands("      ");
-    printDifferentAnalyzerHint("    ");
-    return;
-  }
-  if (config) {
-    const configuredCommand = config.commandPrefix[0];
-    if (!isCommandDefined(configuredCommand)) {
-      console.log(
-        `  \u2717 Configured command not found: ${configuredCommand ?? "(empty)"}`
-      );
-      if (availableCommands.length > 0) {
-        console.log(
-          `    Detected available commands: ${availableCommands.join(", ")}`
-        );
-      } else {
-        console.log(
-          "    No codex, claude, or gemini analyzer command was detected on PATH."
-        );
-      }
-      console.log("    Reconfigure with:");
-      printAiConfigureCommands("      ");
-      printDifferentAnalyzerHint("    ");
-      return;
-    }
-    console.log(
-      `  \u2713 Configured (${config.preset}): ${formatCommandPrefix(config.commandPrefix)}`
-    );
-    console.log("    Analysis commands are ready to use.");
-    printDifferentAnalyzerHint("    ");
-    return;
-  }
-  console.log("  \u2717 No AI config set.");
-  if (availableCommands.length > 0) {
-    console.log(
-      `    Detected available commands: ${availableCommands.join(", ")}`
-    );
-  } else {
-    console.log("    No codex, claude, or gemini analyzer command was detected on PATH.");
-  }
-  console.log("    Configure one with:");
-  printAiConfigureCommands("      ");
-  printDifferentAnalyzerHint("    ");
-  console.log("    Optionally provide a custom command prefix with '-- ...'.");
-}
 function registerInitCommand(yargs) {
   return yargs.command(
     "init",
@@ -149,14 +188,18 @@ function registerInitCommand(yargs) {
       default: false,
       describe: "Skip Playwright Chromium installation"
     }),
-    (argv) => {
+    async (argv) => {
       console.log("Initializing libretto...\n");
       if (!argv["skip-browsers"]) {
         installBrowsers();
       } else {
         console.log("\nSkipping browser installation (--skip-browsers)");
       }
-      checkAiRuntimeConfiguration();
+      if (process.stdin.isTTY) {
+        await runInteractiveApiSetup();
+      } else {
+        printSnapshotApiStatus();
+      }
       console.log("\n\u2713 libretto init complete");
     }
   );

package/dist/cli/commands/snapshot.js

@@ -1,11 +1,10 @@
 import { mkdirSync } from "node:fs";
 import { connect, disconnectBrowser } from "../core/browser.js";
 import { getSessionSnapshotRunDir } from "../core/context.js";
+import { condenseDom } from "../../shared/condense-dom/condense-dom.js";
 import { readSessionState } from "../core/session.js";
-import {
-  canAnalyzeSnapshots,
-  runInterpret
-} from "../core/snapshot-analyzer.js";
+import { runApiInterpret } from "../core/api-snapshot-analyzer.js";
+import { readAiConfig } from "../core/ai-config.js";
 const DEFAULT_SNAPSHOT_CONTEXT = "No additional user context provided.";
 const FALLBACK_SNAPSHOT_VIEWPORT = { width: 1280, height: 800 };
 function generateSnapshotRunId() {
@@ -97,6 +96,7 @@ async function captureScreenshot(session, logger, pageId) {
     }
     const pngPath = `${snapshotRunDir}/page.png`;
     const htmlPath = `${snapshotRunDir}/page.html`;
+    const condensedHtmlPath = `${snapshotRunDir}/page.condensed.html`;
     const restoreViewport = resolveSnapshotViewport(session, logger);
     const viewportMetrics = await readSnapshotViewportMetrics(page);
     logger.info("screenshot-viewport-metrics", {
@@ -132,15 +132,23 @@ async function captureScreenshot(session, logger, pageId) {
     const htmlContent = await page.content();
     const fs = await import("node:fs/promises");
     await fs.writeFile(htmlPath, htmlContent);
+    const condenseResult = condenseDom(htmlContent);
+    await fs.writeFile(condensedHtmlPath, condenseResult.html);
     logger.info("screenshot-success", {
       session,
       pageUrl,
       title,
       pngPath,
       htmlPath,
-      snapshotRunId
+      condensedHtmlPath,
+      snapshotRunId,
+      domCondenseStats: {
+        originalLength: condenseResult.originalLength,
+        condensedLength: condenseResult.condensedLength,
+        reductions: condenseResult.reductions
+      }
     });
-    return { pngPath, htmlPath, baseName: snapshotRunId };
+    return { pngPath, htmlPath, condensedHtmlPath, baseName: snapshotRunId };
   } catch (err) {
     let pageAlive = false;
     let browserConnected = false;
@@ -168,33 +176,35 @@ async function captureScreenshot(session, logger, pageId) {
   }
 }
 async function runSnapshot(session, logger, pageId, objective, context) {
-  const { pngPath, htmlPath } = await captureScreenshot(session, logger, pageId);
-  console.log("Screenshot saved:");
-  console.log(`  PNG:  ${pngPath}`);
-  console.log(`  HTML: ${htmlPath}`);
   const normalizedObjective = objective?.trim();
   const normalizedContext = context?.trim();
-  if (!normalizedObjective && !normalizedContext) {
-    console.log("Use --objective flag to analyze snapshots.");
-    return;
-  }
-  if (!normalizedObjective) {
+  if (!normalizedObjective && normalizedContext) {
     throw new Error(
       "Couldn't run analysis: --objective is required when providing --context."
     );
   }
-  if (!canAnalyzeSnapshots()) {
-    throw new Error(
-      "Couldn't run analysis: no AI config set. Run 'libretto-cli ai configure codex' (or claude/gemini) to enable analysis."
-    );
+  const { pngPath, htmlPath, condensedHtmlPath } = await captureScreenshot(
+    session,
+    logger,
+    pageId
+  );
+  console.log("Screenshot saved:");
+  console.log(`  PNG:             ${pngPath}`);
+  console.log(`  HTML:            ${htmlPath}`);
+  console.log(`  Condensed HTML:  ${condensedHtmlPath}`);
+  if (!normalizedObjective) {
+    console.log("Use --objective flag to analyze snapshots.");
+    return;
   }
-  await runInterpret({
+  const interpretArgs = {
     objective: normalizedObjective,
     session,
     context: normalizedContext ?? DEFAULT_SNAPSHOT_CONTEXT,
     pngPath,
-    htmlPath
-  }, logger);
+    htmlPath,
+    condensedHtmlPath
+  };
+  await runApiInterpret(interpretArgs, logger, readAiConfig());
 }
 function registerSnapshotCommands(yargs, logger) {
   return yargs.command(

package/dist/cli/core/ai-config.js

@@ -1,13 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
+import { dirname } from "node:path";
 import { z } from "zod";
 import { LIBRETTO_CONFIG_PATH } from "./context.js";
 const CURRENT_CONFIG_VERSION = 1;
-const AiPresetSchema = z.enum(["codex", "claude", "gemini"]);
 const AiConfigSchema = z.object({
-  preset: AiPresetSchema,
-  commandPrefix: z.array(z.string()).min(1),
+  model: z.string().min(1),
   updatedAt: z.string()
 }).strict();
 const ViewportConfigSchema = z.object({
@@ -19,11 +16,14 @@ const LibrettoConfigSchema = z.object({
   ai: AiConfigSchema.optional(),
   viewport: ViewportConfigSchema.optional()
 }).passthrough();
-const AI_CONFIG_PRESETS = {
-  codex: ["codex", "exec", "--skip-git-repo-check", "--sandbox", "read-only"],
-  claude: [join(homedir(), ".claude", "local", "claude"), "-p"],
-  gemini: ["gemini", "--output-format", "json"]
+const DEFAULT_MODELS = {
+  openai: "openai/gpt-5.4",
+  anthropic: "anthropic/claude-sonnet-4-6",
+  gemini: "google/gemini-2.5-flash",
+  google: "google/gemini-2.5-flash",
+  vertex: "vertex/gemini-2.5-pro"
 };
+const CONFIGURE_PROVIDERS = Object.keys(DEFAULT_MODELS);
 function invalidConfigError(configPath) {
   return new Error(
     `AI config is invalid at ${configPath}. Fix the file to match the expected schema or delete it.`
@@ -51,18 +51,10 @@ function writeLibrettoConfig(config, configPath = LIBRETTO_CONFIG_PATH) {
 function readAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   return readLibrettoConfig(configPath).ai ?? null;
 }
-function quoteShellArg(value) {
-  if (/^[a-zA-Z0-9_./:@=-]+$/.test(value)) return value;
-  return JSON.stringify(value);
-}
-function formatCommandPrefix(prefix) {
-  return prefix.map((arg) => quoteShellArg(arg)).join(" ");
-}
-function writeAiConfig(preset, commandPrefix, configPath = LIBRETTO_CONFIG_PATH) {
+function writeAiConfig(model, configPath = LIBRETTO_CONFIG_PATH) {
   const librettoConfig = readLibrettoConfig(configPath);
   const ai = AiConfigSchema.parse({
-    preset,
-    commandPrefix,
+    model,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   writeLibrettoConfig(
@@ -88,27 +80,24 @@ function clearAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   return true;
 }
 function printAiConfig(config, configPath) {
-  console.log(`AI preset: ${config.preset}`);
-  console.log(`Command prefix: ${formatCommandPrefix(config.commandPrefix)}`);
+  console.log(`Model: ${config.model}`);
   console.log(`Config file: ${configPath}`);
   console.log(`Updated at: ${config.updatedAt}`);
 }
-function printConfigureUsage(commandName) {
-  console.log(
-    `Usage: ${commandName} <codex|claude|gemini> [-- <command prefix...>]
-       ${commandName}
-       ${commandName} --clear`
-  );
+function resolveModelFromInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (trimmed.includes("/")) return trimmed;
+  return DEFAULT_MODELS[trimmed.toLowerCase()] ?? null;
 }
 function runAiConfigure(input, options = {}) {
-  const configureCommandName = options.configureCommandName ?? "libretto-cli ai configure";
+  const configureCommandName = options.configureCommandName ?? "npx libretto ai configure";
   const configPath = options.configPath ?? LIBRETTO_CONFIG_PATH;
   const presetArg = input.preset?.trim();
-  const customPrefix = (input.customPrefix ?? []).filter(Boolean);
-  if (!presetArg && customPrefix.length === 0 && !input.clear) {
+  if (!presetArg && !input.clear) {
     const config2 = readAiConfig(configPath);
     if (!config2) {
-      console.log(`No AI config set. Run '${configureCommandName} codex' to set one.`);
+      console.log(`No AI config set. Run '${configureCommandName} openai' to set one.`);
       return;
     }
     printAiConfig(config2, configPath);
@@ -123,31 +112,27 @@ function runAiConfigure(input, options = {}) {
     }
     return;
   }
-  const parsedPreset = AiPresetSchema.safeParse(presetArg);
-  if (!parsedPreset.success) {
-    printConfigureUsage(configureCommandName);
+  const model = resolveModelFromInput(presetArg);
+  if (!model) {
+    console.log(
+      `Usage: ${configureCommandName} <${CONFIGURE_PROVIDERS.join("|")}|provider/model-id>
+       ${configureCommandName}
+       ${configureCommandName} --clear`
+    );
     throw new Error(
-      "Missing or invalid preset. Use one of: codex, claude, gemini."
+      `Invalid provider or model. Use one of: ${CONFIGURE_PROVIDERS.join(", ")}, or a full model string like "openai/gpt-4o".`
     );
   }
-  if (input.customPrefix && input.customPrefix.length > 0 && customPrefix.length === 0) {
-    throw new Error("Custom command prefix cannot be empty.");
-  }
-  const preset = parsedPreset.data;
-  const commandPrefix = customPrefix.length > 0 ? customPrefix : AI_CONFIG_PRESETS[preset];
-  const config = writeAiConfig(preset, commandPrefix, configPath);
+  const config = writeAiConfig(model, configPath);
   console.log("AI config saved.");
   printAiConfig(config, configPath);
 }
 export {
-  AI_CONFIG_PRESETS,
   AiConfigSchema,
-  AiPresetSchema,
   CURRENT_CONFIG_VERSION,
   LibrettoConfigSchema,
   ViewportConfigSchema,
   clearAiConfig,
-  formatCommandPrefix,
   readAiConfig,
   readLibrettoConfig,
   runAiConfigure,

package/dist/cli/core/api-snapshot-analyzer.js

@@ -0,0 +1,74 @@
+import { readFileSync } from "node:fs";
+import { createLLMClient } from "../../shared/llm/client.js";
+import {
+  formatInterpretationOutput,
+  InterpretResultSchema,
+  buildInlinePromptSelection,
+  getMimeType,
+  readFileAsBase64
+} from "./snapshot-analyzer.js";
+import { readAiConfig } from "./ai-config.js";
+import {
+  resolveSnapshotApiModelOrThrow
+} from "./snapshot-api-config.js";
+async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
+  const selection = resolveSnapshotApiModelOrThrow(configuredAi);
+  logger.info("api-interpret-start", {
+    objective: args.objective,
+    pngPath: args.pngPath,
+    htmlPath: args.htmlPath,
+    condensedHtmlPath: args.condensedHtmlPath,
+    model: selection.model,
+    modelSource: selection.source
+  });
+  const fullHtmlContent = readFileSync(args.htmlPath, "utf-8");
+  const condensedHtmlContent = readFileSync(args.condensedHtmlPath, "utf-8");
+  const promptSelection = buildInlinePromptSelection(
+    args,
+    fullHtmlContent,
+    condensedHtmlContent,
+    selection.model
+  );
+  logger.info("api-interpret-dom-selection", {
+    configuredModel: promptSelection.stats.configuredModel,
+    fullDomEstimatedTokens: promptSelection.stats.fullDomEstimatedTokens,
+    condensedDomEstimatedTokens: promptSelection.stats.condensedDomEstimatedTokens,
+    contextWindowTokens: promptSelection.budget.contextWindowTokens,
+    promptBudgetTokens: promptSelection.budget.promptBudgetTokens,
+    selectedDom: promptSelection.domSource,
+    selectedHtmlEstimatedTokens: promptSelection.htmlEstimatedTokens,
+    selectedPromptEstimatedTokens: promptSelection.promptEstimatedTokens,
+    selectionReason: promptSelection.selectionReason,
+    truncated: promptSelection.truncated
+  });
+  const imageBase64 = readFileAsBase64(args.pngPath);
+  const imageMimeType = getMimeType(args.pngPath);
+  const imageBytes = Buffer.from(imageBase64, "base64");
+  const client = createLLMClient(selection.model);
+  const result = await client.generateObjectFromMessages({
+    schema: InterpretResultSchema,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: promptSelection.prompt },
+          {
+            type: "image",
+            image: imageBytes,
+            mediaType: imageMimeType
+          }
+        ]
+      }
+    ],
+    temperature: 0.1
+  });
+  const parsed = InterpretResultSchema.parse(result);
+  logger.info("api-interpret-success", {
+    selectorCount: parsed.selectors.length,
+    answer: parsed.answer.slice(0, 200)
+  });
+  console.log(formatInterpretationOutput(parsed, "Interpretation (via API):"));
+}
+export {
+  runApiInterpret
+};

package/dist/cli/core/context.js

@@ -86,7 +86,7 @@ function getLLMClientFactory() {
 }
 function maybeConfigureLLMClientFactoryFromEnv() {
   if (llmClientFactory) return;
-  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
   if (!hasAnyCreds) return;
   setLLMClientFactory(async (_logger, model) => {
     const { createLLMClient } = await import("../../shared/llm/index.js");