@edgehero/pi-dispatch 4.3.0 → 5.0.0

package/src/model-ref.mjs

@@ -31,8 +31,39 @@ export const MODEL_REF_PATTERN = /^(?=.{1,64}$)[~@]?[a-z0-9][a-z0-9._:/@_-]*$/;
  * never be listed. Applied after lowercasing, like `MODEL_REF_PATTERN`.
  */
 export const PROVIDER_REF_PATTERN = /^(?=.{1,64}$)[a-z0-9][a-z0-9._-]*$/;
+/** What a model id may be, in words: the sentence every source's refusal ends with. */
+const MODEL_ID_SHAPE = "a model id of 1 to 64 characters: letters, digits and . _ - : / @, starting with a letter or digit (or ~ or @ then one)";
+/** What a provider id may be, in words. */
+const PROVIDER_ID_SHAPE = "a provider id of 1 to 64 characters: letters, digits, dot, dash and underscore, starting with a letter or digit";
+
 /**
- * Validate the optional `run.provider`, `run.model`, `run.maxTurns` and `run.models` of one trigger (issue #502) and return
+ * Is `value` a model id a record may carry (issue #673)? Null when it is, else the shape it must have, as a
+ * sentence ("must be a model id of ..."). ONE rule for every source of a job's model: a trigger's `run.model`
+ * (`validateModelRef`), `PI_MODEL` (`loadConfig`), the settings overlay's `model` (`validateOverlay`) and
+ * `pi-dispatch run --model`. Held to one rule because the run record writes whichever of them won, and the
+ * console's runs filter (`RUN_MODEL_RE`, admin) accepts exactly the ids this rule does and more, so a run on a model
+ * the worker accepted is always one the console can find.
+ *
+ * ASCII is checked on the ORIGINAL before lowercasing, because lowercasing is not closed over ASCII: the Kelvin
+ * sign (U+212A) lowercases to a plain `k`, so a lowercase-then-match check alone would pass a homoglyph that then
+ * reaches the job verbatim and names a model nobody listed. Only the CHECK lowercases: the caller keeps the
+ * original case, because pi resolves model ids exactly and case-sensitively, and the pinned catalog holds
+ * uppercase ids. The sentence never carries the value.
+ */
+export function modelIdProblem(value) {
+	if (typeof value === "string" && value.startsWith("role:") && !/^role:[a-z][a-z0-9_-]{0,31}$/.test(value)) return "must name role:<lowercase-role>, with a role of 1 to 32 letters, digits, underscores or dashes";
+	if (typeof value !== "string" || !/^[\x21-\x7E]+$/.test(value) || !MODEL_REF_PATTERN.test(value.toLowerCase())) return `must be ${MODEL_ID_SHAPE}`;
+	return null;
+}
+
+/** `modelIdProblem` for a provider id (issue #673), against `PROVIDER_REF_PATTERN`, by the same rule. */
+export function providerIdProblem(value) {
+	if (typeof value !== "string" || !/^[\x21-\x7E]+$/.test(value) || !PROVIDER_REF_PATTERN.test(value.toLowerCase())) return `must be ${PROVIDER_ID_SHAPE}`;
+	return null;
+}
+
+/**
+ * Validate the optional `run.provider`, `run.model`, `run.maxTurns`, `run.models` and `run.fallbackModels` of one trigger (issue #502) and return
  * the fields that were present, so a normalizer can spread them and an absent field stays absent. Shared by
  * the trigger loader and the console, so both refuse with the same words.
  *
@@ -48,24 +79,24 @@ export function validateModelRef(run, at, path) {
 	// import-free: run-history.mjs imports it too, and must not drag config.mjs's fs and os in with it.
 	const configError = (message) => Object.assign(new Error(message), { piDispatchConfig: true });
 	const out = {};
-	// ASCII is checked on the ORIGINAL before lowercasing, because lowercasing is not closed over ASCII:
-	// the Kelvin sign (U+212A) lowercases to a plain `k`, so a lowercase-then-match check alone would pass
-	// a homoglyph that then reaches the job verbatim and names a model nobody listed.
-	const ascii = (value) => /^[\x21-\x7E]+$/.test(value);
+	// The shape checks (ASCII on the original, then the pattern on the lowercased value) are `providerIdProblem`
+	// and `modelIdProblem`, shared with PI_MODEL, PI_PROVIDER, the settings overlay and `pi-dispatch run` (#673).
 	// NULL IS ABSENT, for all three. Before #502 a hand-written cron entry's `"model": null` loaded and
 	// meant the deployment default (the worker fills `job.data ?? overlay ?? env`, and `??` passes over
 	// null), so refusing it now would turn a working file into one that refuses to load for no gain.
 	if (run?.provider != null) {
 		const provider = run.provider;
-		if (typeof provider !== "string" || !ascii(provider) || !PROVIDER_REF_PATTERN.test(provider.toLowerCase())) {
-			throw configError(`${at}: run.provider must be a provider id of 1 to 64 characters: letters, digits, dot, dash and underscore, starting with a letter or digit: ${path}`);
+		const problem = providerIdProblem(provider);
+		if (problem !== null) {
+			throw configError(`${at}: run.provider ${problem}: ${path}`);
 		}
 		out.provider = provider;
 	}
 	if (run?.model != null) {
 		const model = run.model;
-		if (typeof model !== "string" || !ascii(model) || !MODEL_REF_PATTERN.test(model.toLowerCase())) {
-			throw configError(`${at}: run.model must be a model id of 1 to 64 characters: letters, digits and . _ - : / @, starting with a letter or digit (or ~ or @ then one): ${path}`);
+		const problem = modelIdProblem(model);
+		if (problem !== null) {
+			throw configError(`${at}: run.model ${problem}: ${path}`);
 		}
 		out.model = model;
 	}
@@ -82,14 +113,40 @@ export function validateModelRef(run, at, path) {
 		// The main model must be on its own list, refused HERE when the trigger names all three, because the
 		// file alone answers it. When the provider or the model comes from the deployment default instead,
 		// the worker answers it at job start (`model-not-allowed`, pre-spend).
-		if (out.provider !== undefined && out.model !== undefined && !modelOnList(run.models, out.provider, out.model)) {
+		if (out.provider !== undefined && out.model !== undefined && !out.model.startsWith("role:") && !modelOnList(run.models, out.provider, out.model)) {
 			throw configError(`${at}: run.models does not list this trigger's own run.provider/run.model, so every job it starts would be refused: ${path}`);
 		}
 		out.models = [...run.models];
 	}
+	// Fallbacks are operator-reviewed candidates, never an implicit widening of the allowed list.
+	// The deployment list is checked at pickup when this pure loader cannot see it.
+	if (run?.fallbackModels != null) {
+		const problem = modelListProblem(run.fallbackModels);
+		if (problem !== null) throw configError(`${at}: run.fallbackModels ${problem}: ${path}`);
+		for (const entry of run.fallbackModels) {
+			const ref = splitModelEntry(entry);
+			if (out.models !== undefined && !modelOnList(out.models, ref.provider, ref.model)) {
+				throw configError(`${at}: run.models does not list a run.fallbackModels entry: ${path}`);
+			}
+		}
+		out.fallbackModels = [...run.fallbackModels];
+	}
 	return out;
 }
 
+/**
+ * Whether a job's fallbacks can be tried at all: each must be on its allowed list, the trigger's or else the deployment's, and
+ * with no list none is. Without this a job with fallbacks is refused as `model-failover-no-candidate`, before it spends. One
+ * rule for the failover's selection and the console's preview.
+ */
+export function failoverListUsable(job) {
+	if (modelListProblem(job?.fallbackModels) !== null || modelListProblem(job?.models) !== null) return false;
+	return job.fallbackModels.every((ref) => {
+		const split = splitModelEntry(ref);
+		return split !== null && modelOnList(job.models, split.provider, split.model);
+	});
+}
+
 /** The most entries an allowed-model list may carry (issue #502). Past this a list is a catalog, not a policy. */
 export const MAX_ALLOWED_MODELS = 16;
 

