mu-agent 0.1.0 → 0.1.3

package/judge/dist/auth.js

@@ -0,0 +1,1248 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// mu-auth-unused:cloud-code
+var cloud_code_exports = {};
+var init_cloud_code = __esm({
+  "mu-auth-unused:cloud-code"() {
+    "use strict";
+  }
+});
+
+// packages/kyrn-judge/src/auth/main.ts
+import { join as join3 } from "node:path";
+import { createInterface } from "node:readline";
+import { defaultModelPerProvider, ModelRuntime } from "../../dist/bundle/index.js";
+
+// packages/kyrn-judge/src/config.ts
+import { readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// packages/kyrn-judge/src/naming.ts
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function muEnv(name, env = process.env) {
+  return env[`MU_${name}`] || env[`KYRN_${name}`] || void 0;
+}
+var CONFIG_FILE = "mu.json";
+var LEGACY_CONFIG_FILE = "kyrn.json";
+function muHome(home = homedir()) {
+  const current = join(home, ".mu");
+  const legacy = join(home, ".kyrn");
+  return existsSync(current) || !existsSync(legacy) ? current : legacy;
+}
+
+// packages/kyrn-judge/src/config.ts
+var DEFAULT_CONFIG = {
+  tiers: ["jev"],
+  judges: {},
+  modes: { default: "shadow" },
+  routes: {},
+  features: {},
+  recordState: false
+};
+var MODES = ["off", "shadow", "active"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readModes(value) {
+  const modes = {};
+  if (!isRecord(value)) return modes;
+  for (const [specId, mode] of Object.entries(value)) {
+    if (typeof mode === "string" && MODES.includes(mode)) modes[specId] = mode;
+  }
+  return modes;
+}
+function readTiers(value) {
+  const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  return raw.filter((tier) => typeof tier === "string").map((tier) => tier.trim()).filter(Boolean);
+}
+function readRoutes(value) {
+  const routes = {};
+  if (!isRecord(value)) return routes;
+  for (const [specId, tiers] of Object.entries(value)) {
+    const parsed = readTiers(tiers);
+    if (parsed.length > 0) routes[specId] = parsed;
+  }
+  return routes;
+}
+function readJudges(value) {
+  const judges = {};
+  if (!isRecord(value)) return judges;
+  for (const [name, config] of Object.entries(value)) {
+    if (!isRecord(config) || typeof config.type !== "string") continue;
+    if (!["jev", "typesafe", "gateway", "local", "http", "llm", "mock"].includes(config.type)) continue;
+    judges[name] = config;
+  }
+  return judges;
+}
+function parseConfig(value) {
+  if (!isRecord(value)) return DEFAULT_CONFIG;
+  const tiers = Array.isArray(value.tiers) ? value.tiers.filter((tier) => typeof tier === "string") : [];
+  return {
+    tiers: tiers.length > 0 ? tiers : DEFAULT_CONFIG.tiers,
+    judges: readJudges(value.judges),
+    modes: { ...DEFAULT_CONFIG.modes, ...readModes(value.modes) },
+    routes: readRoutes(value.routes),
+    features: isRecord(value.features) ? value.features : {},
+    mcp: isRecord(value.mcp) ? value.mcp : void 0,
+    writer: typeof value.writer === "string" ? value.writer : void 0,
+    recordState: value.recordState === true
+  };
+}
+function loadConfig(source = {}) {
+  const env = source.env ?? process.env;
+  let config = DEFAULT_CONFIG;
+  let problem;
+  for (const file of source.dir ? [CONFIG_FILE, LEGACY_CONFIG_FILE] : []) {
+    try {
+      config = parseConfig(JSON.parse(readFileSync(join2(source.dir, file), "utf8")));
+      break;
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      problem = `${file} could not be read: ${error instanceof Error ? error.message : String(error)}`;
+      break;
+    }
+  }
+  const judge = muEnv("JUDGE", env)?.trim();
+  if (judge === "off") return { config, disabled: true, problem };
+  if (judge) {
+    const tiers = judge.split(",").map((tier) => tier.trim() === "gateway" ? "jev" : tier.trim());
+    config = { ...config, tiers: tiers.filter(Boolean) };
+  }
+  const mode = muEnv("JUDGE_MODE", env);
+  if (mode && MODES.includes(mode)) config = { ...config, modes: { ...config.modes, default: mode } };
+  const writer = muEnv("WRITER", env);
+  if (writer) config = { ...config, writer };
+  return { config, disabled: false, problem };
+}
+function featureOptions(config, name, defaults) {
+  const value = config.features[name];
+  if (value === false) return { ...defaults, enabled: false };
+  if (value === true) return { ...defaults, enabled: true };
+  if (isRecord(value)) return { ...defaults, ...value };
+  return defaults;
+}
+
+// node_modules/typebox/build/system/hashing/hash.mjs
+var ByteMarker;
+(function(ByteMarker2) {
+  ByteMarker2[ByteMarker2["Array"] = 0] = "Array";
+  ByteMarker2[ByteMarker2["BigInt"] = 1] = "BigInt";
+  ByteMarker2[ByteMarker2["Boolean"] = 2] = "Boolean";
+  ByteMarker2[ByteMarker2["Date"] = 3] = "Date";
+  ByteMarker2[ByteMarker2["Constructor"] = 4] = "Constructor";
+  ByteMarker2[ByteMarker2["Function"] = 5] = "Function";
+  ByteMarker2[ByteMarker2["Null"] = 6] = "Null";
+  ByteMarker2[ByteMarker2["Number"] = 7] = "Number";
+  ByteMarker2[ByteMarker2["Object"] = 8] = "Object";
+  ByteMarker2[ByteMarker2["RegExp"] = 9] = "RegExp";
+  ByteMarker2[ByteMarker2["String"] = 10] = "String";
+  ByteMarker2[ByteMarker2["Symbol"] = 11] = "Symbol";
+  ByteMarker2[ByteMarker2["TypeArray"] = 12] = "TypeArray";
+  ByteMarker2[ByteMarker2["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
+var Accumulator = BigInt("14695981039346656037");
+var [Prime, Size] = [BigInt("1099511628211"), BigInt(
+  "18446744073709551616"
+  /* 2 ^ 64 */
+)];
+var Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+var F64 = new Float64Array(1);
+var F64In = new DataView(F64.buffer);
+var F64Out = new Uint8Array(F64.buffer);
+var encoder = new TextEncoder();
+
+// node_modules/typebox/build/type/types/integer.mjs
+var IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+
+// node_modules/typebox/build/type/types/number.mjs
+var NumberPattern = "-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?";
+
+// node_modules/typebox/build/type/types/string.mjs
+var StringPattern = ".*";
+
+// node_modules/typebox/build/type/types/record.mjs
+var IntegerKey = `^${IntegerPattern}$`;
+var NumberKey = `^${NumberPattern}$`;
+var StringKey = `^${StringPattern}$`;
+
+// node_modules/typebox/build/type/script/token/internal/char.mjs
+function Range(start, end) {
+  return Array.from({ length: end - start + 1 }, (_, i) => String.fromCharCode(start + i));
+}
+var Alpha = [
+  ...Range(97, 122),
+  // Lowercase
+  ...Range(65, 90)
+  // Uppercase
+];
+var Zero = "0";
+var NonZero = Range(49, 57);
+var Digit = [Zero, ...NonZero];
+var UnderScore = "_";
+var DollarSign = "$";
+
+// node_modules/typebox/build/type/script/token/unsigned_integer.mjs
+var AllowedDigits = [...Digit, UnderScore];
+
+// node_modules/typebox/build/type/script/token/ident.mjs
+var Initial = [...Alpha, UnderScore, DollarSign];
+var Remaining = [...Initial, ...Digit];
+
+// node_modules/typebox/build/type/script/token/unsigned_number.mjs
+var AllowedDigits2 = [...Digit, UnderScore];
+
+// node_modules/typebox/build/type/engine/helpers/keys.mjs
+var integerKeyPattern = new RegExp("^(?:0|[1-9][0-9]*)$");
+
+// node_modules/typebox/build/type/engine/indexed/from_object.mjs
+var NumericKeyPattern = new RegExp(IntegerKey);
+
+// packages/ai/src/utils/event-stream.ts
+var FifoQueue = class {
+  constructor() {
+    this.incoming = [];
+    this.outgoing = [];
+  }
+  get length() {
+    return this.incoming.length + this.outgoing.length;
+  }
+  enqueue(value) {
+    this.incoming.push(value);
+  }
+  dequeue() {
+    if (this.outgoing.length === 0) {
+      while (this.incoming.length > 0) {
+        this.outgoing.push(this.incoming.pop());
+      }
+    }
+    return this.outgoing.pop();
+  }
+};
+var EventStream = class {
+  constructor(isComplete, extractResult) {
+    this.queue = new FifoQueue();
+    this.waiting = new FifoQueue();
+    this.done = false;
+    this.isComplete = isComplete;
+    this.extractResult = extractResult;
+    this.finalResultPromise = new Promise((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+  push(event) {
+    if (this.done) return;
+    if (this.isComplete(event)) {
+      this.done = true;
+      this.resolveFinalResult(this.extractResult(event));
+    }
+    const waiter = this.waiting.dequeue();
+    if (waiter) {
+      waiter({ value: event, done: false });
+    } else {
+      this.queue.enqueue(event);
+    }
+  }
+  end(result) {
+    this.done = true;
+    if (result !== void 0) {
+      this.resolveFinalResult(result);
+    }
+    while (this.waiting.length > 0) {
+      const waiter = this.waiting.dequeue();
+      waiter({ value: void 0, done: true });
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.dequeue();
+      } else if (this.done) {
+        return;
+      } else {
+        const result = await new Promise((resolve) => this.waiting.enqueue(resolve));
+        if (result.done) return;
+        yield result.value;
+      }
+    }
+  }
+  result() {
+    return this.finalResultPromise;
+  }
+};
+var AssistantMessageEventStream = class extends EventStream {
+  constructor() {
+    super(
+      (event) => event.type === "done" || event.type === "error",
+      (event) => {
+        if (event.type === "done") {
+          return event.message;
+        } else if (event.type === "error") {
+          return event.error;
+        }
+        throw new Error("Unexpected event type for final result");
+      }
+    );
+  }
+};
+
+// packages/ai/src/api/lazy.ts
+function createSetupErrorMessage(model, error) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason: "error",
+    errorMessage: error instanceof Error ? error.message : String(error),
+    timestamp: Date.now()
+  };
+}
+function hasResult(source) {
+  return typeof source.result === "function";
+}
+async function forwardStream(target, source) {
+  for await (const event of source) {
+    target.push(event);
+  }
+  target.end(hasResult(source) ? await source.result() : void 0);
+}
+function lazyStream(model, setup) {
+  const outer = new AssistantMessageEventStream();
+  setup().then((inner) => forwardStream(outer, inner)).catch((error) => {
+    const message = createSetupErrorMessage(model, error);
+    outer.push({ type: "error", reason: "error", error: message });
+    outer.end(message);
+  });
+  return outer;
+}
+function lazyApi(load, capabilities) {
+  const api = {
+    stream: (model, context, options) => lazyStream(model, async () => (await load()).stream(model, context, options)),
+    streamSimple: (model, context, options) => lazyStream(model, async () => (await load()).streamSimple(model, context, options))
+  };
+  if (capabilities?.fetchDeferred) {
+    api.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+      const implementation = await load();
+      if (!implementation.fetchDeferred) throw new Error("API does not support deferred responses");
+      return implementation.fetchDeferred(model, handle, options);
+    });
+  }
+  if (capabilities?.cancelDeferred) {
+    api.cancelDeferred = async (model, handle, options) => {
+      const implementation = await load();
+      if (!implementation.cancelDeferred) throw new Error("API cannot cancel deferred responses");
+      await implementation.cancelDeferred(model, handle, options);
+    };
+  }
+  return api;
+}
+
+// packages/ai/src/auth/oauth/oauth-page.ts
+var MU_MARK_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none" aria-hidden="true"><defs><linearGradient id="mu-tile" x1="0" y1="0" x2="100" y2="100" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#F3C6FA"/><stop offset="0.5" stop-color="#B79CF7"/><stop offset="1" stop-color="#8680EB"/></linearGradient></defs><rect width="100" height="100" rx="27" fill="url(#mu-tile)"/><path d="M41 32 L35 74.4 M38.9 47 C37.77 55 41 59.4 47.6 59.4 C54.8 59.4 61.05 54.5 61.9 48.5 M64.25 32 L61.35 52.5 C60.6 58 62.3 61.2 66.4 60.4" stroke="#FFFFFF" stroke-width="9.8" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+var MU_FAVICON = `data:image/svg+xml,${encodeURIComponent(MU_MARK_SVG)}`;
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function renderPage(options) {
+  const title = escapeHtml(`${options.heading} \xB7 mu`);
+  const heading = escapeHtml(options.heading);
+  const message = escapeHtml(options.message);
+  const details = options.details ? escapeHtml(options.details) : void 0;
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="color-scheme" content="light dark" />
+  <title>${title}</title>
+  <link rel="icon" type="image/svg+xml" href="${MU_FAVICON}" />
+  <style>
+    :root {
+      color-scheme: light dark;
+      --text: #111111;
+      --text-dim: #6b6b70;
+      --page-bg: #ffffff;
+      --font-sans: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
+      --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --text: #f4f4f5;
+        --text-dim: #9a9aa1;
+        --page-bg: #000000;
+      }
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      background: var(--page-bg);
+      color: var(--text);
+      font-family: var(--font-sans);
+      text-align: center;
+    }
+    main {
+      width: 100%;
+      max-width: 520px;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+    }
+    .mark {
+      width: 72px;
+      height: 72px;
+      display: block;
+      margin-bottom: 28px;
+    }
+    .mark svg { display: block; width: 100%; height: 100%; }
+    h1 {
+      margin: 0 0 10px;
+      font-size: 26px;
+      line-height: 1.2;
+      font-weight: 600;
+      letter-spacing: -0.01em;
+      color: var(--text);
+    }
+    p {
+      margin: 0;
+      line-height: 1.7;
+      color: var(--text-dim);
+      font-size: 15px;
+    }
+    .details {
+      margin-top: 16px;
+      font-family: var(--font-mono);
+      font-size: 13px;
+      color: var(--text-dim);
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <div class="mark">${MU_MARK_SVG}</div>
+    <h1>${heading}</h1>
+    <p>${message}</p>
+    ${details ? `<div class="details">${details}</div>` : ""}
+  </main>
+</body>
+</html>`;
+}
+function oauthSuccessHtml(message) {
+  return renderPage({ heading: "Signed in", message });
+}
+function oauthErrorHtml(message, details) {
+  return renderPage({ heading: "Sign-in did not complete", message, details });
+}
+
+// packages/ai/src/utils/diagnostics.ts
+function formatThrownValue(value) {
+  if (value instanceof Error) return value.message || value.name;
+  if (typeof value === "string") return value;
+  return String(value);
+}
+
+// packages/ai/src/auth/resolve.ts
+var ModelsError = class extends Error {
+  constructor(code, message, options) {
+    super(withCauseDetail(message, options?.cause), options);
+    this.name = "ModelsError";
+    this.code = code;
+  }
+};
+function withCauseDetail(message, cause) {
+  if (cause === void 0 || cause === null) return message;
+  const detail = formatThrownValue(cause).trim();
+  if (!detail || message.includes(detail)) return message;
+  return `${message}: ${detail}`;
+}
+var DEFAULT_OAUTH_MINIMUM_VALIDITY_MS = 5 * 60 * 1e3;
+
+// packages/ai/src/models.ts
+function createProvider(input) {
+  const baselineModels = input.models;
+  let dynamicModels = [];
+  const fetchModels = input.fetchModels;
+  const currentModels = () => {
+    const merged = [...baselineModels];
+    for (const model of dynamicModels) {
+      const index = merged.findIndex((entry) => entry.id === model.id);
+      if (index >= 0) merged[index] = model;
+      else merged.push(model);
+    }
+    return merged;
+  };
+  const single = typeof input.api.stream === "function" ? input.api : void 0;
+  const byApi = single ? void 0 : input.api;
+  const apiFor = (model) => single ?? byApi?.[model.api];
+  const dispatch = (model, run) => {
+    const streams2 = apiFor(model);
+    if (!streams2) {
+      return lazyStream(model, async () => {
+        throw new ModelsError("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
+      });
+    }
+    return run(streams2);
+  };
+  const provider = {
+    id: input.id,
+    name: input.name ?? input.id,
+    baseUrl: input.baseUrl,
+    headers: input.headers,
+    auth: input.auth,
+    getModels: currentModels,
+    refreshModels: fetchModels ? async (context) => {
+      if (context.stored) {
+        const restored = context.stored.models.filter((model) => model.provider === input.id).map((model) => model);
+        if (!await context.publish({
+          update: () => {
+            dynamicModels = restored;
+          }
+        })) {
+          return;
+        }
+      }
+      if (!context.allowNetwork || context.signal.aborted) return;
+      const refreshed = await fetchModels(context);
+      if (context.signal.aborted) return;
+      await context.publish({
+        persist: { models: refreshed, checkedAt: Date.now() },
+        update: () => {
+          dynamicModels = refreshed;
+        }
+      });
+    } : void 0,
+    filterModels: input.filterModels,
+    stream: (model, context, options) => dispatch(model, (streams2) => streams2.stream(model, context, options)),
+    streamSimple: (model, context, options) => dispatch(model, (streams2) => streams2.streamSimple(model, context, options))
+  };
+  const streams = single ? [single] : Object.values(byApi ?? {}).filter((entry) => entry !== void 0);
+  if (streams.some((entry) => entry.fetchDeferred !== void 0)) {
+    provider.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+      const implementation = apiFor(model);
+      if (!implementation?.fetchDeferred) {
+        throw new ModelsError(
+          "provider",
+          `Provider ${input.id} does not support deferred responses for "${model.api}"`
+        );
+      }
+      return implementation.fetchDeferred(model, handle, options);
+    });
+  }
+  if (streams.some((entry) => entry.cancelDeferred !== void 0)) {
+    provider.cancelDeferred = async (model, handle, options) => {
+      const implementation = apiFor(model);
+      if (!implementation?.cancelDeferred) {
+        throw new ModelsError(
+          "provider",
+          `Provider ${input.id} cannot cancel deferred responses for "${model.api}"`
+        );
+      }
+      await implementation.cancelDeferred(model, handle, options);
+    };
+  }
+  return provider;
+}
+
+// packages/ai/src/providers/data/google.json
+var google_default = { "google-generative-ai": { "deep-research-max-preview-04-2026": { id: "deep-research-max-preview-04-2026", name: "Deep Research Max Preview (Apr-21-2026)", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, input: ["text", "image"], cost: { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 }, contextWindow: 131072, maxTokens: 65536 }, "deep-research-preview-04-2026": { id: "deep-research-preview-04-2026", name: "Deep Research Preview (Apr-21-2026)", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, input: ["text", "image"], cost: { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 }, contextWindow: 131072, maxTokens: 65536 }, "gemini-2.5-computer-use-preview-10-2025": { id: "gemini-2.5-computer-use-preview-10-2025", name: "Gemini 2.5 Computer Use Preview 10-2025", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, input: ["text", "image"], cost: { input: 1.25, output: 10, cacheRead: 0, cacheWrite: 0 }, contextWindow: 131072, maxTokens: 65536 }, "gemini-2.5-flash": { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, input: ["text", "image"], cost: { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-2.5-flash-lite": { id: "gemini-2.5-flash-lite", name: "Gemini 2.5 Flash-Lite", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, input: ["text", "image"], cost: { input: 0.1, output: 0.4, cacheRead: 0.01, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-2.5-pro": { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, input: ["text", "image"], cost: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3-flash-preview": { id: "gemini-3-flash-preview", name: "Gemini 3 Flash Preview", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.5, output: 3, cacheRead: 0.05, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.1-flash-lite": { id: "gemini-3.1-flash-lite", name: "Gemini 3.1 Flash Lite", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.25, output: 1.5, cacheRead: 0.025, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.1-flash-lite-image": { id: "gemini-3.1-flash-lite-image", name: "Nano Banana 2 Lite", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: null, medium: null, high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.25, output: 30, cacheRead: 0, cacheWrite: 0 }, contextWindow: 65536, maxTokens: 65536 }, "gemini-3.1-flash-lite-preview": { id: "gemini-3.1-flash-lite-preview", name: "Gemini 3.1 Flash Lite Preview", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.25, output: 1.5, cacheRead: 0.025, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.1-flash-live-preview": { id: "gemini-3.1-flash-live-preview", name: "Gemini 3.1 Flash Live Preview", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.75, output: 4.5, cacheRead: 0, cacheWrite: 0 }, contextWindow: 131072, maxTokens: 65536 }, "gemini-3.1-pro-preview": { id: "gemini-3.1-pro-preview", name: "Gemini 3.1 Pro Preview", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: null, low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.1-pro-preview-customtools": { id: "gemini-3.1-pro-preview-customtools", name: "Gemini 3.1 Pro Preview Custom Tools", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: null, low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.5-flash": { id: "gemini-3.5-flash", name: "Gemini 3.5 Flash", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.5-flash-lite": { id: "gemini-3.5-flash-lite", name: "Gemini 3.5 Flash Lite", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.6-flash": { id: "gemini-3.6-flash", name: "Gemini 3.6 Flash", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.75, output: 3.75, cacheRead: 0.075, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.7-flash": { id: "gemini-3.7-flash", name: "Gemini 3.7 Flash", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: null, low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.75, output: 3.75, cacheRead: 0.075, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-3.8-flash": { id: "gemini-3.8-flash", name: "Gemini 3.8 Flash", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: null, low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.75, output: 3.75, cacheRead: 0.075, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-flash-latest": { id: "gemini-flash-latest", name: "Gemini Flash Latest", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemini-flash-lite-latest": { id: "gemini-flash-lite-latest", name: "Gemini Flash-Lite Latest", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null, max: null }, input: ["text", "image"], cost: { input: 0.25, output: 1.5, cacheRead: 0.025, cacheWrite: 0 }, contextWindow: 1048576, maxTokens: 65536 }, "gemma-4-26b-a4b-it": { id: "gemma-4-26b-a4b-it", name: "Gemma 4 26B A4B IT", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "MINIMAL", low: null, medium: null, high: "HIGH" }, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 262144, maxTokens: 32768 }, "gemma-4-31b-it": { id: "gemma-4-31b-it", name: "Gemma 4 31B IT", api: "google-generative-ai", provider: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", reasoning: true, thinkingLevelMap: { off: null, minimal: "MINIMAL", low: null, medium: null, high: "HIGH" }, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 262144, maxTokens: 32768 } } };
+
+// packages/ai/src/model-catalog.ts
+function flattenModelCatalog(_provider, groups) {
+  return Object.assign({}, ...Object.values(groups));
+}
+
+// packages/ai/src/providers/google.models.ts
+var GOOGLE_MODELS = flattenModelCatalog("google", google_default);
+
+// packages/kyrn-judge/src/google-login/endpoints.ts
+var CLOUD_CODE_API = "google-cloud-code";
+var GEMINI_CLI_PROVIDER = "google-gemini-cli";
+var ANTIGRAVITY_PROVIDER = "google-antigravity";
+var CLOUD_CODE_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+var ANTIGRAVITY_ENDPOINTS = [
+  "https://daily-cloudcode-pa.sandbox.googleapis.com",
+  "https://autopush-cloudcode-pa.sandbox.googleapis.com",
+  CLOUD_CODE_ENDPOINT
+];
+var antigravityUserAgent = (env = (name) => process.env[name]) => `antigravity/${env("MU_ANTIGRAVITY_VERSION") || env("PI_AI_ANTIGRAVITY_VERSION") || "1.107.0"} darwin/arm64`;
+
+// packages/kyrn-judge/src/google-login/oauth.ts
+import { createServer } from "node:http";
+var decode = (value) => atob(value);
+var GOOGLE = {
+  authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  userInfoUrl: "https://www.googleapis.com/oauth2/v1/userinfo?alt=json",
+  callbackHost: process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1",
+  env: (name) => process.env[name]
+};
+var BASE_SCOPES = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile"
+];
+var GEMINI_CLI_LOGIN = {
+  ...GOOGLE,
+  kind: "gemini-cli",
+  title: "Google Gemini CLI",
+  clientId: decode("NjgxMjU1ODA5Mzk1LW9vOGZ0Mm9wcmRybnA5ZTNhcWY2YXYzaG1kaWIxMzVqLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29t"),
+  clientSecret: decode("R09DU1BYLTR1SGdNUG0tMW83U2stZ2VWNkN1NWNsWEZzeGw="),
+  callbackPort: 8085,
+  callbackPath: "/oauth2callback",
+  scopes: BASE_SCOPES,
+  codeAssistEndpoints: [CLOUD_CODE_ENDPOINT]
+};
+var ANTIGRAVITY_LOGIN = {
+  ...GOOGLE,
+  kind: "antigravity",
+  title: "Google Antigravity",
+  clientId: decode(
+    "MTA3MTAwNjA2MDU5MS10bWhzc2luMmgyMWxjcmUyMzV2dG9sb2poNGc0MDNlcC5hcHBzLmdvb2dsZXVzZXJjb250ZW50LmNvbQ=="
+  ),
+  clientSecret: decode("R09DU1BYLUs1OEZXUjQ4NkxkTEoxbUxCOHNYQzR6NnFEQWY="),
+  callbackPort: 51121,
+  callbackPath: "/oauth-callback",
+  scopes: [
+    ...BASE_SCOPES,
+    "https://www.googleapis.com/auth/cclog",
+    "https://www.googleapis.com/auth/experimentsandconfigs"
+  ],
+  codeAssistEndpoints: [CLOUD_CODE_ENDPOINT, ANTIGRAVITY_ENDPOINTS[0]]
+};
+var ANTIGRAVITY_DEFAULT_PROJECT = "rising-fact-p41fc";
+function riskNotice(config) {
+  return `Experimental: this signs in through ${config.title}'s own login, not one Google made for mu. Google may treat that as against its terms and limit or suspend the account. Use an account you can afford to lose access to, or a Gemini API key (provider "google") instead.`;
+}
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function pkce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  const verifier = base64url(bytes);
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return { verifier, challenge: base64url(new Uint8Array(digest)) };
+}
+function listen(config, state) {
+  return new Promise((resolve, reject) => {
+    let settle = () => {
+    };
+    const wait = new Promise((done) => {
+      let settled = false;
+      settle = (value) => {
+        if (settled) return;
+        settled = true;
+        done(value);
+      };
+    });
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", `http://localhost:${config.callbackPort}`);
+      const send = (status, html) => {
+        response.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
+        response.end(html);
+      };
+      if (url.pathname !== config.callbackPath) {
+        return send(404, oauthErrorHtml("This address is mu's sign-in callback; there is no page here."));
+      }
+      const given = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      if (error) {
+        const said = error.replace(/[^\w.-]/g, "").slice(0, 80) || "an error";
+        send(400, oauthErrorHtml("Google did not complete the sign-in.", `Google said: ${said}`));
+        if (given === state) settle({ declined: said });
+        return;
+      }
+      const code = url.searchParams.get("code");
+      if (!code || !given) return send(400, oauthErrorHtml("The code or the state is missing."));
+      if (given !== state) {
+        return send(400, oauthErrorHtml("This address belongs to another sign-in. Use the tab mu opened last."));
+      }
+      send(200, oauthSuccessHtml("You can close this window and go back to mu."));
+      settle({ code, state: given });
+    });
+    server.once(
+      "error",
+      (error) => reject(
+        error.code === "EADDRINUSE" ? new Error(
+          `Port ${config.callbackPort} is taken (is ${config.title} itself signing in?). Close it and try again.`
+        ) : error
+      )
+    );
+    server.listen(
+      config.callbackPort,
+      config.callbackHost,
+      () => resolve({ server, wait, cancel: () => settle(void 0) })
+    );
+  });
+}
+function parsePasted(input) {
+  const value = input.trim();
+  if (!value) return {};
+  try {
+    const url = new URL(value);
+    return { code: url.searchParams.get("code") ?? void 0, state: url.searchParams.get("state") ?? void 0 };
+  } catch {
+    return { code: value };
+  }
+}
+async function tokenRequest(config, body, signal) {
+  const response = await fetch(config.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ client_id: config.clientId, client_secret: config.clientSecret, ...body }),
+    signal
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`Google token request failed (${response.status}): ${text.slice(0, 300)}`);
+  const data = JSON.parse(text);
+  if (!data.access_token || typeof data.expires_in !== "number") {
+    throw new Error("Google's token response has no access token");
+  }
+  return data;
+}
+var expiry = (seconds) => Date.now() + seconds * 1e3 - 5 * 60 * 1e3;
+async function email(config, token, signal) {
+  try {
+    const response = await fetch(config.userInfoUrl, { headers: { Authorization: `Bearer ${token}` }, signal });
+    if (!response.ok) return void 0;
+    const data = await response.json();
+    return typeof data.email === "string" ? data.email : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var CLIENT_METADATA = { ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" };
+var projectOf = (value) => typeof value === "string" ? value || void 0 : value?.id || void 0;
+var NEEDS_PROJECT = "This account needs a Google Cloud project: set GOOGLE_CLOUD_PROJECT (see https://goo.gle/gemini-cli-auth-docs#workspace-gca).";
+async function geminiProject(config, token, interaction) {
+  const own = config.env("GOOGLE_CLOUD_PROJECT") || config.env("GOOGLE_CLOUD_PROJECT_ID");
+  const endpoint = config.codeAssistEndpoints[0];
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "User-Agent": "google-api-nodejs-client/9.15.1",
+    "X-Goog-Api-Client": "gl-node/22.17.0"
+  };
+  interaction.notify({ type: "progress", message: "Looking up the Cloud Code Assist project..." });
+  const loaded = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ cloudaicompanionProject: own, metadata: { ...CLIENT_METADATA, duetProject: own } }),
+    signal: interaction.signal
+  });
+  let data;
+  if (loaded.ok) data = await loaded.json();
+  else {
+    const text = await loaded.text();
+    if (!text.includes("SECURITY_POLICY_VIOLATED")) {
+      throw new Error(`loadCodeAssist failed (${loaded.status}): ${text.slice(0, 300)}`);
+    }
+    data = { currentTier: { id: "standard-tier" } };
+  }
+  if (data.currentTier) {
+    const found = projectOf(data.cloudaicompanionProject) ?? own;
+    if (!found) throw new Error(NEEDS_PROJECT);
+    return found;
+  }
+  const tier = data.allowedTiers?.find((candidate) => candidate.isDefault)?.id ?? "legacy-tier";
+  if (tier !== "free-tier" && !own) throw new Error(NEEDS_PROJECT);
+  interaction.notify({
+    type: "progress",
+    message: "Setting up a Cloud Code Assist project (this can take a minute)..."
+  });
+  const body = { tierId: tier, metadata: CLIENT_METADATA };
+  if (tier !== "free-tier" && own) {
+    body.cloudaicompanionProject = own;
+    body.metadata = { ...CLIENT_METADATA, duetProject: own };
+  }
+  const started = await fetch(`${endpoint}/v1internal:onboardUser`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: interaction.signal
+  });
+  if (!started.ok) throw new Error(`onboardUser failed (${started.status}): ${(await started.text()).slice(0, 300)}`);
+  let operation = await started.json();
+  for (let attempt = 0; !operation.done && operation.name && attempt < 60; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, attempt === 0 ? 1e3 : 5e3));
+    const polled = await fetch(`${endpoint}/v1internal/${operation.name}`, { headers, signal: interaction.signal });
+    if (!polled.ok) throw new Error(`Setting up the project failed (${polled.status})`);
+    operation = await polled.json();
+  }
+  const provisioned = operation.response?.cloudaicompanionProject?.id ?? own;
+  if (!provisioned) throw new Error(NEEDS_PROJECT);
+  return provisioned;
+}
+async function antigravityProject(config, token, interaction) {
+  interaction.notify({ type: "progress", message: "Looking up the Antigravity project..." });
+  for (const endpoint of config.codeAssistEndpoints) {
+    try {
+      const loaded = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "User-Agent": "google-api-nodejs-client/9.15.1",
+          "Client-Metadata": JSON.stringify(CLIENT_METADATA)
+        },
+        body: JSON.stringify({ metadata: CLIENT_METADATA }),
+        signal: interaction.signal
+      });
+      if (!loaded.ok) continue;
+      const found = projectOf((await loaded.json()).cloudaicompanionProject);
+      if (found) return found;
+    } catch (error) {
+      if (interaction.signal.aborted) throw error;
+    }
+  }
+  return ANTIGRAVITY_DEFAULT_PROJECT;
+}
+async function consent(config, interaction) {
+  const answer = await interaction.prompt({
+    type: "select",
+    message: riskNotice(config),
+    options: [
+      { id: "continue", label: "I understand the risk, sign in" },
+      { id: "cancel", label: "Cancel" }
+    ]
+  });
+  if (answer !== "continue") throw new Error("Login cancelled");
+}
+async function login(config, interaction) {
+  await consent(config, interaction);
+  const { verifier, challenge } = await pkce();
+  const redirectUri = `http://localhost:${config.callbackPort}${config.callbackPath}`;
+  const callback = await listen(config, verifier);
+  const pasting = new AbortController();
+  const onAbort = () => callback.cancel();
+  interaction.signal.addEventListener("abort", onAbort, { once: true });
+  let pasted;
+  let pasteError;
+  try {
+    const query = new URLSearchParams({
+      client_id: config.clientId,
+      response_type: "code",
+      redirect_uri: redirectUri,
+      scope: config.scopes.join(" "),
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      state: verifier,
+      access_type: "offline",
+      prompt: "consent"
+    });
+    interaction.notify({
+      type: "auth_url",
+      url: `${config.authUrl}?${query.toString()}`,
+      instructions: "Sign in with Google in your browser. If the browser is on another machine, paste the address it ends on here."
+    });
+    const typed = interaction.prompt({
+      type: "manual_code",
+      message: "Sign in in your browser, or paste the address the browser ended on:",
+      placeholder: redirectUri,
+      signal: pasting.signal
+    }).then((value) => {
+      pasted = value;
+      callback.cancel();
+    }).catch((error) => {
+      pasteError = error instanceof Error ? error : new Error(String(error));
+      callback.cancel();
+    });
+    let code;
+    const received = await callback.wait;
+    if (received && "declined" in received) throw new Error(`Google sign-in was declined: ${received.declined}`);
+    if (received) {
+      if (received.state !== verifier) throw new Error("OAuth state mismatch");
+      code = received.code;
+    } else {
+      if (!pasted && !pasteError && !interaction.signal.aborted) await typed;
+      if (interaction.signal.aborted) throw new Error("Login cancelled");
+      if (pasteError) throw pasteError;
+      const parsed = parsePasted(pasted ?? "");
+      if (parsed.state && parsed.state !== verifier) throw new Error("OAuth state mismatch");
+      code = parsed.code;
+    }
+    if (!code) throw new Error("No authorization code came back");
+    interaction.notify({ type: "progress", message: "Exchanging the code for tokens..." });
+    const tokens = await tokenRequest(
+      config,
+      { code, grant_type: "authorization_code", redirect_uri: redirectUri, code_verifier: verifier },
+      interaction.signal
+    );
+    if (!tokens.refresh_token) throw new Error("Google sent no refresh token; sign in again");
+    const who = await email(config, tokens.access_token, interaction.signal);
+    const projectId = config.kind === "gemini-cli" ? await geminiProject(config, tokens.access_token, interaction) : await antigravityProject(config, tokens.access_token, interaction);
+    return {
+      type: "oauth",
+      access: tokens.access_token,
+      refresh: tokens.refresh_token,
+      expires: expiry(tokens.expires_in),
+      projectId,
+      ...who ? { email: who } : {}
+    };
+  } finally {
+    interaction.signal.removeEventListener("abort", onAbort);
+    pasting.abort();
+    callback.server.close();
+    callback.server.closeAllConnections();
+  }
+}
+async function refresh(config, credential, signal) {
+  const projectId = credential.projectId;
+  if (!projectId) throw new Error(`${config.title} credential has no project; sign in again`);
+  const tokens = await tokenRequest(
+    config,
+    { refresh_token: credential.refresh, grant_type: "refresh_token" },
+    signal
+  );
+  return {
+    ...credential,
+    type: "oauth",
+    access: tokens.access_token,
+    refresh: tokens.refresh_token || credential.refresh,
+    expires: expiry(tokens.expires_in),
+    projectId
+  };
+}
+function cloudCodeKey(credential) {
+  return JSON.stringify({ token: credential.access, projectId: credential.projectId });
+}
+function googleOAuth(config) {
+  return {
+    name: `${config.title} (experimental)`,
+    isSubscription: true,
+    loginLabel: `Sign in with Google through ${config.title} (experimental)`,
+    login: (interaction) => login(config, interaction),
+    refresh: (credential, signal) => refresh(config, credential, signal),
+    toAuth: async (credential) => ({ apiKey: cloudCodeKey(credential) })
+  };
+}
+var geminiCliOAuth = googleOAuth(GEMINI_CLI_LOGIN);
+var antigravityOAuth = googleOAuth(ANTIGRAVITY_LOGIN);
+
+// packages/kyrn-judge/src/google-login/providers.ts
+var cloudCode = () => lazyApi(() => Promise.resolve().then(() => (init_cloud_code(), cloud_code_exports)));
+var FREE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+var NOT_CHAT = /image|live|computer-use|customtools|latest|deep-research|tts|embedding/;
+function geminiCliModels() {
+  return Object.values(GOOGLE_MODELS).filter((model) => model.id.startsWith("gemini-") && !NOT_CHAT.test(model.id)).map((model) => ({
+    ...model,
+    api: CLOUD_CODE_API,
+    provider: GEMINI_CLI_PROVIDER,
+    baseUrl: CLOUD_CODE_ENDPOINT,
+    cost: FREE
+  }));
+}
+function geminiCliProvider() {
+  return createProvider({
+    id: GEMINI_CLI_PROVIDER,
+    name: "Google Gemini CLI (experimental)",
+    baseUrl: CLOUD_CODE_ENDPOINT,
+    auth: { oauth: geminiCliOAuth },
+    models: geminiCliModels(),
+    api: cloudCode()
+  });
+}
+var FLASH_LEVELS = {
+  off: null,
+  minimal: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: null,
+  max: null
+};
+var PRO_LEVELS = { ...FLASH_LEVELS, minimal: null };
+var levelsOf = (id) => /^gemini-3(?:\.\d+)?-pro/.test(id) ? PRO_LEVELS : /^gemini-3(?:\.\d+)?-flash/.test(id) ? FLASH_LEVELS : void 0;
+var OPUS = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
+var SONNET = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+var GEMINI_PRO = { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 2.375 };
+var GEMINI_FLASH = { input: 0.5, output: 3, cacheRead: 0.5, cacheWrite: 0 };
+var GPT_OSS = { input: 0.09, output: 0.36, cacheRead: 0, cacheWrite: 0 };
+function antigravityModel(id, name, fields) {
+  const levels = levelsOf(id);
+  return {
+    id,
+    name: `${name} (Antigravity)`,
+    api: CLOUD_CODE_API,
+    provider: ANTIGRAVITY_PROVIDER,
+    baseUrl: ANTIGRAVITY_ENDPOINTS[0],
+    ...fields,
+    ...levels ? { thinkingLevelMap: levels } : {}
+  };
+}
+var TEXT_AND_IMAGE = ["text", "image"];
+function antigravityBaseline() {
+  const claude = (maxTokens, reasoning, cost) => ({ reasoning, input: TEXT_AND_IMAGE, cost, contextWindow: 2e5, maxTokens });
+  const gemini = (cost) => ({ reasoning: true, input: TEXT_AND_IMAGE, cost, contextWindow: 1048576, maxTokens: 65535 });
+  return [
+    antigravityModel("claude-opus-4-5-thinking", "Claude Opus 4.5 Thinking", claude(64e3, true, OPUS)),
+    antigravityModel("claude-opus-4-6-thinking", "Claude Opus 4.6 Thinking", claude(128e3, true, OPUS)),
+    antigravityModel("claude-sonnet-4-5", "Claude Sonnet 4.5", claude(64e3, false, SONNET)),
+    antigravityModel("claude-sonnet-4-5-thinking", "Claude Sonnet 4.5 Thinking", claude(64e3, true, SONNET)),
+    antigravityModel("claude-sonnet-4-6", "Claude Sonnet 4.6", claude(64e3, true, SONNET)),
+    antigravityModel("gemini-3-flash", "Gemini 3 Flash", gemini(GEMINI_FLASH)),
+    antigravityModel("gemini-3.1-pro-high", "Gemini 3.1 Pro High", gemini(GEMINI_PRO)),
+    antigravityModel("gemini-3.1-pro-low", "Gemini 3.1 Pro Low", gemini(GEMINI_PRO)),
+    antigravityModel("gpt-oss-120b-medium", "GPT-OSS 120B Medium", {
+      reasoning: false,
+      input: ["text"],
+      cost: GPT_OSS,
+      contextWindow: 131072,
+      maxTokens: 32768
+    })
+  ];
+}
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+var SERVED = /^(?:gemini|claude|gpt-oss)-/;
+function antigravityModelsFrom(body) {
+  const listed = isRecord2(body) ? body.models : void 0;
+  const entries = Array.isArray(listed) ? listed.flatMap(
+    (item) => isRecord2(item) && typeof item.id === "string" ? [[item.id, item]] : []
+  ) : isRecord2(listed) ? Object.entries(listed).map(([id, info]) => [id, isRecord2(info) ? info : {}]) : [];
+  const baseline = new Map(antigravityBaseline().map((model) => [model.id, model]));
+  const models = /* @__PURE__ */ new Map();
+  for (const [raw, info] of entries) {
+    const id = raw.trim();
+    if (!SERVED.test(id) || /image/.test(id) || models.has(id)) continue;
+    const known = baseline.get(id);
+    if (known) {
+      models.set(id, known);
+      continue;
+    }
+    const family = id.startsWith("claude-") ? "claude" : id.startsWith("gpt-oss-") ? "gpt-oss" : "gemini";
+    const name = typeof info.displayName === "string" && info.displayName.trim() ? info.displayName.trim() : id;
+    const images = typeof info.supportsImages === "boolean" ? info.supportsImages : family !== "gpt-oss";
+    const reasoning = family === "gemini" ? true : typeof info.supportsThinking === "boolean" ? info.supportsThinking : /thinking/.test(id);
+    models.set(
+      id,
+      antigravityModel(id, name, {
+        reasoning,
+        input: images ? TEXT_AND_IMAGE : ["text"],
+        cost: FREE,
+        contextWindow: family === "gemini" ? 1048576 : family === "claude" ? 2e5 : 131072,
+        maxTokens: positive(info.maxOutputTokens) ?? (family === "gemini" ? 65535 : family === "claude" ? 64e3 : 32768)
+      })
+    );
+  }
+  return [...models.values()];
+}
+async function fetchAntigravityModels(context, fetcher = globalThis.fetch) {
+  const credential = context.credential;
+  if (credential?.type !== "oauth") return [];
+  let failure = "no endpoint answered";
+  for (const endpoint of ANTIGRAVITY_ENDPOINTS) {
+    const response = await fetcher(`${endpoint}/v1internal:fetchAvailableModels`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${credential.access}`,
+        "Content-Type": "application/json",
+        "User-Agent": antigravityUserAgent()
+      },
+      body: "{}",
+      signal: context.signal
+    });
+    if (response.ok) return antigravityModelsFrom(await response.json());
+    failure = `${endpoint} answered ${response.status}`;
+  }
+  throw new Error(`Antigravity did not list its models: ${failure}`);
+}
+function antigravityProvider(fetcher) {
+  return createProvider({
+    id: ANTIGRAVITY_PROVIDER,
+    name: "Google Antigravity (experimental)",
+    baseUrl: ANTIGRAVITY_ENDPOINTS[0],
+    auth: { oauth: antigravityOAuth },
+    models: antigravityBaseline(),
+    fetchModels: (context) => fetchAntigravityModels(context, fetcher),
+    api: cloudCode()
+  });
+}
+
+// packages/kyrn-judge/src/auth/runner.ts
+var BUILT_IN_PROVIDERS = ["openai-codex", "anthropic", "xai"];
+var LISTED_BY_ACCOUNT = /* @__PURE__ */ new Set(["google-antigravity"]);
+var MODELS_READ_MS = 2e4;
+var BROWSER_METHOD = "browser";
+var USAGE = "usage: mu auth status | mu auth login <provider> | mu auth logout <provider>";
+var AUTH_COMMANDS = ["status", "login", "logout"];
+function modelsOf(runtime, provider, preferred) {
+  const models = runtime.getModels(provider).map((model) => ({ id: model.id, name: model.name || model.id }));
+  const first = models.findIndex((model) => model.id === preferred[provider]);
+  return first > 0 ? [models[first], ...models.slice(0, first), ...models.slice(first + 1)] : models;
+}
+var isBrowserChoice = (prompt) => prompt.type === "select" && prompt.options.some((option) => option.id === BROWSER_METHOD);
+function shown(prompt) {
+  return {
+    type: prompt.type,
+    message: prompt.message,
+    placeholder: "placeholder" in prompt ? prompt.placeholder : void 0,
+    options: prompt.type === "select" ? prompt.options : void 0
+  };
+}
+async function runAuth(argv, options) {
+  const { runtime, preferred, io } = options;
+  try {
+    const [mode, provider] = argv;
+    if (!AUTH_COMMANDS.includes(mode ?? "")) throw new Error(USAGE);
+    for (const extra of options.extra) runtime.registerNativeProvider(extra);
+    if (options.extra.length > 0) {
+      await runtime.refresh({ allowNetwork: false, providers: options.extra.map((extra) => extra.id) });
+    }
+    const offered = [...BUILT_IN_PROVIDERS, ...options.extra.map((extra) => extra.id)];
+    const status = async () => ({
+      type: "status",
+      offered,
+      signedIn: (await runtime.listCredentials()).filter((credential) => credential.type === "oauth" && offered.includes(credential.providerId)).map((credential) => ({
+        provider: credential.providerId,
+        models: modelsOf(runtime, credential.providerId, preferred)
+      }))
+    });
+    if (mode === "status") {
+      io.say(await status());
+      return 0;
+    }
+    if (!provider) throw new Error(USAGE);
+    if (!offered.includes(provider)) throw new Error(`Signing in to ${provider} is not available in this mu`);
+    if (mode === "logout") {
+      const stored = (await runtime.listCredentials()).find((credential) => credential.providerId === provider);
+      if (stored?.type === "oauth") await runtime.logout(provider);
+      io.say(await status());
+      return 0;
+    }
+    await signIn(provider, options);
+    return 0;
+  } catch (error) {
+    io.say({ type: "error", message: error instanceof Error ? error.message : String(error) });
+    return 1;
+  }
+}
+async function signIn(provider, { runtime, preferred, io, modelsReadMs }) {
+  const controller = new AbortController();
+  let pending;
+  io.listen(
+    (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (message.type === "answer" && pending) {
+        const waiting = pending;
+        pending = void 0;
+        waiting.resolve(typeof message.value === "string" ? message.value : "");
+      } else if (message.type === "cancel") {
+        controller.abort();
+        pending?.reject(new Error("cancelled"));
+      }
+    },
+    // The app went away: nobody is left to finish the sign-in.
+    () => controller.abort()
+  );
+  await runtime.login(provider, "oauth", {
+    signal: controller.signal,
+    notify: (event) => io.say({ type: "event", event }),
+    prompt: (prompt) => isBrowserChoice(prompt) ? Promise.resolve(BROWSER_METHOD) : new Promise((resolve, reject) => {
+      const entry = { resolve, reject };
+      pending = entry;
+      prompt.signal?.addEventListener(
+        "abort",
+        () => {
+          if (pending !== entry) return;
+          pending = void 0;
+          reject(new Error("withdrawn"));
+          io.say({ type: "prompt_done" });
+        },
+        { once: true }
+      );
+      io.say({ type: "prompt", prompt: shown(prompt) });
+    })
+  });
+  io.say({ type: "signed_in" });
+  if (LISTED_BY_ACCOUNT.has(provider)) {
+    const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(modelsReadMs ?? MODELS_READ_MS)]);
+    await runtime.refresh({ providers: [provider], allowNetwork: true, signal }).catch(() => {
+    });
+  }
+  io.say({ type: "done", provider, models: modelsOf(runtime, provider, preferred) });
+}
+
+// packages/kyrn-judge/src/auth/main.ts
+var agentDir = muEnv("AGENT_DIR") || join3(muHome(), "agent");
+var say = (message) => process.stdout.write(`${JSON.stringify(message)}
+`);
+function googleProviders() {
+  try {
+    const loaded = loadConfig({ dir: agentDir, env: process.env });
+    if (loaded.disabled) return [];
+    const options = featureOptions(loaded.config, "googleLogin", {
+      enabled: true,
+      geminiCli: true,
+      antigravity: true
+    });
+    if (!options.enabled) return [];
+    return [
+      ...options.geminiCli ? [geminiCliProvider()] : [],
+      ...options.antigravity ? [antigravityProvider()] : []
+    ];
+  } catch {
+    return [];
+  }
+}
+async function main() {
+  const runtime = await ModelRuntime.create({
+    authPath: join3(agentDir, "auth.json"),
+    modelsPath: join3(agentDir, "models.json"),
+    refreshOnCreate: false
+  });
+  return runAuth(process.argv.slice(2), {
+    runtime,
+    preferred: defaultModelPerProvider,
+    extra: googleProviders(),
+    io: {
+      say,
+      listen: (line, end) => {
+        const lines = createInterface({ input: process.stdin });
+        lines.on("line", line);
+        lines.on("close", end);
+      }
+    }
+  });
+}
+main().then(
+  (code) => process.exit(code),
+  (error) => {
+    say({ type: "error", message: error instanceof Error ? error.message : String(error) });
+    process.exit(1);
+  }
+);