@vostride/agent-qa-subscription-auth 0.2.3 → 0.2.5

package/dist/index.js

@@ -1,715 +1,625 @@
+import { createAuthFetch, generatePKCE, generateState } from "@vostride/agent-qa-core";
+import { createServer } from "node:http";
 // src/anthropic.ts
-import {
-  generatePKCE
-} from "@vostride/agent-qa-core";
-var ANTHROPIC_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-var ANTHROPIC_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
-var ANTHROPIC_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
-var ANTHROPIC_SCOPES = "org:create_api_key user:profile user:inference";
-var ANTHROPIC_BETA_FLAGS = "oauth-2025-04-20,interleaved-thinking-2025-05-14";
-var SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
-var TOOL_PREFIX = "mcp_";
-var AUTH_BASES = {
-  max: "https://claude.ai/oauth/authorize",
-  console: "https://console.anthropic.com/oauth/authorize"
+const ANTHROPIC_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const ANTHROPIC_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+const ANTHROPIC_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
+const ANTHROPIC_SCOPES = "org:create_api_key user:profile user:inference";
+const ANTHROPIC_BETA_FLAGS = "oauth-2025-04-20,interleaved-thinking-2025-05-14";
+const SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
+const TOOL_PREFIX = "mcp_";
+const AUTH_BASES = {
+	max: "https://claude.ai/oauth/authorize",
+	console: "https://console.anthropic.com/oauth/authorize"
 };
 function anthropicAuthorizeUrl(options) {
-  const base = AUTH_BASES[options.mode];
-  const params = new URLSearchParams({
-    code: "true",
-    client_id: ANTHROPIC_CLIENT_ID,
-    response_type: "code",
-    redirect_uri: ANTHROPIC_REDIRECT_URI,
-    scope: ANTHROPIC_SCOPES,
-    code_challenge: options.pkce.challenge,
-    code_challenge_method: "S256",
-    state: options.pkce.verifier
-  });
-  return `${base}?${params.toString()}`;
+	return `${AUTH_BASES[options.mode]}?${new URLSearchParams({
+		code: "true",
+		client_id: ANTHROPIC_CLIENT_ID,
+		response_type: "code",
+		redirect_uri: ANTHROPIC_REDIRECT_URI,
+		scope: ANTHROPIC_SCOPES,
+		code_challenge: options.pkce.challenge,
+		code_challenge_method: "S256",
+		state: options.pkce.verifier
+	}).toString()}`;
 }
 function startAnthropicAuth() {
-  const pkce = generatePKCE();
-  return {
-    authorizeUrl: anthropicAuthorizeUrl({ mode: "max", pkce }),
-    sessionState: { verifier: pkce.verifier }
-  };
+	const pkce = generatePKCE();
+	return {
+		authorizeUrl: anthropicAuthorizeUrl({
+			mode: "max",
+			pkce
+		}),
+		sessionState: { verifier: pkce.verifier }
+	};
 }
 function readVerifier(sessionState) {
-  if (sessionState && typeof sessionState === "object" && typeof sessionState.verifier === "string") {
-    return sessionState.verifier;
-  }
-  throw new Error("Anthropic subscription auth session is missing PKCE verifier.");
+	if (sessionState && typeof sessionState === "object" && typeof sessionState.verifier === "string") return sessionState.verifier;
+	throw new Error("Anthropic subscription auth session is missing PKCE verifier.");
 }
 async function exchangeAnthropicManualCode(ctx) {
-  return await anthropicExchangeCode(ctx.code, { verifier: readVerifier(ctx.sessionState) });
+	return await anthropicExchangeCode(ctx.code, { verifier: readVerifier(ctx.sessionState) });
 }
 async function anthropicExchangeCode(codeWithState, pkce) {
-  const [code, state] = codeWithState.split("#");
-  const res = await globalThis.fetch(ANTHROPIC_TOKEN_URL, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      code,
-      state: state ?? pkce.verifier,
-      grant_type: "authorization_code",
-      client_id: ANTHROPIC_CLIENT_ID,
-      redirect_uri: ANTHROPIC_REDIRECT_URI,
-      code_verifier: pkce.verifier
-    })
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Anthropic token exchange failed: ${text}`);
-  }
-  const json = await res.json();
-  if (typeof json.access_token !== "string" || typeof json.refresh_token !== "string" || typeof json.expires_in !== "number") {
-    throw new Error("Anthropic token exchange response is missing required fields");
-  }
-  return {
-    access: json.access_token,
-    refresh: json.refresh_token,
-    expires: Date.now() + json.expires_in * 1e3
-  };
+	const [code, state] = codeWithState.split("#");
+	const res = await globalThis.fetch(ANTHROPIC_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			code,
+			state: state ?? pkce.verifier,
+			grant_type: "authorization_code",
+			client_id: ANTHROPIC_CLIENT_ID,
+			redirect_uri: ANTHROPIC_REDIRECT_URI,
+			code_verifier: pkce.verifier
+		})
+	});
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error(`Anthropic token exchange failed: ${text}`);
+	}
+	const json = await res.json();
+	if (typeof json.access_token !== "string" || typeof json.refresh_token !== "string" || typeof json.expires_in !== "number") throw new Error("Anthropic token exchange response is missing required fields");
+	return {
+		access: json.access_token,
+		refresh: json.refresh_token,
+		expires: Date.now() + json.expires_in * 1e3
+	};
 }
-var anthropicRefreshTokens = async (_provider, refreshToken) => {
-  const res = await globalThis.fetch(ANTHROPIC_TOKEN_URL, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-      client_id: ANTHROPIC_CLIENT_ID
-    })
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Anthropic token refresh failed: ${text}`);
-  }
-  const json = await res.json();
-  if (typeof json.access_token !== "string" || typeof json.expires_in !== "number") {
-    throw new Error("Anthropic token refresh response is missing required fields");
-  }
-  return {
-    access: json.access_token,
-    refresh: typeof json.refresh_token === "string" ? json.refresh_token : refreshToken,
-    expires: Date.now() + json.expires_in * 1e3
-  };
+const anthropicRefreshTokens = async (_provider, refreshToken) => {
+	const res = await globalThis.fetch(ANTHROPIC_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			grant_type: "refresh_token",
+			refresh_token: refreshToken,
+			client_id: ANTHROPIC_CLIENT_ID
+		})
+	});
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error(`Anthropic token refresh failed: ${text}`);
+	}
+	const json = await res.json();
+	if (typeof json.access_token !== "string" || typeof json.expires_in !== "number") throw new Error("Anthropic token refresh response is missing required fields");
+	return {
+		access: json.access_token,
+		refresh: typeof json.refresh_token === "string" ? json.refresh_token : refreshToken,
+		expires: Date.now() + json.expires_in * 1e3
+	};
 };
 function prefixToolName(name) {
-  return typeof name === "string" && !name.startsWith(TOOL_PREFIX) ? `${TOOL_PREFIX}${name}` : name;
+	return typeof name === "string" && !name.startsWith(TOOL_PREFIX) ? `${TOOL_PREFIX}${name}` : name;
 }
 function stripToolNamePrefix(name) {
-  return typeof name === "string" && name.startsWith(TOOL_PREFIX) ? name.slice(TOOL_PREFIX.length) : name;
+	return typeof name === "string" && name.startsWith(TOOL_PREFIX) ? name.slice(4) : name;
 }
 function createAnthropicAuthFetch(getTokens, onRefreshed) {
-  return async (input, init) => {
-    let tokens = await getTokens();
-    if (tokens.expires < Date.now()) {
-      tokens = await anthropicRefreshTokens("anthropic-subscription", tokens.refresh);
-      await onRefreshed(tokens);
-    }
-    const headers = new Headers();
-    if (input instanceof Request) {
-      input.headers.forEach((value, key) => {
-        headers.set(key, value);
-      });
-    }
-    if (init?.headers) {
-      if (init.headers instanceof Headers) {
-        init.headers.forEach((value, key) => {
-          headers.set(key, value);
-        });
-      } else if (Array.isArray(init.headers)) {
-        for (const [key, value] of init.headers) {
-          if (value !== void 0) headers.set(key, String(value));
-        }
-      } else {
-        for (const [key, value] of Object.entries(init.headers)) {
-          if (value !== void 0) headers.set(key, String(value));
-        }
-      }
-    }
-    const incoming = (headers.get("anthropic-beta") || "").split(",").map((b) => b.trim()).filter(Boolean);
-    const required = ANTHROPIC_BETA_FLAGS.split(",");
-    const merged = [.../* @__PURE__ */ new Set([...required, ...incoming])].join(",");
-    headers.delete("authorization");
-    headers.delete("x-api-key");
-    headers.set("Authorization", `Bearer ${tokens.access}`);
-    headers.set("anthropic-beta", merged);
-    headers.set("user-agent", "claude-cli/2.1.2 (external, cli)");
-    let body = init?.body;
-    if (body && typeof body === "string") {
-      try {
-        const parsed = JSON.parse(body);
-        if (parsed.system && Array.isArray(parsed.system)) {
-          parsed.system = [{ type: "text", text: SYSTEM_PREFIX }, ...parsed.system];
-        } else if (typeof parsed.system === "string") {
-          parsed.system = SYSTEM_PREFIX + "\n\n" + parsed.system;
-        } else if (!parsed.system) {
-          parsed.system = [{ type: "text", text: SYSTEM_PREFIX }];
-        }
-        if (parsed.tools && Array.isArray(parsed.tools)) {
-          parsed.tools = parsed.tools.map((tool) => ({
-            ...tool,
-            name: prefixToolName(tool.name)
-          }));
-        }
-        if (parsed.messages && Array.isArray(parsed.messages)) {
-          parsed.messages = parsed.messages.map((msg) => {
-            if (msg.content && Array.isArray(msg.content)) {
-              msg.content = msg.content.map((block) => {
-                if (block.type === "tool_use" && block.name) {
-                  return { ...block, name: prefixToolName(block.name) };
-                }
-                return block;
-              });
-            }
-            return msg;
-          });
-        }
-        body = JSON.stringify(parsed);
-      } catch {
-      }
-    }
-    let url;
-    if (typeof input === "string") url = input;
-    else if (input instanceof URL) url = input.toString();
-    else url = input.url;
-    try {
-      const parsed = new URL(url);
-      if (parsed.pathname === "/v1/messages" && !parsed.searchParams.has("beta")) {
-        parsed.searchParams.set("beta", "true");
-        url = parsed.toString();
-      }
-    } catch {
-    }
-    const response = await globalThis.fetch(url, {
-      ...init,
-      body,
-      headers
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      return new Response(text, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
-    }
-    if (response.body) {
-      const contentType = response.headers.get("content-type") ?? "";
-      if (contentType.includes("application/json")) {
-        const rawText = await response.text();
-        const headers2 = new Headers(response.headers);
-        headers2.delete("content-length");
-        headers2.delete("content-encoding");
-        try {
-          const json = JSON.parse(rawText);
-          rewriteToolUseNames(json);
-          return new Response(JSON.stringify(json), {
-            status: response.status,
-            statusText: response.statusText,
-            headers: headers2
-          });
-        } catch {
-          return new Response(rawText, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: headers2
-          });
-        }
-      }
-      const stream = response.body.pipeThrough(createAnthropicToolNameTransform());
-      return new Response(stream, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
-    }
-    return response;
-  };
+	return async (input, init) => {
+		let tokens = await getTokens();
+		if (tokens.expires < Date.now()) {
+			tokens = await anthropicRefreshTokens("anthropic-subscription", tokens.refresh);
+			await onRefreshed(tokens);
+		}
+		const headers = new Headers();
+		if (input instanceof Request) input.headers.forEach((value, key) => {
+			headers.set(key, value);
+		});
+		if (init?.headers) {
+			if (init.headers instanceof Headers) init.headers.forEach((value, key) => {
+				headers.set(key, value);
+			});
+			else if (Array.isArray(init.headers)) {
+				for (const [key, value] of init.headers) if (value !== void 0) headers.set(key, String(value));
+			} else for (const [key, value] of Object.entries(init.headers)) if (value !== void 0) headers.set(key, String(value));
+		}
+		const incoming = (headers.get("anthropic-beta") || "").split(",").map((b) => b.trim()).filter(Boolean);
+		const required = ANTHROPIC_BETA_FLAGS.split(",");
+		const merged = [.../* @__PURE__ */ new Set([...required, ...incoming])].join(",");
+		headers.delete("authorization");
+		headers.delete("x-api-key");
+		headers.set("Authorization", `Bearer ${tokens.access}`);
+		headers.set("anthropic-beta", merged);
+		headers.set("user-agent", "claude-cli/2.1.2 (external, cli)");
+		let body = init?.body;
+		if (body && typeof body === "string") try {
+			const parsed = JSON.parse(body);
+			if (parsed.system && Array.isArray(parsed.system)) parsed.system = [{
+				type: "text",
+				text: SYSTEM_PREFIX
+			}, ...parsed.system];
+			else if (typeof parsed.system === "string") parsed.system = SYSTEM_PREFIX + "\n\n" + parsed.system;
+			else if (!parsed.system) parsed.system = [{
+				type: "text",
+				text: SYSTEM_PREFIX
+			}];
+			if (parsed.tools && Array.isArray(parsed.tools)) parsed.tools = parsed.tools.map((tool) => ({
+				...tool,
+				name: prefixToolName(tool.name)
+			}));
+			if (parsed.messages && Array.isArray(parsed.messages)) parsed.messages = parsed.messages.map((msg) => {
+				if (msg.content && Array.isArray(msg.content)) msg.content = msg.content.map((block) => {
+					if (block.type === "tool_use" && block.name) return {
+						...block,
+						name: prefixToolName(block.name)
+					};
+					return block;
+				});
+				return msg;
+			});
+			body = JSON.stringify(parsed);
+		} catch {}
+		let url;
+		if (typeof input === "string") url = input;
+		else if (input instanceof URL) url = input.toString();
+		else url = input.url;
+		try {
+			const parsed = new URL(url);
+			if (parsed.pathname === "/v1/messages" && !parsed.searchParams.has("beta")) {
+				parsed.searchParams.set("beta", "true");
+				url = parsed.toString();
+			}
+		} catch {}
+		const response = await globalThis.fetch(url, {
+			...init,
+			body,
+			headers
+		});
+		if (!response.ok) {
+			const text = await response.text();
+			return new Response(text, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			});
+		}
+		if (response.body) {
+			if ((response.headers.get("content-type") ?? "").includes("application/json")) {
+				const rawText = await response.text();
+				const headers = new Headers(response.headers);
+				headers.delete("content-length");
+				headers.delete("content-encoding");
+				try {
+					const json = JSON.parse(rawText);
+					rewriteToolUseNames(json);
+					return new Response(JSON.stringify(json), {
+						status: response.status,
+						statusText: response.statusText,
+						headers
+					});
+				} catch {
+					return new Response(rawText, {
+						status: response.status,
+						statusText: response.statusText,
+						headers
+					});
+				}
+			}
+			const stream = response.body.pipeThrough(createAnthropicToolNameTransform());
+			return new Response(stream, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			});
+		}
+		return response;
+	};
 }
 function createAnthropicToolNameTransform() {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let pending = "";
-  return new TransformStream({
-    transform(chunk, controller) {
-      pending += decoder.decode(chunk, { stream: true });
-      let newlineIndex = pending.indexOf("\n");
-      while (newlineIndex !== -1) {
-        const line = pending.slice(0, newlineIndex + 1);
-        pending = pending.slice(newlineIndex + 1);
-        controller.enqueue(encoder.encode(rewriteAnthropicEventLine(line)));
-        newlineIndex = pending.indexOf("\n");
-      }
-    },
-    flush(controller) {
-      pending += decoder.decode();
-      if (pending) {
-        controller.enqueue(encoder.encode(rewriteAnthropicEventLine(pending)));
-        pending = "";
-      }
-    }
-  });
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	let pending = "";
+	return new TransformStream({
+		transform(chunk, controller) {
+			pending += decoder.decode(chunk, { stream: true });
+			let newlineIndex = pending.indexOf("\n");
+			while (newlineIndex !== -1) {
+				const line = pending.slice(0, newlineIndex + 1);
+				pending = pending.slice(newlineIndex + 1);
+				controller.enqueue(encoder.encode(rewriteAnthropicEventLine(line)));
+				newlineIndex = pending.indexOf("\n");
+			}
+		},
+		flush(controller) {
+			pending += decoder.decode();
+			if (pending) {
+				controller.enqueue(encoder.encode(rewriteAnthropicEventLine(pending)));
+				pending = "";
+			}
+		}
+	});
 }
 function rewriteAnthropicEventLine(line) {
-  const match = /^(data:\s*)(.*?)(\r?\n?)$/.exec(line);
-  if (!match) return line;
-  const [, prefix, jsonText, suffix] = match;
-  if (!jsonText || jsonText === "[DONE]") return line;
-  try {
-    const event = JSON.parse(jsonText);
-    rewriteToolUseNames(event);
-    return `${prefix}${JSON.stringify(event)}${suffix}`;
-  } catch {
-    return line;
-  }
+	const match = /^(data:\s*)(.*?)(\r?\n?)$/.exec(line);
+	if (!match) return line;
+	const [, prefix, jsonText, suffix] = match;
+	if (!jsonText || jsonText === "[DONE]") return line;
+	try {
+		const event = JSON.parse(jsonText);
+		rewriteToolUseNames(event);
+		return `${prefix}${JSON.stringify(event)}${suffix}`;
+	} catch {
+		return line;
+	}
 }
 function rewriteToolUseNames(value) {
-  if (!value || typeof value !== "object") return;
-  if (Array.isArray(value)) {
-    for (const item of value) rewriteToolUseNames(item);
-    return;
-  }
-  const record = value;
-  if (record.type === "tool_use") {
-    record.name = stripToolNamePrefix(record.name);
-  }
-  for (const item of Object.values(record)) {
-    rewriteToolUseNames(item);
-  }
+	if (!value || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (const item of value) rewriteToolUseNames(item);
+		return;
+	}
+	const record = value;
+	if (record.type === "tool_use") record.name = stripToolNamePrefix(record.name);
+	for (const item of Object.values(record)) rewriteToolUseNames(item);
 }
