@posthog/wizard 2.67.0 → 2.69.0

package/dist/{agent-interface-tM_b0l__.js → agent-interface-CI89BrWE.js}

@@ -1,12 +1,12 @@
 import { n as __require } from "./rolldown-runtime-B_-DWIq7.js";
-import { a as AgentSignals, o as REMARK_INSTRUCTION, s as classifyAuthFailure } from "./errors-BHervYGs.js";
-import { G as POSTHOG_FLAG_HEADER_PREFIX, J as POSTHOG_PROPERTY_HEADER_PREFIX, a as getLogFilePath, dt as WIZARD_REMARK_EVENT_NAME, f as getUI, ht as wizardUserAgentForProgram, o as initLogFile, r as debug, s as logToFile, xt as runtimeEnv } from "./debug-BsHD83Vy.js";
-import { n as analytics } from "./analytics-CtIYzkK4.js";
-import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-BWqoFQvQ.js";
-import { n as ADDITIONAL_FEATURE_PROMPTS } from "./wizard-session-Cex1BiXs.js";
-import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-CGv3lVxw.js";
-import { _ as modelCapabilities, m as writeJsonAtomic, o as buildOrchestratorTools, p as makeMutex, y as triageModelFor } from "./queue-tools-BC9HxOV6.js";
-import { b as coerceAuditChecks, g as AUDIT_CHECKS_FILE, l as prewarmYaraScanner, n as createPostToolUseYaraHooks, p as scanInstalledSkill, r as createPreToolUseYaraHooks } from "./yara-hooks-DZIVzhA6.js";
+import { a as AgentSignals, o as REMARK_INSTRUCTION, s as classifyAuthFailure } from "./errors-BSdz2lsl.js";
+import { G as POSTHOG_FLAG_HEADER_PREFIX, J as POSTHOG_PROPERTY_HEADER_PREFIX, a as getLogFilePath, dt as WIZARD_REMARK_EVENT_NAME, f as getUI, ht as wizardUserAgentForProgram, o as initLogFile, r as debug, s as logToFile, xt as runtimeEnv } from "./debug-CifTS9lQ.js";
+import { n as analytics } from "./analytics-D90QbLf5.js";
+import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-BhlVkP1r.js";
+import { n as ADDITIONAL_FEATURE_PROMPTS } from "./wizard-session-C_7r3-rO.js";
+import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-CFMdj6sZ.js";
+import { _ as modelCapabilities, m as writeJsonAtomic, o as buildOrchestratorTools, p as makeMutex, y as triageModelFor } from "./queue-tools-zrqCiy6q.js";
+import { b as coerceAuditChecks, g as AUDIT_CHECKS_FILE, l as prewarmYaraScanner, n as createPostToolUseYaraHooks, p as scanInstalledSkill, r as createPreToolUseYaraHooks } from "./yara-hooks-CmQT-oBy.js";
 import { createRequire } from "node:module";
 import * as fs$1 from "fs";
 import fs from "fs";
@@ -19,6 +19,228 @@ import { z } from "zod";
 import * as os from "os";
 import { unzipSync } from "fflate";
 import { randomUUID } from "crypto";