package/src/model-roles-file.mjs

@@ -0,0 +1,24 @@
+import * as nodeFs from "node:fs";
+import { parseTriggersDocument } from "./triggers.mjs";
+
+/** Same live/last-good posture as project bundles. A broken first read cannot silently remove model policy. */
+export function makeReadModelRoles({ triggersPath, fs = nodeFs, log = () => {} }) {
+	let last = null;
+	let failed = false;
+	return () => {
+		if (!triggersPath) return {};
+		try {
+			const text = fs.readFileSync(triggersPath, "utf8");
+			last = parseTriggersDocument(text, triggersPath).modelRoles;
+			failed = false;
+			return last;
+		} catch (error) {
+			if (error?.code === "ENOENT" && last === null) return {};
+			if (!failed) log("model_roles_last_good", { kept: last !== null });
+			failed = true;
+			if (last !== null) return last;
+			if (error?.piDispatchConfig === true) throw Object.assign(new Error("the model roles file is invalid and no validated snapshot exists"), { piDispatchConfig: true, modelSelectionReason: "model-roles-invalid" });
+			throw new Error("modelRoles could not be read and no validated snapshot exists");
+		}
+	};
+}

package/src/model-roles.mjs

@@ -0,0 +1,73 @@
+import { modelListProblem, splitModelEntry } from "./model-ref.mjs";
+import { isProjectId } from "./project-id.mjs";
+
+export const MODEL_ROLE_RE = /^[a-z][a-z0-9_-]{0,31}$/;
+const object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const scopeOf = (roles, id) => object(roles) && typeof id === "string" && Object.hasOwn(roles, id) ? roles[id] : {};
+const failure = (reason, message) => Object.assign(new Error(message), { piDispatchConfig: true, modelSelectionReason: reason });
+
+/** A misspelt policy block must refuse rather than silently removing the reviewed ceiling. */
+export function isModelRolesField(key) {
+	const text = String(key);
+	const normalized = text.normalize("NFKC").replace(/[^a-z]/gi, "").toLowerCase();
+	if (["modelroles", "modelrole"].includes(normalized)) return true;
+	if (/^[\x20-\x7E]*$/.test(text) || normalized.length < 4) return false;
+	let cursor = 0;
+	for (const letter of "modelroles") if (normalized[cursor] === letter) cursor++;
+	return cursor === normalized.length;
+}
+
+/** Reviewed policy, never job data. Bounded maps keep the effective allowlist a policy rather than a catalog. */
+export function validateModelRoles(value) {
+	if (value === undefined) return {};
+	const bad = () => { throw failure("model-roles-invalid", "modelRoles must map default/project ids to at most 16 roles, each a provider/model or {model, fallbackModels}"); };
+	if (!object(value) || Object.keys(value).length > 128) bad();
+	const out = {};
+	for (const [project, roles] of Object.entries(value)) {
+		if (!isProjectId(project) || !object(roles) || Object.keys(roles).length > 16) bad();
+		const row = {};
+		for (const [role, entry] of Object.entries(roles)) {
+			if (!MODEL_ROLE_RE.test(role) || ["inherit", "constructor", "prototype"].includes(role)) bad();
+			const ref = typeof entry === "string" ? entry : entry?.model;
+			if (!splitModelEntry(ref) || splitModelEntry(ref).model.startsWith("role:")) bad();
+			if (typeof entry === "string") row[role] = entry;
+			else {
+				if (!object(entry) || Object.keys(entry).some((k) => !["model", "fallbackModels"].includes(k))) bad();
+				if (entry.fallbackModels !== undefined && modelListProblem(entry.fallbackModels) !== null) bad();
+				row[role] = { model: ref, ...(entry.fallbackModels !== undefined ? { fallbackModels: [...entry.fallbackModels] } : {}) };
+			}
+		}
+		out[project] = row;
+	}
+	return out;
+}
+
+export function roleMapFor(roles, project = null) {
+	const entries = { ...scopeOf(roles, "default"), ...(project && project !== "default" ? scopeOf(roles, project) : {}) };
+	return Object.fromEntries(Object.entries(entries).map(([role, entry]) => [role, typeof entry === "string" ? entry : entry.model]));
+}
+
+/** One snapshot is used for admission, endpoint slots and the runner. Failover may narrow it afterwards. */
+export function resolveModelRoles(job, roles, project = null, { authoredProvider = undefined } = {}) {
+	// A receiver or an old queued delivery cannot carry authority over the live map.
+	const { modelRoles: _queuedMap, modelRole: _queuedRole, ...authored } = job;
+	job = authored;
+	const map = roleMapFor(roles, project);
+	const requested = typeof job.model === "string" && job.model.startsWith("role:") ? job.model.slice(5) : null;
+	if (requested !== null && (!MODEL_ROLE_RE.test(requested) || !Object.hasOwn(map, requested))) throw failure("model-role-unknown", "the requested model role is not declared in modelRoles");
+	if (requested === null && Object.keys(map).length === 0) return job;
+	let resolved = { ...job };
+	if (requested !== null) {
+		const ref = splitModelEntry(map[requested]);
+		if (authoredProvider !== undefined && authoredProvider !== null && authoredProvider !== ref.provider) throw failure("model-role-provider-conflict", "run.provider conflicts with its model role provider");
+		const entry = scopeOf(roles, project)[requested] ?? scopeOf(roles, "default")[requested];
+		resolved = { ...resolved, ...ref, modelRole: requested };
+		if (job.fallbackModels !== undefined && typeof entry !== "string" && entry.fallbackModels !== undefined) throw failure("model-roles-invalid", "declare fallbackModels on the role or the trigger, not both");
+		if (typeof entry !== "string" && entry.fallbackModels !== undefined) resolved.fallbackModels = [...entry.fallbackModels];
+	}
+	const refs = [...(job.models ?? [`${resolved.provider}/${resolved.model}`]), ...Object.values(map)];
+	for (const entry of Object.values({ ...scopeOf(roles, "default"), ...(project && project !== "default" ? scopeOf(roles, project) : {}) })) if (typeof entry !== "string") refs.push(...(entry.fallbackModels ?? []));
+	const models = [...new Set(refs)];
+	if (modelListProblem(models) !== null) throw failure("model-roles-invalid", "the role-expanded allowed-model list is invalid or exceeds 16 models");
+	return { ...resolved, models, modelRoles: map };
+}