-
 // src/openai-codex.ts
-import { createServer } from "http";
-import {
-  createAuthFetch,
-  generatePKCE as generatePKCE2,
-  generateState
-} from "@vostride/agent-qa-core";
-var CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-var CODEX_AUTH_BASE = "https://auth.openai.com";
-var CODEX_TOKEN_URL = "https://auth.openai.com/oauth/token";
-var CODEX_SCOPES = "openid profile email offline_access";
-var CODEX_API_URL = "https://chatgpt.com/backend-api/codex/responses";
-var CODEX_DEFAULT_PORT = 1455;
-var CODEX_CALLBACK_HOST = "localhost";
-var CODEX_LISTEN_HOST = "127.0.0.1";
+const CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const CODEX_AUTH_BASE = "https://auth.openai.com";
+const CODEX_TOKEN_URL = "https://auth.openai.com/oauth/token";
+const CODEX_SCOPES = "openid profile email offline_access";
+const CODEX_API_URL = "https://chatgpt.com/backend-api/codex/responses";
+const CODEX_DEFAULT_PORT = 1455;
+const CODEX_CALLBACK_HOST = "localhost";
 function decodeJwtClaims(token) {
-  const parts = token.split(".");
-  if (parts.length < 3) throw new Error("Invalid JWT: expected 3 segments");
-  const payload = parts[1];
-  const decoded = Buffer.from(payload, "base64url").toString("utf-8");
-  return JSON.parse(decoded);
+	const parts = token.split(".");
+	if (parts.length < 3) throw new Error("Invalid JWT: expected 3 segments");
+	const payload = parts[1];
+	const decoded = Buffer.from(payload, "base64url").toString("utf-8");
+	return JSON.parse(decoded);
 }
 function extractAccountId(idToken) {
-  try {
-    const claims = decodeJwtClaims(idToken);
-    const authClaim = claims["https://api.openai.com/auth"];
-    if (authClaim && typeof authClaim === "object") {
-      const userIdStr = authClaim.user_id ?? authClaim.account_id;
-      if (userIdStr) return userIdStr;
-    }
-    return claims.sub ?? void 0;
-  } catch {
-    return void 0;
-  }
+	try {
+		const claims = decodeJwtClaims(idToken);
+		const authClaim = claims["https://api.openai.com/auth"];
+		if (authClaim && typeof authClaim === "object") {
+			const userIdStr = authClaim.user_id ?? authClaim.account_id;
+			if (userIdStr) return userIdStr;
+		}
+		return claims.sub ?? void 0;
+	} catch {
+		return;
+	}
 }
 async function codexExchangeCode(code, redirectUri, pkce) {
-  const body = new URLSearchParams({
-    grant_type: "authorization_code",
-    client_id: CODEX_CLIENT_ID,
-    code,
-    redirect_uri: redirectUri,
-    code_verifier: pkce.verifier
-  });
-  const res = await globalThis.fetch(CODEX_TOKEN_URL, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString()
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Codex token exchange failed: ${text}`);
-  }
-  const json = await res.json();
-  if (typeof json.access_token !== "string" || typeof json.refresh_token !== "string" || typeof json.expires_in !== "number") {
-    throw new Error("Codex token exchange response is missing required fields");
-  }
-  const accountId = typeof json.id_token === "string" ? extractAccountId(json.id_token) : void 0;
-  return {
-    access: json.access_token,
-    refresh: json.refresh_token,
-    expires: Date.now() + json.expires_in * 1e3,
-    accountId
-  };
+	const body = new URLSearchParams({
+		grant_type: "authorization_code",
+		client_id: CODEX_CLIENT_ID,
+		code,
+		redirect_uri: redirectUri,
+		code_verifier: pkce.verifier
+	});
+	const res = await globalThis.fetch(CODEX_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error(`Codex token exchange failed: ${text}`);
+	}
+	const json = await res.json();
+	if (typeof json.access_token !== "string" || typeof json.refresh_token !== "string" || typeof json.expires_in !== "number") throw new Error("Codex token exchange response is missing required fields");
+	const accountId = typeof json.id_token === "string" ? extractAccountId(json.id_token) : void 0;
+	return {
+		access: json.access_token,
+		refresh: json.refresh_token,
+		expires: Date.now() + json.expires_in * 1e3,
+		accountId
+	};
 }
-var codexRefreshTokens = async (_provider, refreshToken) => {
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    client_id: CODEX_CLIENT_ID,
-    refresh_token: refreshToken
-  });
-  const res = await globalThis.fetch(CODEX_TOKEN_URL, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString()
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Codex token refresh failed: ${text}`);
-  }
-  const json = await res.json();
-  if (typeof json.access_token !== "string" || typeof json.expires_in !== "number") {
-    throw new Error("Codex token refresh response is missing required fields");
-  }
-  const accountId = typeof json.id_token === "string" ? extractAccountId(json.id_token) : void 0;
-  return {
-    access: json.access_token,
-    refresh: typeof json.refresh_token === "string" ? json.refresh_token : refreshToken,
-    expires: Date.now() + json.expires_in * 1e3,
-    accountId
-  };
+const codexRefreshTokens = async (_provider, refreshToken) => {
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		client_id: CODEX_CLIENT_ID,
+		refresh_token: refreshToken
+	});
+	const res = await globalThis.fetch(CODEX_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error(`Codex token refresh failed: ${text}`);
+	}
+	const json = await res.json();
+	if (typeof json.access_token !== "string" || typeof json.expires_in !== "number") throw new Error("Codex token refresh response is missing required fields");
+	const accountId = typeof json.id_token === "string" ? extractAccountId(json.id_token) : void 0;
+	return {
+		access: json.access_token,
+		refresh: typeof json.refresh_token === "string" ? json.refresh_token : refreshToken,
+		expires: Date.now() + json.expires_in * 1e3,
+		accountId
+	};
 };
 async function codexBrowserAuth(options) {
-  const port = options?.port ?? CODEX_DEFAULT_PORT;
-  const listenHost = options?.listenHost ?? CODEX_LISTEN_HOST;
-  const redirectUri = `http://${CODEX_CALLBACK_HOST}:${port}/auth/callback`;
-  const pkce = generatePKCE2();
-  const state = generateState();
-  let server;
-  let resolveTokens;
-  let rejectTokens;
-  const waitForCallback = new Promise((resolve, reject) => {
-    resolveTokens = resolve;
-    rejectTokens = reject;
-  });
-  server = createServer(async (req, res) => {
-    const url = new URL(req.url ?? "/", redirectUri);
-    if (url.pathname === "/auth/callback") {
-      const code = url.searchParams.get("code");
-      const returnedState = url.searchParams.get("state");
-      if (returnedState !== state) {
-        res.writeHead(400, { "Content-Type": "text/html" });
-        res.end("<html><body>State mismatch. Please try again.</body></html>");
-        rejectTokens(new Error("OAuth state mismatch"));
-        return;
-      }
-      if (!code) {
-        res.writeHead(400, { "Content-Type": "text/html" });
-        res.end("<html><body>Missing authorization code.</body></html>");
-        rejectTokens(new Error("Missing authorization code"));
-        return;
-      }
-      try {
-        const tokens = await codexExchangeCode(code, redirectUri, {
-          verifier: pkce.verifier
-        });
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(
-          "<html><body>Authentication successful! You can close this tab.</body></html>"
-        );
-        resolveTokens(tokens);
-      } catch (err) {
-        res.writeHead(500, { "Content-Type": "text/html" });
-        res.end("<html><body>Token exchange failed.</body></html>");
-        rejectTokens(
-          err instanceof Error ? err : new Error("Token exchange failed")
-        );
-      }
-    } else {
-      res.writeHead(404);
-      res.end();
-    }
-  });
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(port, listenHost, () => {
-      server.off("error", reject);
-      resolve();
-    });
-  });
-  const params = new URLSearchParams({
-    response_type: "code",
-    client_id: CODEX_CLIENT_ID,
-    redirect_uri: redirectUri,
-    scope: CODEX_SCOPES,
-    state,
-    code_challenge: pkce.challenge,
-    code_challenge_method: "S256"
-  });
-  const authorizeUrl = `${CODEX_AUTH_BASE}/oauth/authorize?${params.toString()}`;
-  const cleanup = () => {
-    server.close();
-  };
-  return { authorizeUrl, waitForCallback, cleanup };
+	const port = options?.port ?? 1455;
+	const listenHost = options?.listenHost ?? "127.0.0.1";
+	const redirectUri = `http://${CODEX_CALLBACK_HOST}:${port}/auth/callback`;
+	const pkce = generatePKCE();
+	const state = generateState();
+	let server;
+	let resolveTokens;
+	let rejectTokens;
+	const waitForCallback = new Promise((resolve, reject) => {
+		resolveTokens = resolve;
+		rejectTokens = reject;
+	});
+	server = createServer(async (req, res) => {
+		const url = new URL(req.url ?? "/", redirectUri);
+		if (url.pathname === "/auth/callback") {
+			const code = url.searchParams.get("code");
+			if (url.searchParams.get("state") !== state) {
+				res.writeHead(400, { "Content-Type": "text/html" });
+				res.end("<html><body>State mismatch. Please try again.</body></html>");
+				rejectTokens(/* @__PURE__ */ new Error("OAuth state mismatch"));
+				return;
+			}
+			if (!code) {
+				res.writeHead(400, { "Content-Type": "text/html" });
+				res.end("<html><body>Missing authorization code.</body></html>");
+				rejectTokens(/* @__PURE__ */ new Error("Missing authorization code"));
+				return;
+			}
+			try {
+				const tokens = await codexExchangeCode(code, redirectUri, { verifier: pkce.verifier });
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end("<html><body>Authentication successful! You can close this tab.</body></html>");
+				resolveTokens(tokens);
+			} catch (err) {
+				res.writeHead(500, { "Content-Type": "text/html" });
+				res.end("<html><body>Token exchange failed.</body></html>");
+				rejectTokens(err instanceof Error ? err : /* @__PURE__ */ new Error("Token exchange failed"));
+			}
+		} else {
+			res.writeHead(404);
+			res.end();
+		}
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, listenHost, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	const params = new URLSearchParams({
+		response_type: "code",
+		client_id: CODEX_CLIENT_ID,
+		redirect_uri: redirectUri,
+		scope: CODEX_SCOPES,
+		state,
+		code_challenge: pkce.challenge,
+		code_challenge_method: "S256"
+	});
+	const authorizeUrl = `${CODEX_AUTH_BASE}/oauth/authorize?${params.toString()}`;
+	const cleanup = () => {
+		server.close();
+	};
+	return {
+		authorizeUrl,
+		waitForCallback,
+		cleanup
+	};
 }
 function createCodexAuthFetch(getTokens, onRefreshed) {
-  const authFetch = createAuthFetch({
-    provider: "openai-codex",
-    getTokens,
-    refreshTokens: codexRefreshTokens,
-    onTokensRefreshed: onRefreshed,
-    headerTransform: (headers, tokens) => {
-      if (tokens.accountId) {
-        headers.set("ChatGPT-Account-Id", tokens.accountId);
-      }
-    },
-    urlTransform: (url) => {
-      if (url.includes("/v1/responses") || url.includes("/chat/completions")) {
-        return CODEX_API_URL;
-      }
-      return url;
-    }
-  });
-  return async (input, init) => {
-    const inputUrl = extractRequestUrl(input);
-    let forceStream = false;
-    let body = init?.body;
-    if (isCodexRequestUrl(inputUrl) && body && typeof body === "string") {
-      try {
-        const parsed = JSON.parse(body);
-        if (!parsed.stream) {
-          parsed.stream = true;
-          forceStream = true;
-        }
-        if (parsed.text?.format?.strict) {
-          parsed.text.format.strict = false;
-        }
-        body = JSON.stringify(parsed);
-      } catch {
-      }
-    }
-    const response = await authFetch(input, { ...init, body });
-    if (forceStream && response.ok && response.body) {
-      return bufferCodexSSEResponse(response);
-    }
-    return response;
-  };
+	const authFetch = createAuthFetch({
+		provider: "openai-codex",
+		getTokens,
+		refreshTokens: codexRefreshTokens,
+		onTokensRefreshed: onRefreshed,
+		headerTransform: (headers, tokens) => {
+			if (tokens.accountId) headers.set("ChatGPT-Account-Id", tokens.accountId);
+		},
+		urlTransform: (url) => {
+			if (url.includes("/v1/responses") || url.includes("/chat/completions")) return CODEX_API_URL;
+			return url;
+		}
+	});
+	return async (input, init) => {
+		const inputUrl = extractRequestUrl(input);
+		let forceStream = false;
+		let body = init?.body;
+		if (isCodexRequestUrl(inputUrl) && body && typeof body === "string") try {
+			const parsed = JSON.parse(body);
+			if (!parsed.stream) {
+				parsed.stream = true;
+				forceStream = true;
+			}
+			if (parsed.text?.format?.strict) parsed.text.format.strict = false;
+			body = JSON.stringify(parsed);
+		} catch {}
+		const response = await authFetch(input, {
+			...init,
+			body
+		});
+		if (forceStream && response.ok && response.body) return bufferCodexSSEResponse(response);
+		return response;
+	};
 }
 function extractRequestUrl(input) {
-  if (typeof input === "string") return input;
-  if (input instanceof URL) return input.toString();
-  return input.url;
+	if (typeof input === "string") return input;
+	if (input instanceof URL) return input.toString();
+	return input.url;
 }
 function isCodexRequestUrl(url) {
-  return url.includes("/v1/responses") || url.includes("/chat/completions") || url.includes("chatgpt.com/backend-api/codex");
+	return url.includes("/v1/responses") || url.includes("/chat/completions") || url.includes("chatgpt.com/backend-api/codex");
 }
 async function bufferCodexSSEResponse(response) {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let completedResponse = null;
-  let outputText = "";
-  const pendingOutputItems = /* @__PURE__ */ new Map();
-  const completedOutputItems = /* @__PURE__ */ new Map();
-  const functionCallArgumentDeltas = /* @__PURE__ */ new Map();
-  const customToolInputDeltas = /* @__PURE__ */ new Map();
-  const overallTimeout = setTimeout(() => {
-    try {
-      reader.cancel();
-    } catch {
-    }
-  }, 12e4);
-  try {
-    while (true) {
-      const chunkPromise = reader.read();
-      const timeoutPromise = new Promise(
-        (resolve) => setTimeout(() => resolve({ done: true, value: void 0 }), 3e4)
-      );
-      const { done, value } = await Promise.race([chunkPromise, timeoutPromise]);
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line.startsWith("data: ")) continue;
-        const data = line.slice(6).trim();
-        if (data === "[DONE]") continue;
-        try {
-          const event = JSON.parse(data);
-          if (!isJSONRecord(event) || typeof event.type !== "string") continue;
-          if (event.type === "response.output_text.delta" && typeof event.delta === "string") {
-            outputText += event.delta;
-          }
-          if (event.type === "response.output_item.added" && typeof event.output_index === "number" && isJSONRecord(event.item)) {
-            pendingOutputItems.set(event.output_index, { ...event.item });
-          }
-          if (event.type === "response.function_call_arguments.delta" && typeof event.output_index === "number" && typeof event.delta === "string") {
-            const prev = functionCallArgumentDeltas.get(event.output_index) ?? "";
-            functionCallArgumentDeltas.set(event.output_index, prev + event.delta);
-          }
-          if (event.type === "response.custom_tool_call_input.delta" && typeof event.output_index === "number" && typeof event.delta === "string") {
-            const prev = customToolInputDeltas.get(event.output_index) ?? "";
-            customToolInputDeltas.set(event.output_index, prev + event.delta);
-          }
-          if (event.type === "response.output_item.done" && typeof event.output_index === "number" && isJSONRecord(event.item)) {
-            completedOutputItems.set(
-              event.output_index,
-              hydrateOutputItem(event.item, event.output_index, functionCallArgumentDeltas, customToolInputDeltas)
-            );
-          }
-          if ((event.type === "response.completed" || event.type === "response.incomplete") && isJSONRecord(event.response)) {
-            completedResponse = event.response;
-          }
-        } catch {
-        }
-      }
-    }
-  } finally {
-    clearTimeout(overallTimeout);
-  }
-  for (const [outputIndex, item] of pendingOutputItems) {
-    if (!completedOutputItems.has(outputIndex)) {
-      completedOutputItems.set(
-        outputIndex,
-        hydrateOutputItem(item, outputIndex, functionCallArgumentDeltas, customToolInputDeltas)
-      );
-    }
-  }
-  const bufferedOutput = [...completedOutputItems.entries()].sort(([left], [right]) => left - right).map(([, item]) => item);
-  const body = JSON.stringify(
-    ensureResponseMetadata(
-      completedResponse ? mergeBufferedOutputItems(completedResponse, bufferedOutput, outputText) : createBufferedResponse(bufferedOutput, outputText)
-    )
-  );
-  return new Response(body, {
-    status: 200,
-    headers: { "content-type": "application/json" }
-  });
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let completedResponse = null;
+	let outputText = "";
+	const pendingOutputItems = /* @__PURE__ */ new Map();
+	const completedOutputItems = /* @__PURE__ */ new Map();
+	const functionCallArgumentDeltas = /* @__PURE__ */ new Map();
+	const customToolInputDeltas = /* @__PURE__ */ new Map();
+	const overallTimeout = setTimeout(() => {
+		try {
+			reader.cancel();
+		} catch {}
+	}, 12e4);
+	try {
+		while (true) {
+			const chunkPromise = reader.read();
+			const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve({
+				done: true,
+				value: void 0
+			}), 3e4));
+			const { done, value } = await Promise.race([chunkPromise, timeoutPromise]);
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				if (!line.startsWith("data: ")) continue;
+				const data = line.slice(6).trim();
+				if (data === "[DONE]") continue;
+				try {
+					const event = JSON.parse(data);
+					if (!isJSONRecord(event) || typeof event.type !== "string") continue;
+					if (event.type === "response.output_text.delta" && typeof event.delta === "string") outputText += event.delta;
+					if (event.type === "response.output_item.added" && typeof event.output_index === "number" && isJSONRecord(event.item)) pendingOutputItems.set(event.output_index, { ...event.item });
+					if (event.type === "response.function_call_arguments.delta" && typeof event.output_index === "number" && typeof event.delta === "string") {
+						const prev = functionCallArgumentDeltas.get(event.output_index) ?? "";
+						functionCallArgumentDeltas.set(event.output_index, prev + event.delta);
+					}
+					if (event.type === "response.custom_tool_call_input.delta" && typeof event.output_index === "number" && typeof event.delta === "string") {
+						const prev = customToolInputDeltas.get(event.output_index) ?? "";
+						customToolInputDeltas.set(event.output_index, prev + event.delta);
+					}
+					if (event.type === "response.output_item.done" && typeof event.output_index === "number" && isJSONRecord(event.item)) completedOutputItems.set(event.output_index, hydrateOutputItem(event.item, event.output_index, functionCallArgumentDeltas, customToolInputDeltas));
+					if ((event.type === "response.completed" || event.type === "response.incomplete") && isJSONRecord(event.response)) completedResponse = event.response;
+				} catch {}
+			}
+		}
+	} finally {
+		clearTimeout(overallTimeout);
+	}
+	for (const [outputIndex, item] of pendingOutputItems) if (!completedOutputItems.has(outputIndex)) completedOutputItems.set(outputIndex, hydrateOutputItem(item, outputIndex, functionCallArgumentDeltas, customToolInputDeltas));
+	const bufferedOutput = [...completedOutputItems.entries()].sort(([left], [right]) => left - right).map(([, item]) => item);
+	const body = JSON.stringify(ensureResponseMetadata(completedResponse ? mergeBufferedOutputItems(completedResponse, bufferedOutput, outputText) : createBufferedResponse(bufferedOutput, outputText)));
+	return new Response(body, {
+		status: 200,
+		headers: { "content-type": "application/json" }
+	});
 }
 function isJSONRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function hydrateOutputItem(item, outputIndex, functionCallArgumentDeltas, customToolInputDeltas) {
-  const hydrated = { ...item };
-  if (hydrated.type === "function_call" && typeof hydrated.arguments !== "string") {
-    hydrated.arguments = functionCallArgumentDeltas.get(outputIndex) ?? "";
-  }
-  if (hydrated.type === "custom_tool_call" && hydrated.input == null) {
-    const input = customToolInputDeltas.get(outputIndex);
-    if (input !== void 0) {
-      hydrated.input = safeParseJSON(input) ?? input;
-    }
-  }
-  return hydrated;
+	const hydrated = { ...item };
+	if (hydrated.type === "function_call" && typeof hydrated.arguments !== "string") hydrated.arguments = functionCallArgumentDeltas.get(outputIndex) ?? "";
+	if (hydrated.type === "custom_tool_call" && hydrated.input == null) {
+		const input = customToolInputDeltas.get(outputIndex);
+		if (input !== void 0) hydrated.input = safeParseJSON(input) ?? input;
+	}
+	return hydrated;
 }
 function mergeBufferedOutputItems(response, bufferedOutput, outputText) {
-  const existingOutput = Array.isArray(response.output) ? response.output.filter(isJSONRecord) : [];
-  if (bufferedOutput.length === 0) {
-    if (existingOutput.length > 0) return response;
-    return { ...response, output: [buildTextOutput(outputText)] };
-  }
-  const mergedOutput = [...existingOutput];
-  const seenKeys = new Set(existingOutput.map(getOutputItemKey).filter((key) => key !== null));
-  for (const item of bufferedOutput) {
-    const key = getOutputItemKey(item);
-    if (key && seenKeys.has(key)) continue;
-    if (key) seenKeys.add(key);
-    mergedOutput.push(item);
-  }
-  return { ...response, output: mergedOutput };
+	const existingOutput = Array.isArray(response.output) ? response.output.filter(isJSONRecord) : [];
+	if (bufferedOutput.length === 0) {
+		if (existingOutput.length > 0) return response;
+		return {
+			...response,
+			output: [buildTextOutput(outputText)]
+		};
+	}
+	const mergedOutput = [...existingOutput];
+	const seenKeys = new Set(existingOutput.map(getOutputItemKey).filter((key) => key !== null));
+	for (const item of bufferedOutput) {
+		const key = getOutputItemKey(item);
+		if (key && seenKeys.has(key)) continue;
+		if (key) seenKeys.add(key);
+		mergedOutput.push(item);
+	}
+	return {
+		...response,
+		output: mergedOutput
+	};
 }
 function createBufferedResponse(bufferedOutput, outputText) {
-  return {
-    id: "codex-buffered",
-    output: bufferedOutput.length > 0 ? bufferedOutput : [buildTextOutput(outputText)],
-    status: "completed"
-  };
+	return {
+		id: "codex-buffered",
+		output: bufferedOutput.length > 0 ? bufferedOutput : [buildTextOutput(outputText)],
+		status: "completed"
+	};
 }
 function ensureResponseMetadata(response) {
-  if (typeof response.created_at === "number") return response;
-  return {
-    ...response,
-    created_at: Math.floor(Date.now() / 1e3)
-  };
+	if (typeof response.created_at === "number") return response;
+	return {
+		...response,
+		created_at: Math.floor(Date.now() / 1e3)
+	};
 }
 function buildTextOutput(outputText) {
-  return {
-    type: "message",
-    role: "assistant",
-    content: [{ type: "output_text", text: outputText, annotations: [] }]
-  };
+	return {
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "output_text",
+			text: outputText,
+			annotations: []
+		}]
+	};
 }
 function getOutputItemKey(item) {
-  const type = typeof item.type === "string" ? item.type : "unknown";
-  if (typeof item.id === "string") return `${type}:${item.id}`;
-  if (typeof item.call_id === "string") return `${type}:${item.call_id}`;
-  return null;
+	const type = typeof item.type === "string" ? item.type : "unknown";
+	if (typeof item.id === "string") return `${type}:${item.id}`;
+	if (typeof item.call_id === "string") return `${type}:${item.call_id}`;
+	return null;
 }
 function safeParseJSON(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
 }