+//#region src/lib/gateway-session.ts
+/**
+* Gateway auth for a wizard run: a `phe_` scoped token the backend mints, with
+* pinned attribution, a spend cap and an expiry.
+*
+* A 404 resolves to the legacy posture (OAuth token, Python gateway); every
+* other failure throws, because the legacy path enforces none of those, so a
+* silent downgrade spends unattributed money to hide an outage.
+*/
+let cached = null;
+/**
+* Shared so concurrent callers mint once. The orchestrator starts every runnable
+* task at once, and each would otherwise take its own token and its own cap.
+*/
+let inFlight = null;
+/**
+* Adoption floor. The anthropic subprocess holds its credential for the whole
+* session, so a token below this 401s mid-run.
+*/
+const MIN_USABLE_TTL_MS = 120 * 1e3;
+/** Re-resolve at this fraction of the token's life, leaving a usable remainder. */
+const REFRESH_AT_FRACTION = .8;
+/** How long a legacy fallback sticks before the mint endpoint is retried. */
+const LEGACY_RETRY_MS = 600 * 1e3;
+const MINT_TIMEOUT_MS = 2e4;
+/** Resolve this run's gateway auth, minting and re-minting near expiry. */
+async function gatewayAuth(host, accessToken, program) {
+	const key = `${host.apiHost}\n${accessToken}\n${program ?? ""}`;
+	if (cached && cached.key === key && Date.now() < cached.staleAtMs) return cached.auth;
+	if (inFlight && inFlight.key === key) return inFlight.promise;
+	const promise = resolveGatewayAuth(host, accessToken, key, program);
+	inFlight = {
+		key,
+		promise
+	};
+	try {
+		return await promise;
+	} finally {
+		if (inFlight?.promise === promise) inFlight = null;
+	}
+}
+async function resolveGatewayAuth(host, accessToken, key, program) {
+	if (!program) {
+		logToFile("[gateway] run has no program id; failing the run");
+		throw new GatewayMintFailed("this run has no program to attribute its spend to");
+	}
+	const minted = await mintGatewayToken(host, accessToken, program);
+	if (!minted) {
+		analytics.setTag("gateway_edition", "legacy");
+		const auth = legacyAuth(host, accessToken);
+		cached = {
+			key,
+			auth,
+			staleAtMs: Date.now() + LEGACY_RETRY_MS
+		};
+		return auth;
+	}
+	const expiresAtMs = Date.parse(minted.expiresAt);
+	const ttlMs = expiresAtMs - Date.now();
+	if (!Number.isFinite(expiresAtMs) || ttlMs < MIN_USABLE_TTL_MS) {
+		logToFile(`[gateway] mint returned a token with ${ttlMs}ms of life; failing the run`);
+		throw new GatewayMintFailed(`the PostHog gateway issued a token with ${ttlMs}ms of life`);
+	}
+	const staleAtMs = Date.now() + ttlMs * REFRESH_AT_FRACTION;
+	analytics.setTag("gateway_edition", "v2");
+	const auth = {
+		gatewayUrl: minted.gatewayUrl,
+		token: minted.token,
+		edition: "v2",
+		teamId: minted.teamId
+	};
+	cached = {
+		key,
+		auth,
+		staleAtMs
+	};
+	return auth;
+}
+/** The legacy posture: the user's OAuth token against the Python gateway. */
+function legacyAuth(host, accessToken) {
+	return {
+		gatewayUrl: host.gatewayUrl,
+		token: accessToken,
+		edition: "legacy"
+	};
+}
+/**
+* Whether a server-supplied origin may receive a bearer and prompt content:
+* https (loopback excepted), and either a posthog.com host or the one the run
+* authenticated against.
+*/
+function isTrustedGatewayUrl(value, apiHost) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	if (url.pathname !== "/" || url.search || url.hash || url.username || url.password) return false;
+	if (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "host.docker.internal") return true;
+	if (url.protocol !== "https:") return false;
+	if (url.hostname.endsWith(".posthog.com")) return true;
+	try {
+		return url.hostname === new URL(apiHost).hostname;
+	} catch {
+		return false;
+	}
+}
+/**
+* A deliberate refusal from the mint endpoint, as opposed to the mint being
+* unavailable. Thrown rather than folded into the legacy fallback, so the run
+* stops instead of proceeding without the controls the refusal was enforcing.
+*/
+var GatewayMintRefused = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "GatewayMintRefused";
+		this.status = status;
+	}
+};
+/**
+* The mint could not produce a usable credential: unreachable, a 5xx, or a
+* response the client cannot use.
+*/
+var GatewayMintFailed = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GatewayMintFailed";
+	}
+};
+/**
+* Whether a mint status means "refused this run" rather than "not available".
+* These are the statuses the endpoint returns after it has authenticated the
+* caller: 429 the daily run limit, 403 revoked project access, 400 a login
+* covering more than one project. 404 and 401 fall back instead.
+*/
+function isMintRefusal(status) {
+	return status === 400 || status === 403 || status === 429;
+}
+function mintRefusalMessage(status) {
+	switch (status) {
+		case 429: return "This wizard program has used its daily run limit. Try again tomorrow.";
+		case 403: return "Your access to this project has changed. Re-authenticate and try again.";
+		case 400: return "Your PostHog login must cover exactly one project. Re-authenticate and try again.";
+		default: return "The PostHog gateway refused this run.";
+	}
+}
+async function mintGatewayToken(host, accessToken, program) {
+	try {
+		const resp = await fetch(`${host.apiHost}/api/wizard/gateway_token/`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ program }),
+			signal: AbortSignal.timeout(MINT_TIMEOUT_MS)
+		});
+		if (!resp.ok) {
+			if (isMintRefusal(resp.status)) {
+				logToFile(`[gateway] mint refused with HTTP ${resp.status}; failing the run`);
+				throw new GatewayMintRefused(resp.status, mintRefusalMessage(resp.status));
+			}
+			if (resp.status === 404 || resp.status === 401) {
+				logToFile(`[gateway] mint unavailable for this credential (HTTP ${resp.status}); staying on the existing gateway`);
+				return null;
+			}
+			logToFile(`[gateway] mint failed with HTTP ${resp.status}; failing the run`);
+			throw new GatewayMintFailed(`the PostHog gateway could not issue a token (HTTP ${resp.status})`);
+		}
+		const body = await resp.json();
+		if (!body.token) {
+			logToFile("[gateway] mint response omitted token; failing the run");
+			throw new GatewayMintFailed("mint response omitted token");
+		}
+		if (!body.expires_at) {
+			logToFile("[gateway] mint response omitted expires_at; failing the run");
+			throw new GatewayMintFailed("mint response omitted expires_at");
+		}
+		if (!body.gateway_url) {
+			logToFile("[gateway] mint response omitted gateway_url; failing the run");
+			throw new GatewayMintFailed("mint response omitted gateway_url");
+		}
+		if (!isTrustedGatewayUrl(body.gateway_url, host.apiHost)) {
+			logToFile("[gateway] mint returned an untrusted gateway url; failing the run");
+			throw new GatewayMintFailed("mint returned an untrusted gateway url");
+		}
+		return {
+			token: body.token,
+			expiresAt: body.expires_at,
+			gatewayUrl: body.gateway_url.replace(/\/+$/, ""),
+			teamId: body.team_id
+		};
+	} catch (e) {
+		if (e instanceof GatewayMintRefused || e instanceof GatewayMintFailed) throw e;
+		logToFile(`[gateway] mint transport failure (${String(e)}); failing the run`);
+		throw new GatewayMintFailed(`could not reach the PostHog gateway (${String(e)})`);
+	}
+}
+/**
+* The v2 run-metadata carrier: one JSON blob for the `X-PostHog-Properties`
+* header. Plain keys only, since the gateway strips `$`-prefixed keys as reserved,
+* so feature-flag variants land as `wizard_flag_<key>` instead of the legacy
+* `$feature/<key>` (dashboards keying on `$feature/wizard-*` read the new key
+* post-cutover).
+*/
+function buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId) {
+	const props = {};
+	if (teamId !== void 0) props.team_id = teamId;
+	for (const [key, value] of Object.entries(wizardMetadata)) props[stripPropertyPrefix(key)] = value;
+	for (const [flagKey, variant] of Object.entries(wizardFlags)) {
+		if (!flagKey.toLowerCase().startsWith("wizard")) continue;
+		props[`wizard_flag_${flagKey.toLowerCase()}`] = variant;
+	}
+	return JSON.stringify(props);
+}
+const LEGACY_PROPERTY_PREFIX = "X-POSTHOG-PROPERTY-";
+function stripPropertyPrefix(key) {
+	return key.toUpperCase().startsWith(LEGACY_PROPERTY_PREFIX) ? key.slice(19).toLowerCase() : key;
+}
+//#endregion
 //#region src/lib/agent/runner/harness/pi/gateway.ts
 /**
 * PostHog LLM gateway provider spec for pi sessions — shared by the linear run
@@ -32,23 +254,33 @@ const GATEWAY_PROVIDER = "posthog-gateway";
 /**
 * The gateway speaks two shapes on two endpoints: Anthropic models over
 * `anthropic-messages` (the SDK appends `/v1/messages`, so the base URL has no
-* `/v1`), and OpenAI-class models (`openai/gpt-5`, …) over OpenAI completions at
-* `/v1/chat/completions` (base URL keeps `/v1`). Infer the shape from the model
-* id so a pair's model selects the right transport.
+* `/v1`), and OpenAI-class models (`openai/gpt-5`, …) over an OpenAI shape at
+* `/v1/responses` or `/v1/chat/completions` (base URL keeps `/v1`). Infer the
+* shape from the model id so a pair's model selects the right transport.
+*
+* v2 takes the Responses API because OpenAI rejects function tools combined
+* with `reasoning_effort` on chat completions and every task sends both. Legacy
+* stays on chat completions, where litellm does that routing itself.
 */