package/src/model-status.mjs

@@ -0,0 +1,34 @@
+/** The failover price verdict shared with operator displays. Looking never reserves or calls a provider. */
+import { builtinChatModels, builtinModel, checkModelsKnown } from "./model-catalog.mjs";
+import { modelEntryOf } from "./model-endpoints.mjs";
+import { splitModelEntry } from "./model-ref.mjs";
+import { outputCapView, outputUnboundable } from "./output-cap.mjs";
+
+// This copy is pinned to the runner's PRICED_APIS by model-failover.test.mjs. The published worker cannot import
+// the image workspace, and a new runner API must not silently become eligible before its free bound is verified.
+export const FAILOVER_PRICED_APIS = Object.freeze(["anthropic-messages", "azure-openai-responses", "bedrock-converse-stream", "cloudflare-workers-ai-system-one", "google-generative-ai", "google-vertex", "mistral-conversations", "openai-codex-responses", "openai-completions", "openai-decisions", "openai-responses", "typesafe-system-one"]);
+/** Catalog/overlay composition is shared with the existing output-cap gate, rather than guessed from a URL or id. */
+export function failoverModelView(ref, { models = null, lookup = builtinModel } = {}) {
+	const split = splitModelEntry(ref);
+	if (!split) return null;
+	const { provider, model } = split;
+	const view = outputCapView({ models, provider, modelId: model, builtinModel: lookup, builtinChatModels });
+	const { defined, override } = modelEntryOf(models, provider, model);
+	// pi provider-composer.js modelFromJson defaults, held to the pinned artifact by the test.
+	const base = defined ? { ...defined, contextWindow: defined.contextWindow ?? 128000, maxTokens: defined.maxTokens ?? 16384 } : lookup(provider, model);
+	return view ? { ...view, contextWindow: override?.contextWindow ?? base?.contextWindow, maxTokens: override?.maxTokens ?? base?.maxTokens } : null;
+}
+
+export function failoverPriceEligible(view) {
+	return Boolean(view && FAILOVER_PRICED_APIS.includes(view.api) && !outputUnboundable(view) && Number.isFinite(view.maxTokens) && view.maxTokens > 0 && ["input", "output", "cacheRead", "cacheWrite"].every((key) => Number.isFinite(view.cost?.[key]) && view.cost[key] >= 0));
+}
+
+export function failoverModelStatus(ref, { models = null, lookup = builtinModel } = {}) {
+	const split = splitModelEntry(ref);
+	if (!split) return { known: false, priced: false, reason: "model-unknown", api: null };
+	const refs = [{ provider: split.provider, id: split.model, main: true }, { provider: split.provider, id: split.model }];
+	const known = checkModelsKnown(refs, { readOverlay: () => models });
+	const view = failoverModelView(ref, { models, lookup });
+	const reason = known.unknown || known.unavailable ? "model-unknown" : known.fallbackUnlisted ? "model-not-allowed" : !failoverPriceEligible(view) ? "model-unpriced" : null;
+	return { known: !known.unknown && !known.unavailable, priced: reason === null, reason, api: typeof view?.api === "string" ? view.api : null };
+}