-
 // src/index.ts
 function createSubscriptionAuthPlugin() {
-  return {
-    providers: [
-      {
-        providerId: "openai-subscription",
-        credentialProviderId: "openai-subscription-oauth",
-        label: "OpenAI subscription",
-        modelAdapter: "openai-responses",
-        dashboardAuth: { mode: "browser-poll", buttonLabel: "Login with OpenAI subscription" },
-        async startAuth() {
-          const result = await codexBrowserAuth();
-          return {
-            authorizeUrl: result.authorizeUrl,
-            waitForTokens: result.waitForCallback,
-            cleanup: result.cleanup
-          };
-        },
-        createAuthFetch({ getTokens, onRefreshed }) {
-          return createCodexAuthFetch(getTokens, onRefreshed);
-        }
-      },
-      {
-        providerId: "anthropic-subscription",
-        credentialProviderId: "anthropic-subscription",
-        label: "Anthropic subscription",
-        modelAdapter: "anthropic-messages",
-        dashboardAuth: { mode: "manual-code", buttonLabel: "Login with Anthropic subscription" },
-        async startAuth() {
-          return startAnthropicAuth();
-        },
-        async exchangeCode(ctx) {
-          return await exchangeAnthropicManualCode(ctx);
-        },
-        createAuthFetch({ getTokens, onRefreshed }) {
-          return createAnthropicAuthFetch(getTokens, onRefreshed);
-        }
-      }
-    ]
-  };
+	return { providers: [{
+		providerId: "openai-subscription",
+		credentialProviderId: "openai-subscription-oauth",
+		label: "OpenAI subscription",
+		modelAdapter: "openai-responses",
+		dashboardAuth: {
+			mode: "browser-poll",
+			buttonLabel: "Login with OpenAI subscription"
+		},
+		async startAuth() {
+			const result = await codexBrowserAuth();
+			return {
+				authorizeUrl: result.authorizeUrl,
+				waitForTokens: result.waitForCallback,
+				cleanup: result.cleanup
+			};
+		},
+		createAuthFetch({ getTokens, onRefreshed }) {
+			return createCodexAuthFetch(getTokens, onRefreshed);
+		}
+	}, {
+		providerId: "anthropic-subscription",
+		credentialProviderId: "anthropic-subscription",
+		label: "Anthropic subscription",
+		modelAdapter: "anthropic-messages",
+		dashboardAuth: {
+			mode: "manual-code",
+			buttonLabel: "Login with Anthropic subscription"
+		},
+		async startAuth() {
+			return startAnthropicAuth();
+		},
+		async exchangeCode(ctx) {
+			return await exchangeAnthropicManualCode(ctx);
+		},
+		createAuthFetch({ getTokens, onRefreshed }) {
+			return createAnthropicAuthFetch(getTokens, onRefreshed);
+		}
+	}] };
 }