-function gatewayApiFor(modelId) {
-	return modelId.startsWith("openai/") ? "openai-completions" : "anthropic-messages";
+function gatewayApiFor(modelId, edition = "legacy") {
+	if (!modelId.startsWith("openai/")) return "anthropic-messages";
+	return edition === "v2" ? "openai-responses" : "openai-completions";
 }
 /**
-* Gateway HTTP headers, mirroring `buildAgentEnv` on the anthropic path: always
-* the Bedrock-fallback header, plus wizard metadata (`X-POSTHOG-PROPERTY-*`) and
-* wizard feature flags (`X-POSTHOG-FLAG-*`).
+* Gateway HTTP headers, mirroring `buildAgentEnv` on the anthropic path. The
+* shape follows the gateway edition: legacy sends per-key metadata/flag
+* headers plus the explicit Bedrock-fallback opt-in; v2 (the Go ai-gateway)
+* takes one `X-PostHog-Properties` JSON blob and falls back natively. The 1M
+* context beta rides both, since pi otherwise runs at 200k and overflows on larger
+* projects (the post-run compaction failures).
 */
-function buildGatewayHeaders(wizardMetadata, wizardFlags) {
-	const headers = {
-		"x-posthog-use-bedrock-fallback": "true",
-		"anthropic-beta": "context-1m-2025-08-07"
-	};
+function buildGatewayHeaders(wizardMetadata, wizardFlags, edition = "legacy", teamId) {
+	const headers = { "anthropic-beta": "context-1m-2025-08-07" };
+	if (edition === "v2") {
+		headers["X-PostHog-Properties"] = buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId);
+		return headers;
+	}
+	headers["x-posthog-use-bedrock-fallback"] = "true";
 	for (const [key, value] of Object.entries(wizardMetadata)) {
 		const name = key.startsWith("X-POSTHOG-PROPERTY-") ? key : `${POSTHOG_PROPERTY_HEADER_PREFIX}${key}`;
 		headers[name] = value;
@@ -65,14 +297,14 @@ function buildGatewayHeaders(wizardMetadata, wizardFlags) {
 * callers (scan triage) hand it straight to `completeSimple`.
 */
 function buildGatewayModel(inputs) {
-	const { gatewayUrl, wizardMetadata, wizardFlags, modelId } = inputs;
-	const api = gatewayApiFor(modelId);
+	const { gatewayUrl, wizardMetadata, wizardFlags, modelId, edition, teamId } = inputs;
+	const api = gatewayApiFor(modelId, edition);
 	return {
 		id: modelId,
 		name: `${modelId} (PostHog Gateway)`,
 		api,
 		provider: GATEWAY_PROVIDER,
-		baseUrl: api === "openai-completions" ? `${gatewayUrl}/v1` : gatewayUrl,
+		baseUrl: api === "anthropic-messages" ? gatewayUrl : `${gatewayUrl}/v1`,
 		reasoning: modelCapabilities(modelId).reasoning,
 		input: ["text"],
 		cost: {
@@ -83,7 +315,7 @@ function buildGatewayModel(inputs) {
 		},
 		contextWindow: 1e6,
 		maxTokens: 64e3,
-		headers: buildGatewayHeaders(wizardMetadata, wizardFlags)
+		headers: buildGatewayHeaders(wizardMetadata, wizardFlags, edition, teamId)
 	};
 }
 /**
@@ -91,12 +323,12 @@ function buildGatewayModel(inputs) {
 * plus the derived traits the session setup needs (`caps.thinkingLevel`).
 */
 function buildGatewayProvider(inputs) {
-	const { gatewayUrl, accessToken, modelId, effort } = inputs;
-	const api = gatewayApiFor(modelId);
+	const { gatewayUrl, accessToken, modelId, effort, edition } = inputs;
+	const api = gatewayApiFor(modelId, edition);
 	const tableCaps = modelCapabilities(modelId);
-	const caps = effort && tableCaps.reasoning ? {
+	const caps = effort && effort !== "off" && tableCaps.reasoning ? modelCapabilities(modelId, effort) : effort === "off" && tableCaps.reasoning ? {
 		...tableCaps,
-		thinkingLevel: effort
+		thinkingLevel: "off"
 	} : tableCaps;
 	const model = buildGatewayModel(inputs);
 	return {
@@ -131,6 +363,8 @@ function createTriageLLMProvider(auth, harness) {
 	const model = buildGatewayModel({
 		gatewayUrl: baseURL,
 		accessToken: authToken,
+		edition: auth.edition,
+		teamId: auth.teamId,
 		wizardMetadata: auth?.wizardMetadata ?? {},
 		wizardFlags: auth?.wizardFlags ?? {},
 		modelId
@@ -836,7 +1070,7 @@ function isFullyCancelled(answers) {
 }
 function createWizardAskBridge(opts) {
 	const timeoutMs = opts.timeoutMs ?? 3e5;
-	return { async request({ questions }) {
+	return { async request({ questions, subject }) {
 		const pending = {
 			id: randomUUID(),
 			questions,
@@ -857,12 +1091,14 @@ function createWizardAskBridge(opts) {
 			const durationMs = Date.now() - startedAt;
 			if (isFullyCancelled(answers)) analytics.wizardCapture("wizard_ask cancelled", {
 				source: pending.source,
+				subject,
 				question_count: questions.length,
 				duration_ms: durationMs,
 				timed_out: durationMs >= timeoutMs
 			});
 			else analytics.wizardCapture("wizard_ask answered", {
 				source: pending.source,
+				subject,
 				question_count: questions.length,
 				duration_ms: durationMs
 			});
@@ -1926,7 +2162,10 @@ async function createWizardToolsServer(options) {
 				}
 				askAccounting.record(args.subject);
 				try {
-					const answers = await askBridge.request({ questions: args.questions });
+					const answers = await askBridge.request({
+						questions: args.questions,
+						subject: normaliseAskSubject(args.subject)
+					});
 					if (isFullyCancelled(answers)) askAccounting.refund(args.subject);
 					const sanitised = vaultSensitiveAnswers(args.questions, answers, secretVault);
 					logToFile(`wizard_ask: resolved ${Object.keys(answers).length} answer(s) for ${args.questions.length} question(s)`);
@@ -2774,17 +3013,23 @@ function isWarlockDisabled() {
 	return runtimeEnv("POSTHOG_WIZARD_WARLOCK_DISABLED") === "true";
 }
 /**
-* Build env for the SDK subprocess: process.env plus ANTHROPIC_CUSTOM_HEADERS, which always
-* includes `x-posthog-use-bedrock-fallback: true` so the LLM gateway falls back to Bedrock on
-* Anthropic 5xx, plus any wizard metadata/flags.
+* Build env for the SDK subprocess: process.env plus ANTHROPIC_CUSTOM_HEADERS.
+* The header shape follows the gateway edition. Legacy (Python gateway):
+* per-key `X-POSTHOG-PROPERTY-*`/`X-POSTHOG-FLAG-*` plus the explicit
+* `x-posthog-use-bedrock-fallback` opt-in. v2 (Go ai-gateway): one
+* `X-PostHog-Properties` JSON blob. Bedrock fallback is native there, and
+* per-key metadata headers are not read.
 */
-function buildAgentEnv(wizardMetadata, wizardFlags) {
+function buildAgentEnv(wizardMetadata, wizardFlags, auth) {
 	const headers = createCustomHeaders();
-	headers.add("x-posthog-use-bedrock-fallback", "true");
-	for (const [key, value] of Object.entries(wizardMetadata)) headers.add(key.startsWith("X-POSTHOG-PROPERTY-") ? key : `${POSTHOG_PROPERTY_HEADER_PREFIX}${key}`, value);
-	for (const [flagKey, variant] of Object.entries(wizardFlags)) {
-		if (!flagKey.toLowerCase().startsWith("wizard")) continue;
-		headers.addFlag(flagKey, variant);
+	if (auth?.edition === "v2") headers.add("X-PostHog-Properties", buildWizardPropertiesBlob(wizardMetadata, wizardFlags, auth.teamId));
+	else {
+		headers.add("x-posthog-use-bedrock-fallback", "true");
+		for (const [key, value] of Object.entries(wizardMetadata)) headers.add(key.startsWith("X-POSTHOG-PROPERTY-") ? key : `${POSTHOG_PROPERTY_HEADER_PREFIX}${key}`, value);
+		for (const [flagKey, variant] of Object.entries(wizardFlags)) {
+			if (!flagKey.toLowerCase().startsWith("wizard")) continue;
+			headers.addFlag(flagKey, variant);
+		}
 	}
 	const encoded = headers.encode();
 	logToFile("ANTHROPIC_CUSTOM_HEADERS", encoded);
@@ -2879,13 +3124,17 @@ async function initializeAgent(config, options) {
 	logToFile("Install directory:", options.installDir);
 	try {
 		process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS = "true";
-		const gatewayUrl = config.host.gatewayUrl;
+		const auth = await gatewayAuth(config.host, config.posthogApiKey, config.programId);
+		const gatewayUrl = auth.gatewayUrl;
 		process.env.ANTHROPIC_BASE_URL = gatewayUrl;
-		process.env.ANTHROPIC_AUTH_TOKEN = config.posthogApiKey;
-		process.env.CLAUDE_CODE_OAUTH_TOKEN = config.posthogApiKey;
+		process.env.ANTHROPIC_AUTH_TOKEN = auth.token;
+		process.env.CLAUDE_CODE_OAUTH_TOKEN = auth.token;
+		logToFile("Gateway edition:", auth.edition);
 		const triageProvider = createTriageLLMProvider({
 			baseURL: gatewayUrl,
-			authToken: config.posthogApiKey,
+			authToken: auth.token,
+			edition: auth.edition,
+			teamId: auth.teamId,
 			wizardMetadata: {
 				...config.wizardMetadata ?? {},
 				call_type: "yara-triage"
@@ -2942,6 +3191,7 @@ async function initializeAgent(config, options) {
 			suppressTaskRender: !!config.orchestrator,
 			capture: config.capture,
 			triageProvider,
+			gatewayAuth: auth,
 			program: config.integrationLabel,
 			sequence: config.orchestrator ? "orchestrator" : "linear"
 		};
@@ -3115,13 +3365,13 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 				},
 				env: {
 					...sanitizeAgentSubprocessEnv(process.env),
-					ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL,
-					ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN,
-					CLAUDE_CODE_OAUTH_TOKEN: process.env.CLAUDE_CODE_OAUTH_TOKEN,
+					ANTHROPIC_BASE_URL: agentConfig.gatewayAuth.gatewayUrl,
+					ANTHROPIC_AUTH_TOKEN: agentConfig.gatewayAuth.token,
+					CLAUDE_CODE_OAUTH_TOKEN: agentConfig.gatewayAuth.token,
 					CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "true",
 					POSTHOG_MCP_TOKEN: agentConfig.posthogApiKey,
 					MCP_CONNECTION_NONBLOCKING: "0",
-					ANTHROPIC_CUSTOM_HEADERS: buildAgentEnv(agentConfig.wizardMetadata ?? {}, agentConfig.wizardFlags ?? {})
+					ANTHROPIC_CUSTOM_HEADERS: buildAgentEnv(agentConfig.wizardMetadata ?? {}, agentConfig.wizardFlags ?? {}, agentConfig.gatewayAuth)
 				},
 				canUseTool: (toolName, input) => {
 					logToFile("canUseTool called:", {
@@ -3200,7 +3450,7 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 			if (message.type === "assistant" && signals.hasApiErrorStatus(401)) {
 				signalDone();
 				spinner.stop("Authentication failed");
-				const authError = buildAuthErrorContext(options.installDir, process.env.ANTHROPIC_BASE_URL ?? "", os.homedir(), signals.apiKeySource);
+				const authError = buildAuthErrorContext(options.installDir, agentConfig.gatewayAuth.gatewayUrl, os.homedir(), signals.apiKeySource);
 				const authCode = classifyAuthFailure({
 					hasSettingsConflict: authError.hasSettingsConflict,
 					usingManagedLogin: authError.usingManagedLogin,
@@ -3572,6 +3822,6 @@ function handleSDKMessage(message, options, spinner, signals, receivedSuccessRes
 	}
 }
 //#endregion
-export { installSkillById as A, isEnvFileName as B, WIZARD_ASK_SUBJECT_DESCRIPTION as C, createAskAccounting as D, checkEnvKeys as E, vaultSensitiveAnswers as F, buildGatewayProvider as G, toPromptSafeRelativePath as H, fetchWithRetry as I, createWizardAskBridge as L, resolveEnvPath as M, resolveEnvSecretRefs as N, downloadSkill as O, templateEnvWriteRefusal as P, isFullyCancelled as R, WIZARD_ASK_SENSITIVE_DESCRIPTION as S, WIZARD_TOOL_NAMES as T, createTriageLLMProvider as U, parseEnvKeyNames as V, GATEWAY_PROVIDER as W, PUBLISH_HANDOFF_TOOL_NAME as _, wizardCanUseTool as a, CHECK_ENV_KEYS_FILE_PATH_DESCRIPTION as b, classifySettingsConflicts as c, sanitizeAgentSubprocessEnv as d, AgentOutputSignals as f, PUBLISH_HANDOFF_DESCRIPTION as g, PUBLISH_HANDOFF_CONTENT_DESCRIPTION as h, runAgent as i, mergeEnvValues as j, fetchSkillMenu as k, recoverOrphanedSettingsBackups as l, createSecretVault as m, buildRunTags as n, backupAndFixClaudeSettings as o, assembleCommandments as p, initializeAgent as r, checkAllSettingsConflicts as s, buildAgentEnv as t, restoreClaudeSettings as u, publishHandoff as v, WIZARD_ASK_TOOL_DESCRIPTION as w, ENV_FILE_PATH_DESCRIPTION as x, CHECK_ENV_KEYS_DESCRIPTION as y, MAX_ENV_KEY_SET as z };
+export { installSkillById as A, MAX_ENV_KEY_SET as B, WIZARD_ASK_SUBJECT_DESCRIPTION as C, createAskAccounting as D, checkEnvKeys as E, templateEnvWriteRefusal as F, GATEWAY_PROVIDER as G, parseEnvKeyNames as H, vaultSensitiveAnswers as I, buildGatewayProvider as K, fetchWithRetry as L, normaliseAskSubject as M, resolveEnvPath as N, downloadSkill as O, resolveEnvSecretRefs as P, createWizardAskBridge as R, WIZARD_ASK_SENSITIVE_DESCRIPTION as S, WIZARD_TOOL_NAMES as T, toPromptSafeRelativePath as U, isEnvFileName as V, createTriageLLMProvider as W, PUBLISH_HANDOFF_TOOL_NAME as _, wizardCanUseTool as a, CHECK_ENV_KEYS_FILE_PATH_DESCRIPTION as b, classifySettingsConflicts as c, sanitizeAgentSubprocessEnv as d, AgentOutputSignals as f, PUBLISH_HANDOFF_DESCRIPTION as g, PUBLISH_HANDOFF_CONTENT_DESCRIPTION as h, runAgent as i, mergeEnvValues as j, fetchSkillMenu as k, recoverOrphanedSettingsBackups as l, createSecretVault as m, buildRunTags as n, backupAndFixClaudeSettings as o, assembleCommandments as p, gatewayAuth as q, initializeAgent as r, checkAllSettingsConflicts as s, buildAgentEnv as t, restoreClaudeSettings as u, publishHandoff as v, WIZARD_ASK_TOOL_DESCRIPTION as w, ENV_FILE_PATH_DESCRIPTION as x, CHECK_ENV_KEYS_DESCRIPTION as y, isFullyCancelled as z };
 
-//# sourceMappingURL=agent-interface-tM_b0l__.js.map
+//# sourceMappingURL=agent-interface-CI89BrWE.js.map