package/src/models-json.mjs

@@ -163,7 +163,7 @@ const posInt = T.int({ minimum: 1 });
 const ImageResize = T.obj({ maxWidth: opt(posInt), maxHeight: opt(posInt), maxBytes: opt(posInt), jpegQuality: opt(T.int({ minimum: 1, maximum: 100 })) });
 const ModelInputLimits = T.obj({ maxRequestBytes: opt(posInt), images: opt(T.obj({ resize: opt(ImageResize), maxPerMessage: opt(posInt), maxPerRequest: opt(posInt) })) });
 // compat-schema.js's ProviderCompatSchema: the merged properties of the OpenAI completions, OpenAI responses, Anthropic
-// messages, Bedrock and Mistral schemas. A key two of them share takes pi's generic override, which for every shared
+// messages, Bedrock, Mistral and System One schemas. A key two of them share takes pi's generic override, which for every shared
 // key here is the same type as each api's own (a boolean, or the three-way affinity format), so the superset is exact.
 const bool = opt(T.bool());
 const ProviderCompat = T.obj({
@@ -209,6 +209,9 @@ const ProviderCompat = T.obj({
 	supportsStrictTools: bool,
 	supportsMidConvoEffort: bool,
 	supportsMidConvoToolChanges: bool,
+	// System One classifier image transport, checked before pi reads the overlay.
+	imageInput: opt(T.union(T.lit("assets"), T.lit("images"), T.lit("state-image-urls"))),
+	sendImageOptInHeader: bool,
 	allowedFallbackModels: opt(T.arr(T.obj({ provider: req(T.str({ minLength: 1 })), model: req(T.str({ minLength: 1 })), cost: req(ModelCost) }), { maxItems: 3 })),
 });
 const nonEmpty = T.str({ minLength: 1 });

package/src/money.mjs

@@ -75,7 +75,7 @@ export function optionalUsdMicros(value, key) {
 
 /**
  * Integer micro-dollars as a plain dollar decimal, at least two decimals and no trailing zeros past them:
- * 2500000 is "2.50", 1 is "0.000001". For messages and displays; never parsed back by anything that enforces.
+ * 2500000 is "2.50", 1 is "0.000001". For messages, displays and exact managed-fork cap serialization; no floating-point conversion is needed.
  */
 export function formatMicros(micros) {
 	if (!Number.isSafeInteger(micros) || micros < 0) throw new TypeError("formatMicros: want a non-negative safe integer");

package/src/oauth-openai.mjs

@@ -0,0 +1,121 @@
+/** Official ChatGPT direct OAuth. Registration identity and renewal secrets stay on the owner host. */
+import { randomBytes, createHash } from "node:crypto";
+import { createServer } from "node:http";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { authError, validOpenAIAccessToken } from "./auth-store.mjs";
+import { readAuthJson } from "./community-auth-helper.mjs";
+
+const ISSUER = "https://auth.openai.com";
+const RESOURCE = "https://api.openai.com/v1";
+export const OPENAI_REDIRECT_URI = "http://127.0.0.1:1455/auth/callback";
+export const OPENAI_LOGIN_INSTRUCTIONS = `For sign-in from another machine, forward port 1455 to 127.0.0.1:1455 on this host, or paste the final ${OPENAI_REDIRECT_URI} URL into this terminal.`;
+const SCOPES = "openid profile email offline_access resource.invoke chatgpt.tokens.use.direct";
+const TERMINAL = new Set(["invalid_grant", "invalid_refresh_token", "token_expired", "refresh_token_expired", "refresh_token_invalidated", "refresh_token_reused"]);
+export const PINNED_OPENAI_OAUTH_SHA256 = "4cf9fc758a07ffe4ee022326404b5dcc86767ee4154945c0417c7f95eaecdcc2";
+export function verifyPinnedOpenAIOAuth({ resolve = import.meta.resolve, readFile = readFileSync } = {}) {
+	const path = fileURLToPath(new URL("../auth/oauth/openai-chatgpt.js", resolve("@earendil-works/pi-ai/providers/openai")));
+	if (createHash("sha256").update(readFile(path)).digest("hex") !== PINNED_OPENAI_OAUTH_SHA256) throw authError("auth-adapter-source-mismatch");
+	return true;
+}
+export function parseOpenAIToken(data, { now, previous = null } = {}) {
+	if (!data || !validOpenAIAccessToken(data.access_token) || typeof data.refresh_token !== "string" || !data.refresh_token || !Number.isFinite(data.expires_in) || data.expires_in <= 0 || data.expires_in > 31 * 24 * 3600 || typeof data.scope !== "string") throw authError("auth-response-invalid", { uncertain: true });
+	const scopes = data.scope.split(/\s+/).filter(Boolean);
+	if (!scopes.includes("chatgpt.tokens.use.direct")) throw authError("auth-permission-missing");
+	const earliest = data.earliest_refresh_at;
+	const earliestRefreshAt = typeof earliest === "number" && Number.isFinite(earliest) ? Math.ceil(earliest < 1e12 ? earliest * 1000 : earliest) : typeof earliest === "string" && Number.isFinite(Date.parse(earliest)) ? Date.parse(earliest) : null;
+	return { type: "oauth", access: data.access_token, refresh: data.refresh_token, expires: Math.floor(now() + data.expires_in * 1000), scopes, ...(earliestRefreshAt === null ? {} : { earliestRefreshAt }) };
+}
+
+export async function verifyOpenAIIdentity({ token, clientId, nonce, fetch = globalThis.fetch, now = () => Date.now(), verify = null }) {
+	let claims;
+	try {
+		if (verify) claims = await verify({ token, clientId, nonce, issuer: ISSUER });
+		else {
+			const { createRemoteJWKSet, jwtVerify, customFetch } = await import("jose");
+			const response = await fetch(`${ISSUER}/.well-known/openid-configuration`, { signal: AbortSignal.timeout(15_000) });
+			if (!response.ok) throw new Error();
+			const discovery = await readAuthJson(response);
+			if (discovery.issuer !== ISSUER || typeof discovery.jwks_uri !== "string" || new URL(discovery.jwks_uri).origin !== ISSUER) throw new Error();
+			const jwks = createRemoteJWKSet(new URL(discovery.jwks_uri), { [customFetch]: fetch });
+			claims = (await jwtVerify(token, jwks, { issuer: ISSUER, audience: clientId, currentDate: new Date(now()), clockTolerance: 30, algorithms: ["RS256", "ES256"] })).payload;
+		}
+		if (typeof claims?.sub !== "string" || !claims.sub || claims.sub.length > 512 || claims.nonce !== nonce || claims.iss !== ISSUER || !(claims.aud === clientId || Array.isArray(claims.aud) && claims.aud.includes(clientId)) || !Number.isFinite(claims.exp) || claims.exp * 1000 <= now()) throw new Error();
+		return { subject: claims.sub };
+	} catch { throw authError("auth-identity-invalid"); }
+}
+
+export async function authorizationCallback({ url, state, interaction, signal, serverFactory = createServer }) {
+	signal?.throwIfAborted();
+	const manualAbort = new AbortController();
+	let resolveCallback;
+	const callback = new Promise((resolve) => { resolveCallback = resolve; });
+	const valid = (received) => received?.origin === new URL(OPENAI_REDIRECT_URI).origin && received.pathname === "/auth/callback" && received.searchParams.getAll("state").length === 1 && received.searchParams.get("state") === state && received.searchParams.getAll("code").length === 1 && Boolean(received.searchParams.get("code"));
+	const server = serverFactory((request, response) => {
+		let received;
+		try { received = new URL(request.url, OPENAI_REDIRECT_URI); } catch { /* Invalid input cannot end the pending sign-in. */ }
+		if (!valid(received)) { response.writeHead(400); response.end("Invalid authorization callback"); return; }
+		response.writeHead(200, { "Content-Type": "text/plain", "Cache-Control": "no-store" }); response.end("Sign-in complete. Return to pi-dispatch.");
+		resolveCallback(received);
+	});
+	const abort = () => resolveCallback(null);
+	signal?.addEventListener("abort", abort, { once: true });
+	try {
+		await new Promise((resolve) => { server.once("error", resolve); server.listen(1455, "127.0.0.1", resolve); });
+		interaction.notify({ type: "auth_url", url, instructions: OPENAI_LOGIN_INSTRUCTIONS });
+		const manual = Promise.resolve(interaction.prompt({ type: "manual_code", message: "Paste the final callback URL", signal: AbortSignal.any([manualAbort.signal, ...(signal ? [signal] : [])]) })).then((value) => { try { return new URL(value); } catch { throw authError("auth-callback-invalid"); } });
+		const received = await Promise.race([callback, manual]);
+		signal?.throwIfAborted();
+		if (!valid(received)) throw authError("auth-callback-invalid");
+		return received;
+	} finally { manualAbort.abort(); signal?.removeEventListener("abort", abort); server.closeAllConnections?.(); if (server.listening) await new Promise((resolve) => server.close(resolve)); }
+}
+
+export function createOpenAIAuthAdapter({ fetch = globalThis.fetch, now = () => Date.now(), verifyIdentity = verifyOpenAIIdentity, callback = authorizationCallback } = {}) {
+	async function tokenRequest(body, signal) {
+		let response;
+		try { response = await fetch(`${ISSUER}/api/accounts/oauth/token`, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(body), signal: AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(15_000)]) }); }
+		catch { throw authError("auth-network-unavailable", { transient: true, uncertain: true }); }
+		const data = await readAuthJson(response);
+		if (!response.ok) {
+			const code = typeof data?.error === "string" ? data.error : data?.error?.code;
+			if (TERMINAL.has(code)) throw authError("auth-reauth-required");
+			if (code === "invalid_client") throw authError("auth-client-invalid");
+			throw authError("auth-provider-refused", { transient: response.status === 429 || response.status >= 500 });
+		}
+		return data;
+	}
+	return {
+		async validate() { verifyPinnedOpenAIOAuth(); },
+		async login({ interaction, signal, previous }) {
+			if (typeof interaction?.prompt !== "function" || typeof interaction?.notify !== "function") throw authError("auth-interaction-required");
+			const verifier = randomBytes(32).toString("base64url");
+			const state = randomBytes(32).toString("base64url");
+			const nonce = randomBytes(32).toString("base64url");
+			const hostId = previous.registration.hostId;
+			const savedClient = previous.registration.clientId;
+			const url = new URL(`${ISSUER}/oauth/authorize`);
+			url.search = new URLSearchParams({ client_id: savedClient ?? "dynamic_agent_client", ...(savedClient ? {} : { agent_name_hint: "pi-dispatch" }), ext_agent_host_id: `urn:uuid:${hostId}`, response_type: "code", redirect_uri: OPENAI_REDIRECT_URI, resource: RESOURCE, scope: SCOPES, state, nonce, code_challenge: createHash("sha256").update(verifier).digest("base64url"), code_challenge_method: "S256" }).toString();
+			const returned = await callback({ url: url.toString(), state, interaction, signal });
+			const clientId = savedClient ?? returned.searchParams.get("client_id");
+			if (typeof clientId !== "string" || !clientId || clientId.length > 1024) throw authError("auth-client-invalid");
+			const data = await tokenRequest({ grant_type: "authorization_code", client_id: clientId, code: returned.searchParams.get("code"), code_verifier: verifier, redirect_uri: OPENAI_REDIRECT_URI, resource: RESOURCE }, signal);
+			const identity = await verifyIdentity({ token: data.id_token, clientId, nonce, fetch, now });
+			if (previous.registration.subject && previous.registration.subject !== identity.subject) throw authError("auth-account-changed");
+			return { credential: { ...parseOpenAIToken(data, { now }), clientId }, registration: { hostId, clientId, subject: identity.subject } };
+		},
+		async refresh({ credential, signal }) {
+			if (credential.earliestRefreshAt > now()) throw authError("auth-refresh-too-early", { transient: true });
+			if (typeof credential.clientId !== "string" || !credential.clientId) throw authError("auth-client-invalid");
+			return { ...parseOpenAIToken(await tokenRequest({ grant_type: "refresh_token", client_id: credential.clientId, refresh_token: credential.refresh, resource: RESOURCE }, signal), { now, previous: credential }), clientId: credential.clientId };
+		},
+		async revoke({ credential, signal }) {
+			const discovery = await fetch(`${ISSUER}/.well-known/openid-configuration`, { signal });
+			if (!discovery.ok) throw authError("auth-revocation-unconfirmed");
+			const config = await readAuthJson(discovery);
+			if (typeof config.revocation_endpoint !== "string" || new URL(config.revocation_endpoint).origin !== ISSUER) throw authError("auth-revocation-unconfirmed");
+			const response = await fetch(config.revocation_endpoint, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ token: credential.refresh, token_type_hint: "refresh_token", client_id: credential.clientId }), signal });
+			return { confirmed: response.status === 200 };
+		},
+	};
+}