-var index_default = createSubscriptionAuthPlugin;
-export {
-  ANTHROPIC_BETA_FLAGS,
-  ANTHROPIC_CLIENT_ID,
-  ANTHROPIC_REDIRECT_URI,
-  ANTHROPIC_SCOPES,
-  ANTHROPIC_TOKEN_URL,
-  CODEX_API_URL,
-  CODEX_AUTH_BASE,
-  CODEX_CLIENT_ID,
-  CODEX_DEFAULT_PORT,
-  CODEX_SCOPES,
-  CODEX_TOKEN_URL,
-  anthropicAuthorizeUrl,
-  anthropicExchangeCode,
-  anthropicRefreshTokens,
-  codexBrowserAuth,
-  codexExchangeCode,
-  codexRefreshTokens,
-  createAnthropicAuthFetch,
-  createCodexAuthFetch,
-  createSubscriptionAuthPlugin,
-  decodeJwtClaims,
-  index_default as default
-};
+export { ANTHROPIC_BETA_FLAGS, ANTHROPIC_CLIENT_ID, ANTHROPIC_REDIRECT_URI, ANTHROPIC_SCOPES, ANTHROPIC_TOKEN_URL, CODEX_API_URL, CODEX_AUTH_BASE, CODEX_CLIENT_ID, CODEX_DEFAULT_PORT, CODEX_SCOPES, CODEX_TOKEN_URL, anthropicAuthorizeUrl, anthropicExchangeCode, anthropicRefreshTokens, codexBrowserAuth, codexExchangeCode, codexRefreshTokens, createAnthropicAuthFetch, createCodexAuthFetch, createSubscriptionAuthPlugin, createSubscriptionAuthPlugin as default, decodeJwtClaims };
+
 //# sourceMappingURL=index.js.map