@anthonyhaussman/opencode-agy-auth 1.2.13-alpha.0 → 1.2.13

package/dist/index.js

@@ -579,12 +579,6 @@ async function resolveQuotaResetDelay(accessToken, projectId, model, userAgentMo
     return null;
   }
 }
-var retryInternals = {
-  parseRetryDelayValue,
-  parseRetryDelayFromMessage,
-  findResetTimeForModel,
-  resolveQuotaResetDelay
-};
 
 // src/sdk/retry/helpers.ts
 var DEFAULT_MAX_ATTEMPTS = 3;
@@ -1581,11 +1575,7 @@ function createOAuthAuthorizeMethod(options) {
     const isHeadless = !!(process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.OPENCODE_HEADLESS);
     const authorization = await authorizeAgy();
     if (!isHeadless) {
-      if (options?.openBrowser) {
-        options.openBrowser(authorization.url);
-      } else {
-        openBrowserUrl(authorization.url);
-      }
+      openBrowserUrl(authorization.url);
     }
     return {
       url: authorization.url,
@@ -1639,23 +1629,16 @@ function parseOAuthCallbackInput(input) {
   }
   return { code: trimmed };
 }
-function defaultOpenBrowserLauncher(command, args) {
-  const child = spawn(command, args, {
-    stdio: "ignore",
-    detached: true
-  });
-  child.unref?.();
-}
-var openBrowserLauncher = defaultOpenBrowserLauncher;
 function openBrowserUrl(url2) {
-  if ((process.env.NODE_ENV === "test" || process.env.VITEST) && openBrowserLauncher === defaultOpenBrowserLauncher) {
-    return;
-  }
   try {
     const platform2 = process.platform;
     const command = platform2 === "darwin" ? "open" : platform2 === "win32" ? "rundll32" : "xdg-open";
     const args = platform2 === "win32" ? ["url.dll,FileProtocolHandler", url2] : [url2];
-    openBrowserLauncher(command, args);
+    const child = spawn(command, args, {
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref?.();
   } catch {
   }
 }
@@ -20830,842 +20813,14 @@ function toUrlString(value) {
   return value.toString();
 }
 
-// src/plugin/types.ts
-function defineOpenCodeV2Plugin(def) {
-  return def;
-}
-
-// src/plugin/v2.ts
-import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
-import "http";
-var AGY_V2_QUOTA_COMMAND = "agy-quota";
-var AGY_V2_QUOTA_SUMMARY_COMMAND = "agy-quota-summary";
-var AGY_V2_QUOTA_COMMAND_TEMPLATE = `Retrieve Agy Code Assist quota usage for the current authenticated account.
-
-Immediately call \`${AGY_QUOTA_TOOL_NAME}\` with no arguments and return its output verbatim.
-Do not call other tools.
-`;
-var AGY_V2_QUOTA_SUMMARY_COMMAND_TEMPLATE = `Retrieve Agy Code Assist quota summary (weekly and 5-hour limits by model group) for the current authenticated account.
-
-Immediately call \`${AGY_QUOTA_SUMMARY_TOOL_NAME}\` with no arguments and return its output verbatim.
-Do not call other tools.
-`;
-function getSafeHeader2(headers, key) {
-  if (!headers) {
-    return void 0;
-  }
-  const targetKey = key.toLowerCase();
-  if (typeof headers.get === "function") {
-    try {
-      return headers.get(targetKey) || void 0;
-    } catch {
-    }
-  }
-  if (Array.isArray(headers)) {
-    const found = headers.find((item) => {
-      if (Array.isArray(item) && typeof item[0] === "string") {
-        return item[0].toLowerCase() === targetKey;
-      }
-      return false;
-    });
-    return found ? String(found[1]) : void 0;
-  }
-  if (typeof headers === "object") {
-    const foundKey = Object.keys(headers).find((k) => k.toLowerCase() === targetKey);
-    return foundKey ? headers[foundKey] !== void 0 ? String(headers[foundKey]) : void 0 : void 0;
-  }
-  return void 0;
-}
-function setSafeHeaders2(initHeaders, newHeaders) {
-  if (typeof globalThis.Headers !== "undefined") {
-    const headers = new globalThis.Headers(initHeaders ?? {});
-    for (const [k, v] of Object.entries(newHeaders)) {
-      headers.set(k, v);
-    }
-    return headers;
-  }
-  if (Array.isArray(initHeaders)) {
-    const nextHeaders2 = [...initHeaders];
-    for (const [k, v] of Object.entries(newHeaders)) {
-      const idx = nextHeaders2.findIndex((item) => Array.isArray(item) && typeof item[0] === "string" && item[0].toLowerCase() === k.toLowerCase());
-      if (idx !== -1) {
-        nextHeaders2[idx] = [k, v];
-      } else {
-        nextHeaders2.push([k, v]);
-      }
-    }
-    return nextHeaders2;
-  }
-  const nextHeaders = {};
-  if (initHeaders && typeof initHeaders === "object") {
-    for (const [k, v] of Object.entries(initHeaders)) {
-      nextHeaders[k] = String(v);
-    }
-  }
-  for (const [k, v] of Object.entries(newHeaders)) {
-    const existingKey = Object.keys(nextHeaders).find((key) => key.toLowerCase() === k.toLowerCase());
-    if (existingKey) {
-      nextHeaders[existingKey] = v;
-    } else {
-      nextHeaders[k] = v;
-    }
-  }
-  return nextHeaders;
-}
-function toUrlString2(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const candidate = value.url;
-  if (candidate) {
-    return candidate;
-  }
-  return value.toString();
-}
-function resolveModelTier2(baseModelId, init) {
-  const parts = baseModelId.split("@");
-  const base = parts[0] || "";
-  const suffixTier = parts[1]?.toLowerCase();
-  const mapping = TIER_MAPPING[base];
-  if (!mapping) {
-    return baseModelId;
-  }
-  const headerTier = getSafeHeader2(init?.headers, "x-agy-tier")?.toLowerCase() || null;
-  const requestedTier = headerTier || suffixTier;
-  if (requestedTier && Object.prototype.hasOwnProperty.call(mapping, requestedTier)) {
-    return mapping[requestedTier] || baseModelId;
-  }
-  return mapping["medium"] ?? mapping["high"];
-}
-var storedAuthOverrideForTesting = void 0;
-function loadStoredAuthFromJson() {
-  if (storedAuthOverrideForTesting !== void 0) {
-    return storedAuthOverrideForTesting;
-  }
-  const authPath = join6(homedir4(), ".local", "share", "opencode", "auth.json");
-  try {
-    if (existsSync6(authPath)) {
-      const content = readFileSync5(authPath, "utf8");
-      const data = JSON.parse(content);
-      return data?.[AGY_PROVIDER_ID];
-    }
-  } catch {
-  }
-  return void 0;
-}
-function saveStoredAuthToJson(authRecord) {
-  if (process.env.NODE_ENV === "test" || process.env.VITEST || storedAuthOverrideForTesting !== void 0) {
-    return;
-  }
-  try {
-    const dirPath = join6(homedir4(), ".local", "share", "opencode");
-    if (!existsSync6(dirPath)) {
-      mkdirSync5(dirPath, { recursive: true });
-    }
-    const authPath = join6(dirPath, "auth.json");
-    let data = {};
-    if (existsSync6(authPath)) {
-      try {
-        data = JSON.parse(readFileSync5(authPath, "utf8")) || {};
-      } catch {
-        data = {};
-      }
-    }
-    data[AGY_PROVIDER_ID] = {
-      type: "oauth",
-      refresh: authRecord.refresh,
-      access: authRecord.access,
-      expires: authRecord.expires
-    };
-    writeFileSync5(authPath, JSON.stringify(data, null, 2), "utf8");
-  } catch {
-  }
-}
-function createV2FetchInterceptor(getAuthSnapshot) {
-  return async function agyV2Fetch(input, init) {
-    const isGL = isGenerativeLanguageRequest(input);
-    const isInternal = toUrlString2(input).includes("cloudcode-pa.googleapis.com");
-    if (!isGL && !isInternal) {
-      return agyFetch(input, init);
-    }
-    let rawAuth = getAuthSnapshot ? await getAuthSnapshot() : void 0;
-    if (!rawAuth) {
-      rawAuth = loadStoredAuthFromJson();
-    }
-    if (!rawAuth || !isOAuthAuth(rawAuth)) {
-      return agyFetch(input, init);
-    }
-    let authRecord = resolveCachedAuth(rawAuth);
-    if (accessTokenExpired(authRecord)) {
-      const refreshed = await refreshAccessToken(authRecord, { auth: { set: async () => {
-      } } });
-      if (refreshed) {
-        authRecord = refreshed;
-      }
-    }
-    if (!authRecord.access) {
-      return agyFetch(input, init);
-    }
-    if (isInternal) {
-      const hasAuth = getSafeHeader2(init?.headers, "Authorization") !== void 0;
-      if (hasAuth) {
-        return agyFetch(input, init);
-      }
-      const userAgent = buildAgyCliUserAgent();
-      const headers = setSafeHeaders2(init?.headers, {
-        Authorization: `Bearer ${authRecord.access}`,
-        "User-Agent": userAgent
-      });
-      return agyFetch(input, {
-        ...init,
-        headers
-      });
-    }
-    const requestTarget = parseGenerativeLanguageRequest(input);
-    const requestUserAgentModel = requestTarget?.effectiveModel;
-    let projectContext;
-    try {
-      projectContext = await ensureProjectContext(
-        authRecord,
-        { auth: { set: async () => {
-        } } },
-        void 0,
-        requestUserAgentModel
-      );
-    } catch {
-      projectContext = {
-        effectiveProjectId: parseRefreshParts(authRecord.refresh).projectId || "antigravity",
-        auth: authRecord
-      };
-    }
-    const originalRequestedModel = parseGenerativeLanguageRequest(input)?.effectiveModel;
-    let modifiedInput = input;
-    if (isGL && originalRequestedModel) {
-      const originalBase = originalRequestedModel.replace("google-agy/", "");
-      const resolvedBase = resolveModelTier2(originalBase, init);
-      if (originalBase !== resolvedBase) {
-        if (typeof modifiedInput === "string") {
-          modifiedInput = modifiedInput.replace(`models/${originalBase}`, `models/${resolvedBase}`);
-        } else if (typeof Request !== "undefined" && modifiedInput instanceof Request) {
-          const newUrl = modifiedInput.url.replace(`models/${originalBase}`, `models/${resolvedBase}`);
-          modifiedInput = new Request(newUrl, modifiedInput);
-        }
-      }
-    }
-    const transformed = prepareAgyRequest(
-      modifiedInput,
-      init,
-      authRecord.access,
-      projectContext.effectiveProjectId,
-      void 0
-    );
-    const chatLogger = createChatLogger();
-    if (chatLogger) {
-      chatLogger.logRequest(
-        toUrlString2(transformed.request),
-        transformed.init.method || "GET",
-        transformed.init.headers,
-        transformed.init.body
-      );
-    }
-    const response = await fetchWithRetry(transformed.request, transformed.init);
-    return transformAgyResponse(
-      response,
-      transformed.streaming,
-      null,
-      transformed.requestedModel,
-      transformed.sessionId,
-      chatLogger
-    );
-  };
-}
-async function setupOpenCodeV2(ctx) {
-  const resolveVariants = (modelId) => {
-    const mapping = TIER_MAPPING[modelId];
-    if (!mapping) return void 0;
-    const variants = [];
-    if (mapping.minimal !== void 0) variants.push({ id: "minimal" });
-    if (mapping.low !== void 0) variants.push({ id: "low" });
-    if (mapping.medium !== void 0) variants.push({ id: "medium" });
-    if (mapping.high !== void 0) variants.push({ id: "high" });
-    return variants.length > 0 ? variants : void 0;
-  };
-  const updateProviderRecord = (p) => {
-    p.name = "Antigravity CLI";
-    p.activation = "enabled";
-    p.package = "aisdk:@ai-sdk/google";
-    p.description = "Google Gemini Antigravity Code Assist OAuth provider";
-    p.settings = { ...p.settings || {}, apiKey: "dummy" };
-    p.integrationID = AGY_PROVIDER_ID;
-  };
-  const buildModelRecord = (modelId, simple, existingModel) => {
-    const isClaude = modelId.startsWith("claude-");
-    const isGpt = modelId.startsWith("gpt-");
-    const variants = resolveVariants(modelId);
-    return {
-      id: modelId,
-      providerID: AGY_PROVIDER_ID,
-      name: simple.name,
-      description: simple.description,
-      family: modelId.includes("gemini") ? "gemini" : isClaude ? "claude" : isGpt ? "gpt" : "unknown",
-      reasoning: simple.reasoning,
-      attachment: simple.attachment,
-      tool_call: simple.toolCall,
-      limit: {
-        context: simple.maxTokens,
-        output: simple.maxOutputTokens
-      },
-      cost: simple.cost || { input: 0, output: 0 },
-      ...variants ? { variants } : {},
-      ...existingModel || {}
-    };
-  };
-  const updateModelRecord = (m, modelId, simple) => {
-    m.name = simple.name;
-    m.capabilities = {
-      tools: true,
-      input: ["text", "image"],
-      output: ["text"]
-    };
-    m.limit = {
-      context: simple.maxTokens,
-      output: simple.maxOutputTokens
-    };
-    m.family = "gemini";
-    if (simple.cost) {
-      m.cost = simple.cost;
-    }
-    const variants = resolveVariants(modelId);
-    if (variants) {
-      m.variants = variants;
-    }
-  };
-  if (ctx.provider?.transform) {
-    ctx.provider.transform(async (editor) => {
-      if (!editor) return;
-      if (typeof editor.update === "function") {
-        editor.update(AGY_PROVIDER_ID, updateProviderRecord);
-      } else if (typeof editor.set === "function") {
-        const p = { id: AGY_PROVIDER_ID };
-        updateProviderRecord(p);
-        editor.set(AGY_PROVIDER_ID, p);
-      } else if (typeof editor === "object") {
-        const p = editor[AGY_PROVIDER_ID] || { id: AGY_PROVIDER_ID };
-        updateProviderRecord(p);
-        editor[AGY_PROVIDER_ID] = p;
-      }
-    });
-  }
-  if (ctx.model?.transform) {
-    ctx.model.transform(async (editor) => {
-      if (!editor) return;
-      if (typeof editor.update === "function") {
-        for (const [modelId, simple] of Object.entries(STATIC_MODELS_SIMPLE)) {
-          editor.update(AGY_PROVIDER_ID, modelId, (m) => updateModelRecord(m, modelId, simple));
-        }
-      } else if (typeof editor.set === "function") {
-        for (const [modelId, simple] of Object.entries(STATIC_MODELS_SIMPLE)) {
-          const m = buildModelRecord(modelId, simple);
-          editor.set(`${AGY_PROVIDER_ID}:${modelId}`, m);
-        }
-      } else if (typeof editor === "object") {
-        for (const [modelId, simple] of Object.entries(STATIC_MODELS_SIMPLE)) {
-          const key = `${AGY_PROVIDER_ID}:${modelId}`;
-          editor[key] = buildModelRecord(modelId, simple, editor[key]);
-        }
-      }
-    });
-  }
-  if (ctx.catalog?.transform) {
-    ctx.catalog.transform(async (editor) => {
-      if (!editor) return;
-      if (typeof editor?.provider?.update === "function") {
-        editor.provider.update(AGY_PROVIDER_ID, updateProviderRecord);
-        if (typeof editor?.model?.update === "function") {
-          for (const [modelId, simple] of Object.entries(STATIC_MODELS_SIMPLE)) {
-            editor.model.update(AGY_PROVIDER_ID, modelId, (m) => updateModelRecord(m, modelId, simple));
-          }
-        }
-        return;
-      }
-      const catalog = editor;
-      catalog.providers = catalog.providers || {};
-      catalog.providers[AGY_PROVIDER_ID] = {
-        id: AGY_PROVIDER_ID,
-        name: "Antigravity CLI",
-        npm: "aisdk:@ai-sdk/google",
-        settings: { apiKey: "dummy" },
-        integrationID: AGY_PROVIDER_ID,
-        models: { ...catalog.providers[AGY_PROVIDER_ID]?.models || {} },
-        ...catalog.providers[AGY_PROVIDER_ID]
-      };
-      if (catalog.providers[AGY_PROVIDER_ID].settings) {
-        catalog.providers[AGY_PROVIDER_ID].settings = {
-          ...catalog.providers[AGY_PROVIDER_ID].settings,
-          apiKey: "dummy"
-        };
-      } else {
-        catalog.providers[AGY_PROVIDER_ID].settings = { apiKey: "dummy" };
-      }
-      catalog.providers[AGY_PROVIDER_ID].integrationID = AGY_PROVIDER_ID;
-      const targetModels = catalog.providers[AGY_PROVIDER_ID].models;
-      for (const [modelId, simple] of Object.entries(STATIC_MODELS_SIMPLE)) {
-        targetModels[modelId] = buildModelRecord(modelId, simple, targetModels[modelId]);
-      }
-    });
-  }
-  ctx.tool.transform(async (editor) => {
-    if (!editor) return;
-    const quotaTool = createAgyQuotaTool({
-      client: void 0,
-      getAuthResolver: () => void 0,
-      getConfiguredProjectId: () => void 0,
-      getUserAgentModel: () => void 0
-    });
-    const quotaSummaryTool = createAgyQuotaSummaryTool({
-      client: void 0,
-      getAuthResolver: () => void 0,
-      getConfiguredProjectId: () => void 0,
-      getUserAgentModel: () => void 0
-    });
-    if (typeof editor.add === "function") {
-      editor.add({
-        name: AGY_QUOTA_TOOL_NAME,
-        description: quotaTool.description,
-        input: {},
-        execute: async (args, context) => quotaTool.execute(args, context)
-      });
-      editor.add({
-        name: AGY_QUOTA_SUMMARY_TOOL_NAME,
-        description: quotaSummaryTool.description,
-        input: {},
-        execute: async (args, context) => quotaSummaryTool.execute(args, context)
-      });
-    } else if (typeof editor.set === "function") {
-      editor.set(AGY_QUOTA_TOOL_NAME, quotaTool);
-      editor.set(AGY_QUOTA_SUMMARY_TOOL_NAME, quotaSummaryTool);
-    } else if (editor.tools && typeof editor.tools === "object") {
-      editor.tools[AGY_QUOTA_TOOL_NAME] = quotaTool;
-      editor.tools[AGY_QUOTA_SUMMARY_TOOL_NAME] = quotaSummaryTool;
-    } else if (typeof editor === "object") {
-      editor[AGY_QUOTA_TOOL_NAME] = quotaTool;
-      editor[AGY_QUOTA_SUMMARY_TOOL_NAME] = quotaSummaryTool;
-    }
-  });
-  ctx.command.transform(async (editor) => {
-    if (!editor) return;
-    const commands = {
-      [AGY_V2_QUOTA_COMMAND]: {
-        description: "Show Agy Code Assist quota usage",
-        template: AGY_V2_QUOTA_COMMAND_TEMPLATE
-      },
-      [AGY_V2_QUOTA_SUMMARY_COMMAND]: {
-        description: "Show Agy Code Assist quota summary with weekly and 5-hour limits",
-        template: AGY_V2_QUOTA_SUMMARY_COMMAND_TEMPLATE
-      }
-    };
-    if (typeof editor.add === "function") {
-      editor.add({
-        name: AGY_V2_QUOTA_COMMAND,
-        description: "Display current Antigravity quota usage",
-        template: AGY_V2_QUOTA_COMMAND_TEMPLATE
-      });
-      editor.add({
-        name: AGY_V2_QUOTA_SUMMARY_COMMAND,
-        description: "Display Antigravity quota summary grouped by model family",
-        template: AGY_V2_QUOTA_SUMMARY_COMMAND_TEMPLATE
-      });
-    } else if (typeof editor.set === "function") {
-      editor.set(AGY_V2_QUOTA_COMMAND, commands[AGY_V2_QUOTA_COMMAND]);
-      editor.set(AGY_V2_QUOTA_SUMMARY_COMMAND, commands[AGY_V2_QUOTA_SUMMARY_COMMAND]);
-    } else if (editor.commands && typeof editor.commands === "object") {
-      editor.commands[AGY_V2_QUOTA_COMMAND] = commands[AGY_V2_QUOTA_COMMAND];
-      editor.commands[AGY_V2_QUOTA_SUMMARY_COMMAND] = commands[AGY_V2_QUOTA_SUMMARY_COMMAND];
-    } else if (typeof editor === "object") {
-      editor[AGY_V2_QUOTA_COMMAND] = commands[AGY_V2_QUOTA_COMMAND];
-      editor[AGY_V2_QUOTA_SUMMARY_COMMAND] = commands[AGY_V2_QUOTA_SUMMARY_COMMAND];
-    }
-  });
-  ctx.integration?.transform?.((editor) => {
-    if (!editor) return;
-    editor.update?.(AGY_PROVIDER_ID, (integration) => {
-      integration.name = "Antigravity CLI (plugin)";
-    });
-    editor.method?.update?.({
-      integrationID: AGY_PROVIDER_ID,
-      method: {
-        id: "oauth",
-        type: "oauth",
-        label: "Antigravity CLI (OAuth)"
-      },
-      authorize: async () => {
-        const authorization = await authorizeAgy();
-        return {
-          mode: "code",
-          url: authorization.url,
-          instructions: "Please complete Google account authorization in your browser. After authorization, copy the full redirect URL or code and paste it below:",
-          callback: async (code) => {
-            const trimmed = code.trim();
-            const parsed = parseOAuthCallbackInput(trimmed);
-            const authCode = parsed.code || trimmed;
-            if (!authCode) {
-              return { type: "failed", error: "Missing authorization code in callback input" };
-            }
-            if (parsed.state && parsed.state !== authorization.state) {
-              return { type: "failed", error: "State mismatch in callback input (possible CSRF attempt)" };
-            }
-            const exchangeResult = await exchangeAgyWithVerifier(authCode, authorization.verifier);
-            if (exchangeResult.type !== "success") {
-              return exchangeResult;
-            }
-            const initialRefresh = formatRefreshParts({
-              refreshToken: exchangeResult.refresh
-            });
-            let authRecord = {
-              type: "oauth",
-              refresh: initialRefresh,
-              access: exchangeResult.access,
-              expires: exchangeResult.expires
-            };
-            try {
-              const projectContext = await ensureProjectContext(
-                authRecord,
-                { auth: { set: async () => {
-                } } }
-              );
-              authRecord = {
-                ...authRecord,
-                refresh: projectContext.auth.refresh
-              };
-            } catch {
-            }
-            saveStoredAuthToJson(authRecord);
-            return {
-              type: "oauth",
-              methodID: "oauth",
-              refresh: authRecord.refresh,
-              access: authRecord.access,
-              expires: authRecord.expires
-            };
-          }
-        };
-      }
-    });
-  });
-  ctx.aisdk?.hook("sdk", async (event) => {
-    if (!event) return;
-    const isMatchingProvider = event.providerID === AGY_PROVIDER_ID || event.model?.providerID === AGY_PROVIDER_ID;
-    if (!isMatchingProvider) return;
-    event.options = event.options || {};
-    event.options.apiKey = "dummy";
-    event.options.fetch = createV2FetchInterceptor();
-  });
-  let lastInterceptedModel;
-  ctx.session.hook(
-    "http.request",
-    async (event) => {
-      if (!event) return;
-      const rawUrl = typeof event.url === "string" ? event.url : event.request?.url || "";
-      const isGL = isGenerativeLanguageRequest(rawUrl);
-      const isInternal = rawUrl.includes("cloudcode-pa.googleapis.com");
-      if (!isGL && !isInternal) {
-        return;
-      }
-      event.headers = event.headers || {};
-      let modelName;
-      let rawAuth = event.auth;
-      if (rawAuth && !rawAuth.type) {
-        const tokenVal = rawAuth.access || rawAuth.token;
-        if (tokenVal || rawAuth.refresh) {
-          rawAuth = { type: "oauth", access: tokenVal, ...rawAuth };
-        }
-      }
-      if (!rawAuth || !isOAuthAuth(rawAuth)) {
-        rawAuth = loadStoredAuthFromJson();
-      }
-      let authRecord = rawAuth && isOAuthAuth(rawAuth) ? resolveCachedAuth(rawAuth) : void 0;
-      if (authRecord && accessTokenExpired(authRecord)) {
-        const refreshed = await refreshAccessToken(authRecord, { auth: { set: async () => {
-        } } });
-        if (refreshed) {
-          authRecord = refreshed;
-          saveStoredAuthToJson(refreshed);
-        }
-      }
-      if (isGL) {
-        const parsed = parseGenerativeLanguageRequest(rawUrl);
-        modelName = parsed?.effectiveModel;
-        if (modelName) {
-          lastInterceptedModel = modelName;
-        }
-        if (typeof event.headers.delete === "function") {
-          event.headers.delete("x-goog-api-key");
-          event.headers.delete("api-key");
-        } else {
-          for (const key of Object.keys(event.headers)) {
-            const lower = key.toLowerCase();
-            if (lower === "x-goog-api-key" || lower === "api-key") {
-              delete event.headers[key];
-            }
-          }
-        }
-        if (event.request?.headers) {
-          if (typeof event.request.headers.delete === "function") {
-            event.request.headers.delete("x-goog-api-key");
-            event.request.headers.delete("api-key");
-          } else {
-            for (const key of Object.keys(event.request.headers)) {
-              const lower = key.toLowerCase();
-              if (lower === "x-goog-api-key" || lower === "api-key") {
-                delete event.request.headers[key];
-              }
-            }
-          }
-        }
-        let cleanUrl = rawUrl;
-        try {
-          const parsedUrl = new URL(rawUrl);
-          let urlChanged = false;
-          for (const param of ["key", "x-goog-api-key", "api-key"]) {
-            if (parsedUrl.searchParams.has(param)) {
-              parsedUrl.searchParams.delete(param);
-              urlChanged = true;
-            }
-          }
-          if (urlChanged) {
-            cleanUrl = parsedUrl.toString();
-          }
-        } catch {
-        }
-        if (authRecord && authRecord.access) {
-          let projectContext;
-          try {
-            projectContext = await ensureProjectContext(
-              authRecord,
-              { auth: { set: async () => {
-              } } },
-              void 0,
-              modelName
-            );
-          } catch {
-            projectContext = {
-              effectiveProjectId: parseRefreshParts(authRecord.refresh).projectId || "antigravity",
-              auth: authRecord
-            };
-          }
-          const originalRequestedModel = modelName;
-          let modifiedUrl = cleanUrl;
-          if (originalRequestedModel) {
-            const originalBase = originalRequestedModel.replace("google-agy/", "");
-            const initHeaders = event.headers instanceof Headers ? event.headers : event.request?.headers;
-            const resolvedBase = resolveModelTier2(originalBase, { headers: initHeaders });
-            if (originalBase !== resolvedBase) {
-              modifiedUrl = modifiedUrl.replace(`models/${originalBase}`, `models/${resolvedBase}`);
-            }
-          }
-          let bodyPayload = event.body;
-          if (bodyPayload === void 0 && event.request) {
-            if (typeof event.request.clone === "function") {
-              try {
-                bodyPayload = await event.request.clone().text();
-              } catch {
-              }
-            } else if (event.request.body !== void 0) {
-              bodyPayload = event.request.body;
-            }
-          }
-          let preExistingUserAgent;
-          if (typeof event.headers?.get === "function") {
-            preExistingUserAgent = event.headers.get("user-agent") || event.headers.get("User-Agent") || void 0;
-          } else if (event.headers && typeof event.headers === "object") {
-            preExistingUserAgent = event.headers["user-agent"] || event.headers["User-Agent"] || void 0;
-          }
-          if (!preExistingUserAgent && typeof event.request?.headers?.get === "function") {
-            preExistingUserAgent = event.request.headers.get("user-agent") || event.request.headers.get("User-Agent") || void 0;
-          } else if (!preExistingUserAgent && event.request?.headers && typeof event.request.headers === "object") {
-            preExistingUserAgent = event.request.headers["user-agent"] || event.request.headers["User-Agent"] || void 0;
-          }
-          const method = event.method || event.request?.method || "POST";
-          const requestHeaders = event.headers || event.request?.headers;
-          const transformed = prepareAgyRequest(
-            modifiedUrl,
-            {
-              method,
-              headers: requestHeaders,
-              body: bodyPayload
-            },
-            authRecord.access,
-            projectContext.effectiveProjectId
-          );
-          const targetUrl = toUrlString2(transformed.request);
-          if (typeof event.url === "string") {
-            event.url = targetUrl;
-          }
-          if (event.request && typeof event.request === "object") {
-            if (typeof Request !== "undefined" && event.request instanceof Request) {
-              event.request = new Request(targetUrl, {
-                method: transformed.init.method,
-                headers: transformed.init.headers,
-                body: transformed.init.body
-              });
-            } else if (typeof event.request.url === "string") {
-              try {
-                event.request.url = targetUrl;
-              } catch {
-              }
-            }
-          }
-          const headerEntries = transformed.init.headers instanceof Headers ? Array.from(transformed.init.headers.entries()) : Object.entries(transformed.init.headers || {});
-          for (const [k, v] of headerEntries) {
-            const lowerK = k.toLowerCase();
-            if (lowerK === "user-agent") {
-              if (preExistingUserAgent) {
-                continue;
-              }
-              if (typeof event.headers?.set === "function") {
-                event.headers.set("User-Agent", v);
-              } else if (event.headers) {
-                event.headers["User-Agent"] = v;
-              }
-              if (event.request?.headers && typeof event.request.headers.set === "function") {
-                event.request.headers.set("User-Agent", v);
-              } else if (event.request?.headers && typeof event.request.headers === "object") {
-                event.request.headers["User-Agent"] = v;
-              }
-              continue;
-            }
-            if (typeof event.headers?.set === "function") {
-              event.headers.set(k, v);
-            } else if (event.headers) {
-              event.headers[k] = v;
-            }
-            if (event.request?.headers && typeof event.request.headers.set === "function") {
-              event.request.headers.set(k, v);
-            } else if (event.request?.headers && typeof event.request.headers === "object") {
-              event.request.headers[k] = v;
-            }
-          }
-          if (transformed.init.body !== void 0) {
-            event.body = transformed.init.body;
-            if (event.request && typeof event.request === "object" && !(event.request instanceof Request)) {
-              event.request.body = transformed.init.body;
-            }
-          }
-        } else {
-          if (typeof event.url === "string") {
-            event.url = cleanUrl;
-          }
-          if (event.request && typeof event.request === "object") {
-            if (typeof event.request.url === "string") {
-              event.request.url = cleanUrl;
-            }
-          }
-        }
-      }
-      if (authRecord && authRecord.access) {
-        if (typeof event.headers?.set === "function") {
-          event.headers.set("Authorization", `Bearer ${authRecord.access}`);
-        } else if (event.headers) {
-          event.headers["Authorization"] = `Bearer ${authRecord.access}`;
-        }
-        if (event.request?.headers && typeof event.request.headers.set === "function") {
-          event.request.headers.set("Authorization", `Bearer ${authRecord.access}`);
-        } else if (event.request?.headers && typeof event.request.headers === "object") {
-          event.request.headers["Authorization"] = `Bearer ${authRecord.access}`;
-        }
-      }
-      const userAgent = buildAgyCliUserAgent(modelName);
-      if (typeof event.headers?.set === "function") {
-        if (!event.headers.get("User-Agent") && !event.headers.get("user-agent")) {
-          event.headers.set("User-Agent", userAgent);
-        }
-      } else if (event.headers) {
-        if (!event.headers["User-Agent"] && !event.headers["user-agent"]) {
-          event.headers["User-Agent"] = userAgent;
-        }
-      }
-      if (event.request?.headers && typeof event.request.headers.set === "function") {
-        if (!event.request.headers.get("User-Agent") && !event.request.headers.get("user-agent")) {
-          event.request.headers.set("User-Agent", userAgent);
-        }
-      } else if (event.request?.headers && typeof event.request.headers === "object") {
-        if (!event.request.headers["User-Agent"] && !event.request.headers["user-agent"]) {
-          event.request.headers["User-Agent"] = userAgent;
-        }
-      }
-    },
-    { providerID: AGY_PROVIDER_ID }
-  );
-  ctx.session.hook(
-    "http.response",
-    async (event) => {
-      if (!event || !event.response) return;
-      const rawUrl = typeof event.url === "string" ? event.url : event.request?.url || "";
-      const isInternal = rawUrl.includes("cloudcode-pa.googleapis.com");
-      if (isInternal && event.response instanceof Response) {
-        const isStreaming = rawUrl.includes(":streamGenerateCode") || event.response.headers.get("content-type")?.includes("text/event-stream");
-        const parsedModel = parseGenerativeLanguageRequest(rawUrl)?.effectiveModel || lastInterceptedModel;
-        const transformed = await transformAgyResponse(
-          event.response,
-          !!isStreaming,
-          null,
-          parsedModel,
-          void 0,
-          void 0
-        );
-        event.response = transformed;
-      }
-    },
-    { providerID: AGY_PROVIDER_ID }
-  );
-  ctx.session.hook(
-    "retry",
-    async (event) => {
-      if (!event) return;
-      const response = event.response;
-      if (response instanceof Response) {
-        if (response.status === 429 || response.status === 503) {
-          const quota = await classifyQuotaResponse(response);
-          if (quota?.retryDelayMs) {
-            event.retryDelayMs = quota.retryDelayMs;
-          } else {
-            event.retryDelayMs = await resolveRetryDelayMs(response, event.attempt || 1);
-          }
-        }
-      } else if (event.details && Array.isArray(event.details)) {
-        const retryInfo = event.details.find(
-          (d) => d && d["@type"] === "type.googleapis.com/google.rpc.RetryInfo"
-        );
-        if (retryInfo?.retryDelay) {
-          const delayMs = retryInternals.parseRetryDelayValue(retryInfo.retryDelay);
-          if (delayMs !== null) {
-            event.retryDelayMs = delayMs;
-          }
-        }
-      }
-    },
-    { providerID: AGY_PROVIDER_ID }
-  );
-}
-var v2PluginDefinition = defineOpenCodeV2Plugin({
-  id: AGY_PROVIDER_ID,
-  setup: setupOpenCodeV2
-});
-
 // index.ts
-var dualPlugin = {
-  ...v2PluginDefinition,
+var index_default = {
+  id: "@anthonyhaussman/opencode-agy-auth",
   server: AgyCLIOAuthPlugin
 };
-var index_default = dualPlugin;
 export {
   AgyCLIOAuthPlugin,
   GoogleOAuthPlugin,
-  index_default as default,
-  defineOpenCodeV2Plugin,
-  setupOpenCodeV2,
-  v2PluginDefinition
+  index_default as default
 };
 //# sourceMappingURL=index.js.map