@yanlinglabs/winter-provider-runtime 0.0.5 → 0.0.6

package/README.md

@@ -61,12 +61,21 @@ not the same as runnable on every path — these exports need the Bun runtime:
 | Function | Import | Needs | Why |
 | --- | --- | --- | --- |
 | `startCodexLogin()` | `@yanlinglabs/winter-provider-runtime` | `Bun.serve` | The authorization-code flow receives the vendor's redirect on `127.0.0.1`, which needs a real HTTP listener. |
-| `startAnthropicConsoleLogin()` | `@yanlinglabs/winter-provider-runtime` | `Bun.serve` | Same flow, same listener. |
 | `startXaiOauthFake()` | `@yanlinglabs/winter-provider-runtime/testing` | `Bun.serve` | Binds a loopback server on `127.0.0.1:0` to stand in for the vendor. |
 | `startXaiChatFake()` | `@yanlinglabs/winter-provider-runtime/testing` | `Bun.serve` | Same. |
-
-(Internally all four go through one `runLoginFlow`/`Bun.serve` seam, which is not on either barrel
-and which a consumer cannot call.)
+| `startAnthropicConsoleBrokerLogin()` | `@yanlinglabs/winter-provider-runtime` | `Bun.spawn` | Spawns Anthropic's own `claude` binary and pipes its stdin/stdout/stderr for the host-brokered Console login (P10a-1 amendment) — never a loopback listener, since this SDK is not itself a party to the OAuth exchange. |
+| `refreshAnthropicBearer()` | `@yanlinglabs/winter-provider-runtime` | `Bun.spawn` | Spawns Anthropic's `ant` binary to mint the native provider's bearer token from the profile the login above wrote. |
+| `logoutAnthropicConsole()` | `@yanlinglabs/winter-provider-runtime` | `Bun.spawn` | Spawns `claude auth logout`. |
+
+(`startCodexLogin()` and the two loopback fakes go through one `runLoginFlow`/`Bun.serve` seam, which
+is not on either barrel and which a consumer cannot call. The Console-broker trio is a SEPARATE
+mechanism — each of the three guards itself directly, with no shared seam, since spawning a
+subprocess and piping its stdio is a different shape from opening a listener.)
+
+**`startAnthropicConsoleLogin()` is RETIRED (P10a-1, 2026-09-13)**: the derived PKCE login it ran —
+re-implementing Claude Code's private OAuth client — was deleted after the platform refused its grant
+for every derivable request shape. Console OAuth is host-brokered now, through the three functions
+above; this SDK must never re-implement the OAuth protocol itself again.
 
 Each throws `BunRequiredError` (exported from both barrels) as its FIRST action — before any network
 call, file write or credential read — naming the function, the Bun API and what to do instead. Catch

package/dist/adapters/anthropic/console-broker.d.ts

@@ -0,0 +1,104 @@
+import type { CredentialStore } from "../../types.js";
+/** `ANTHROPIC_PROFILE`'s default (P10a-2) -- one profile for the login, the official leg, and every `ant` call. */
+export declare const DEFAULT_ANTHROPIC_CONSOLE_PROFILE = "winter";
+/** Config every door in this file shares -- one process env, one profile, one pair of binaries. */
+export interface AnthropicConsoleBrokerOptions {
+    /** The resolved `claude` executable -- the SAME binary the official leg spawns (P9c-1). */
+    claudeExecutable: string;
+    /**
+     * The resolved `ant` executable. Absent means "not installed/resolved" -- `refreshAnthropicBearer`
+     * answers a named, typed failure rather than throwing or leaving a login half-finished.
+     */
+    antExecutable?: string;
+    /** `<home>/runtimes/anthropic-config` (P10a-2). Created by the HOST before this file is ever called; this file only reads and writes inside it, never creates it. */
+    anthropicConfigDir: string;
+    /** P9c-1's own config dir for the official leg's OWN credentials, carried on every spawn alongside `anthropicConfigDir` because a build of `claude` may read either variable. */
+    claudeConfigDir: string;
+    /** `ANTHROPIC_PROFILE`. Defaults to `DEFAULT_ANTHROPIC_CONSOLE_PROFILE`. */
+    profile?: string;
+    /** The Keychain service the bearer material lands in -- `config.keychainService` from the host. */
+    service?: string;
+    /**
+     * Every stdout/stderr line, in the order this file observed them, REDACTED of any URL's query
+     * string before this file ever calls it (R6-F: a progress channel, never material).
+     */
+    onLine?: (line: string) => void;
+    /** Injectable for a fixture: a stub executable under mkdtemp, never the real `claude`/`ant`. */
+    spawn?: typeof Bun.spawn;
+    now?: () => number;
+}
+export interface AnthropicConsoleLoginHandle {
+    /**
+     * Writes `code + "\n"` to the child's stdin and closes it -- exactly what a human types at the
+     * `Paste code here if prompted > ` prompt. Resolves once the write completes, NOT once the login
+     * finishes; await `done` for that. Calling this before the child is ready for input, or more than
+     * once, is a caller error this file does not guard against -- the same trust boundary `openUrl`
+     * callers already hold for every other login in this package.
+     */
+    submitCode(code: string): Promise<void>;
+    /**
+     * Resolves on process exit. A non-zero exit is `{ ok: false, reason }`, the reason being the last
+     * non-empty stderr line this file observed (already redacted) -- never the bare exit code alone,
+     * and never a URL. A ZERO exit is only `{ ok: true, profile }` once `refreshAnthropicBearer` has
+     * ALSO succeeded: an exit-0 login that could not mint a usable bearer is not a login Winter can act
+     * on, so this file does not report success until both steps have.
+     */
+    done: Promise<{
+        ok: true;
+        profile: string;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+}
+/**
+ * Fix round 1, item 3 (MINOR): a TYPED refusal from `submitCode`, rather than a silent no-op or an
+ * untyped throw -- a caller that raced its own timeout against a slow paste, or that mis-drives this
+ * handle from two places, gets something it can `instanceof`-check rather than a message to parse.
+ */
+export type SubmitCodeRefusalReason = "already-submitted" | "not-running";
+export declare class SubmitCodeRefused extends Error {
+    readonly name = "SubmitCodeRefused";
+    readonly reason: SubmitCodeRefusalReason;
+    constructor(reason: SubmitCodeRefusalReason, message: string);
+}
+/**
+ * Starts `claude auth login --console` and returns a handle a host drives interactively: it prints
+ * the authorize URL and a prompt through `onLine`, and the host calls `submitCode` once the operator
+ * has one. See the file banner for what was MEASURED about this shape rather than assumed.
+ *
+ * SYNCHRONOUS RETURN, matching `runGit`'s own precedent for a spawn that can fail before any process
+ * exists: `Bun.spawn` throws SYNCHRONOUSLY on an unresolvable executable (ENOENT), and a function that
+ * only surfaced that inside an async `done` would leave a caller unable to tell "the binary doesn't
+ * exist" from "the login is running" until the first `await`. Here it is instead reflected into an
+ * ALREADY-SETTLED handle: `done` is already resolved `{ ok: false, reason }`, and `submitCode` REFUSES
+ * (fix round 1, item 3) with `SubmitCodeRefused("not-running", …)` — there is no process to write to,
+ * which is the SAME condition a call after a real process exits refuses under.
+ */
+export declare function startAnthropicConsoleBrokerLogin(store: CredentialStore, options: AnthropicConsoleBrokerOptions): AnthropicConsoleLoginHandle;
+/**
+ * Runs `ant auth print-credentials --profile <profile> --access-token` and writes the bearer material
+ * `anthropic:default` (P10a-4) -- called automatically by `startAnthropicConsoleBrokerLogin` on a
+ * successful login, and separately by a host's own refresh timer (60 s before `expiresAt`, per
+ * P10a-4) since renewal never re-runs the interactive login.
+ *
+ * A FAILURE LEAVES ANY EXISTING MATERIAL UNTOUCHED: this function never calls `store.set` on any path
+ * that did not itself produce a fresh token, so a transient failure of the broker cannot erase a
+ * still-good credential.
+ */
+export declare function refreshAnthropicBearer(store: CredentialStore, options: AnthropicConsoleBrokerOptions): Promise<{
+    ok: true;
+    expiresAt: number;
+} | {
+    ok: false;
+    reason: string;
+}>;
+/** Does `<anthropicConfigDir>/credentials/<profile>.json` exist? A plain file-exists check -- this file never opens or parses it here. */
+export declare function anthropicConsoleProfileExists(anthropicConfigDir: string, profile?: string): boolean;
+/**
+ * Runs `claude auth logout` (best-effort) and then deletes the bearer material regardless of whether
+ * the binary succeeded -- a host that cannot reach the binary should still be able to forget the
+ * bearer material it already holds; leaving it in the Keychain because a subprocess failed would be
+ * the worse of the two failures.
+ */
+export declare function logoutAnthropicConsole(store: CredentialStore, options: AnthropicConsoleBrokerOptions): Promise<void>;

package/dist/adapters/anthropic/console-oauth.d.ts

@@ -1,41 +1,4 @@
-import type { CredentialRef, CredentialStore } from "../../types.js";
-/**
- * The Console OAuth constants, derived from `@anthropic-ai/claude-agent-sdk@0.3.250`.
- *
- * Pinned field-by-field against `compat/anthropic/0.3.250/derived-p6b.ts`. Note what is NOT here:
- * the consumer authorize host, the consumer origin, the two `claude_cli`-scoped endpoints, and the
- * vendor's own product beta. A constant that exists is a constant something can come to use, so the
- * excluded ones live only in the capture document, as a record of the exclusion.
- */
-export declare const CONSOLE_OAUTH: {
-    /** A PUBLIC PKCE client id from a public npm artifact — there is no client secret, and none is sent. */
-    readonly clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-    readonly authorizeUrl: "https://platform.claude.com/oauth/authorize";
-    readonly tokenUrl: "https://platform.claude.com/v1/oauth/token";
-    /** The account id is NOT in the token response; it is read from here, as `account.uuid`. */
-    readonly profileUrl: "https://api.anthropic.com/api/oauth/profile";
-    readonly scope: "user:inference user:profile";
-    /**
-     * `0` — an ephemeral port, and the DERIVED value rather than a test convenience. This client's
-     * registration accepts a loopback URI on any port; codex's fixed 1455/1457 pair is the opposite
-     * case, and copying that shape here would bind a port for no reason and fight a concurrent login.
-     */
-    readonly callbackPort: 0;
-    readonly callbackPath: "/callback";
-    /** The `anthropic-beta` value that accompanies an OAuth bearer on every request. */
-    readonly betaHeader: "oauth-2025-04-20";
-    /**
-     * The profile-response field that names the credential record, as a dotted path.
-     *
-     * Present so that EVERY field of the capture's derived table has a counterpart here and the
-     * constants test gates all nine — a derived value with no shipped twin is a value nothing stops
-     * from drifting. `fetchAccountId` reads exactly this path; it is stated rather than walked because
-     * one fixed shape does not need a path interpreter.
-     */
-    readonly accountIdPath: "account.uuid";
-};
-/** How long before expiry a token is renewed rather than used. One minute of slack over a turn that may take seconds to start. */
-export declare const OAUTH_REFRESH_WINDOW_MS = 60000;
+import type { CredentialRef } from "../../types.js";
 /**
  * The ONE provider id whose `oauth` credential is an Anthropic Console one.
  *
@@ -43,16 +6,25 @@ export declare const OAUTH_REFRESH_WINDOW_MS = 60000;
  * condition: R6b-5 makes this adapter MULTI-PROVIDER — a third party that speaks the Anthropic
  * Messages dialect ships as its own `<id>-anthropic` row on this same `adapterId`, with its own
  * `defaultEndpoints.api`. Nothing upstream of the adapter checks that a stored credential's KIND
- * matches its row's `authKinds`, so without this gate an `oauth` credential stored against a sibling
- * row would have its REFRESH TOKEN posted to `platform.claude.com` — a third party's credential sent
- * to Anthropic — and would stamp Anthropic's beta on that third party's request. Both are the same
- * mistake the `bearer` arm already refuses to make, with a considerably worse failure.
+ * matches its row's `authKinds`, so without this gate a sibling row's `oauth` credential would have
+ * Anthropic's beta stamped on its request — a third party's turn wearing Anthropic's own header.
  */
 export declare const ANTHROPIC_CONSOLE_PROVIDER_ID = "anthropic";
 /**
- * The ONE spelling of an Anthropic OAuth record's name (R6-10).
+ * What survives of the old `CONSOLE_OAUTH` object once its login-only fields are gone: the ONE header
+ * value `messages.ts` still sends alongside an `oauth`-kind Anthropic credential's bearer.
+ *
+ * See the file banner for why this is renamed rather than trimmed in place, and P10a-1/M3 for why the
+ * value itself is not yet a settled decision — the constant stays until a measurement says otherwise.
+ */
+export declare const CONSOLE_BEARER: {
+    /** The `anthropic-beta` value that accompanies an OAuth bearer on every request. */
+    readonly betaHeader: "oauth-2025-04-20";
+};
+/**
+ * The ONE spelling of an Anthropic OAuth/bearer record's name (R6-10).
  *
- * Exported and used by both the login and the adapter, because a host that assembles
+ * Exported and used by both a host's broker and the adapter, because a host that assembles
  * `anthropic:<id>` by hand will eventually assemble it differently from whatever reads it — a
  * credential written to a key nothing looks up, failing as "no credential configured" with the
  * record sitting right there.
@@ -60,42 +32,3 @@ export declare const ANTHROPIC_CONSOLE_PROVIDER_ID = "anthropic";
 export declare function anthropicCredentialRef(accountId: string, service?: string): Extract<CredentialRef, {
     kind: "keychain";
 }>;
-export interface AnthropicConsoleLoginOptions {
-    /** Opens the browser. HOST-supplied: the SDK never shells out to one itself. */
-    openUrl: (url: string) => Promise<void>;
-    /** Overridden by a fixture; production uses `CONSOLE_OAUTH`'s own values. */
-    authorizeUrl?: string;
-    tokenUrl?: string;
-    profileUrl?: string;
-    callbackPort?: number;
-    timeoutMs?: number;
-    /** The Keychain service the record lands in — `config.keychainService` from the host. */
-    service?: string;
-    onAuthStatus?: (status: {
-        isAuthenticating: boolean;
-        output?: string[];
-        error?: string;
-    }) => void;
-}
-export interface AnthropicConsoleLoginResult {
-    ref: Extract<CredentialRef, {
-        kind: "keychain";
-    }>;
-    accountId: string;
-    /** Epoch milliseconds. */
-    expiresAt: number;
-}
-/**
- * The host-invoked Console login. Runs the PKCE loopback flow, asks who signed in, and PERSISTS the
- * result through the credential store — returning the ref a session should then be configured with.
- *
- * WHY THERE IS A SECOND REQUEST. The token response carries no account of any kind (the capture's
- * §2.3), so unlike codex — where the id token's own claim names the record — the account id has to
- * be fetched. `GET /api/oauth/profile` under the new bearer is what the pinned artifact itself does,
- * and `user:profile` is in the scope precisely to authorise it.
- *
- * A LOGIN THAT CANNOT NAME ITS RECORD IS A REFUSAL, not a fallback to some default slot: R6-10 is
- * explicit that a credential occupies one record per provider/account, and `anthropic:undefined`
- * would be a shared global slot wearing a per-account name.
- */
-export declare function startAnthropicConsoleLogin(store: CredentialStore, options: AnthropicConsoleLoginOptions): Promise<AnthropicConsoleLoginResult>;

package/dist/adapters/anthropic/index.d.ts

@@ -1,4 +1,5 @@
 export { ANTHROPIC_ADAPTER_ID, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_BASE_URL, ANTHROPIC_DEFAULT_MAX_TOKENS, createAnthropicMessagesAdapter, findDescriptor, mapAnthropicEffort, toWireMessages, } from "./messages.js";
 export type { AnthropicAdapterOptions, EffortMapping } from "./messages.js";
-export { CONSOLE_OAUTH, OAUTH_REFRESH_WINDOW_MS, anthropicCredentialRef, startAnthropicConsoleLogin } from "./console-oauth.js";
-export type { AnthropicConsoleLoginOptions, AnthropicConsoleLoginResult } from "./console-oauth.js";
+export { CONSOLE_BEARER, anthropicCredentialRef } from "./console-oauth.js";
+export { DEFAULT_ANTHROPIC_CONSOLE_PROFILE, anthropicConsoleProfileExists, logoutAnthropicConsole, refreshAnthropicBearer, startAnthropicConsoleBrokerLogin, } from "./console-broker.js";
+export type { AnthropicConsoleBrokerOptions, AnthropicConsoleLoginHandle } from "./console-broker.js";

package/dist/adapters/anthropic/messages.d.ts

@@ -30,13 +30,6 @@ export interface AnthropicAdapterOptions {
     /** `anthropic-beta` values, joined with commas. A PROTOCOL header (R6-L): every endpoint needs it to be spoken to, and it names no account. */
     betas?: string[];
     defaultMaxOutputTokens?: number;
-    /**
-     * The OAuth token endpoint a near-expiry `oauth` credential is renewed through (D20).
-     *
-     * Injectable for a fixture exactly as codex's is; production uses `CONSOLE_OAUTH.tokenUrl`. It has
-     * no effect on an `api-key` credential, which is every other row this adapter serves.
-     */
-    tokenUrl?: string;
 }
 export declare function toWireMessages(messages: ProviderMessageLike[]): Array<{
     role: "user" | "assistant";

package/dist/adapters/openai/pkce.d.ts

@@ -65,6 +65,14 @@ export interface LoginConfig {
      */
     includeStateInTokenRequest?: boolean;
     scope: string;
+    /**
+     * Extra authorize-request query parameters a client's registration REQUIRES beyond the PKCE set —
+     * appended after the standard parameters. Opt-in per login so one endpoint's shape changes nothing
+     * about another's. The Anthropic Console client needs `code=true` (derived-shapes-p6b.md §2.2, the
+     * FIRST parameter of its authorize request); without it the authorize page answers
+     * "Authorization failed — Invalid request format" before any callback (measured 2026-09-13).
+     */
+    extraAuthorizeParams?: Record<string, string>;
     timeoutMs?: number;
     /** Opens the browser. HOST-supplied: the SDK never shells out to a browser itself. */
     openUrl: (url: string) => Promise<void>;
@@ -108,4 +116,5 @@ export declare function buildAuthorizeUrl(cfg: {
     scope: string;
     state: string;
     challenge: string;
+    extraAuthorizeParams?: Record<string, string>;
 }): string;

package/dist/credentials/types.d.ts

@@ -1,5 +1,13 @@
 import type { CredentialMaterial, CredentialRef, CredentialStore } from "../types.js";
-export type CredentialResolutionCode = "unsupported" | "malformed" | "io";
+export type CredentialResolutionCode = "unsupported" | "malformed" | "io"
+/**
+ * P10a-1 (2026-09-13): a `startProviderLogin` refusal, not a store one — added here rather than
+ * reusing `"unsupported"` because a host needs to tell "this login is not wired" (`qoder`) apart
+ * from "this login exists, but it is not this SDK's to run" (Anthropic Console). The Console flow
+ * is host-brokered (`claude auth login --console` / `ant auth print-credentials`); this SDK must
+ * never implement it again.
+ */
+ | "console_login_is_host_brokered";
 /**
  * A typed credential failure. **Its message never contains credential material** — construct it from
  * a locator (`redactRef`) and a reason, never from a file's contents or a parsed value. The stores

package/dist/{index-446qxzss.js → index-r2frr72q.js}

@@ -40996,7 +40996,7 @@ import { CLAUDE_RESERVED_SLOT_NAMES as CLAUDE_RESERVED_SLOT_NAMES2, CURRENCY_RE
 // package.json
 var package_default = {
   name: "@yanlinglabs/winter-provider-runtime",
-  version: "0.0.5",
+  version: "0.0.6",
   license: "MIT",
   type: "module",
   engines: {
@@ -41241,169 +41241,6 @@ async function* parseSse2(body, opts) {
   }
 }
 
-// src/adapters/openai/pkce.ts
-var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-function base64Url2(bytes) {
-  let out = "";
-  for (let i = 0;i < bytes.length; i += 3) {
-    const a = bytes[i];
-    const b = bytes[i + 1];
-    const c = bytes[i + 2];
-    out += BASE64URL_ALPHABET[a >> 2];
-    out += BASE64URL_ALPHABET[(a & 3) << 4 | (b ?? 0) >> 4];
-    if (b === undefined)
-      break;
-    out += BASE64URL_ALPHABET[(b & 15) << 2 | (c ?? 0) >> 6];
-    if (c === undefined)
-      break;
-    out += BASE64URL_ALPHABET[c & 63];
-  }
-  return out;
-}
-function randomBase64Url(byteLength) {
-  const bytes = new Uint8Array(byteLength);
-  crypto.getRandomValues(bytes);
-  return base64Url2(bytes);
-}
-async function generatePkce() {
-  const verifier = randomBase64Url(48);
-  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
-  return { verifier, challenge: base64Url2(new Uint8Array(digest)) };
-}
-function decodeAccountId(idToken) {
-  try {
-    const payloadSegment = idToken.split(".")[1];
-    if (payloadSegment === undefined)
-      return;
-    const normalized = payloadSegment.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
-    const payload = JSON.parse(atob(padded));
-    const auth = payload["https://api.openai.com/auth"];
-    if (auth === null || typeof auth !== "object")
-      return;
-    const accountId = auth.chatgpt_account_id;
-    return typeof accountId === "string" && accountId.length > 0 ? accountId : undefined;
-  } catch {
-    return;
-  }
-}
-async function exchange(tokenUrl, params, label = "codex", bodyEncoding = "form") {
-  const built = createEndpointPolicy2(new URL(tokenUrl).origin, { generated: true });
-  if (!built.ok)
-    throw new ProviderRequestError2({ code: "capability", message: built.reason, retryable: false });
-  const response = await boundedFetch2(tokenUrl, {
-    method: "POST",
-    headers: { "content-type": bodyEncoding === "json" ? "application/json" : "application/x-www-form-urlencoded", accept: "application/json", "user-agent": winterUserAgent2() },
-    body: bodyEncoding === "json" ? JSON.stringify(params) : new URLSearchParams(params).toString(),
-    policy: built.policy,
-    maxBodyBytes: 512 * 1024,
-    timeoutMs: 30000
-  });
-  if (!response.ok) {
-    await response.text().catch(() => "");
-    throw new ProviderRequestError2({ code: response.status === 400 || response.status === 401 ? "auth" : "server", message: `${label} token exchange failed: HTTP ${response.status}`, status: response.status, retryable: response.status >= 500 });
-  }
-  const payload = await response.json();
-  if (typeof payload.access_token !== "string" || payload.access_token.length === 0) {
-    throw new ProviderRequestError2({ code: "auth", message: `${label} token exchange returned no access token`, retryable: false });
-  }
-  const idToken = typeof payload.id_token === "string" ? payload.id_token : undefined;
-  const accountId = idToken !== undefined ? decodeAccountId(idToken) : undefined;
-  return {
-    accessToken: payload.access_token,
-    ...typeof payload.refresh_token === "string" ? { refreshToken: payload.refresh_token } : {},
-    ...idToken !== undefined ? { idToken } : {},
-    ...accountId !== undefined ? { accountId } : {},
-    expiresAt: Date.now() + (typeof payload.expires_in === "number" ? payload.expires_in : 3600) * 1000
-  };
-}
-function refreshTokens(tokenUrl, clientId, refreshToken) {
-  return exchange(tokenUrl, { grant_type: "refresh_token", client_id: clientId, refresh_token: refreshToken });
-}
-async function runLoginFlow(cfg) {
-  requireBunRuntime2(cfg.functionName ?? "runLoginFlow", "Bun.serve", "The authorization-code flow has to receive the vendor's redirect on 127.0.0.1, which needs a real HTTP listener. Run the login under Bun (or complete it in a Bun process and pass the resulting credential ref to your Node session).");
-  const { verifier, challenge } = await generatePkce();
-  const state = randomBase64Url(16);
-  const report = (output) => cfg.onAuthStatus?.({ isAuthenticating: true, output: [output] });
-  let resolveCode;
-  let rejectFlow;
-  const codePromise = new Promise((resolve, reject) => {
-    resolveCode = resolve;
-    rejectFlow = reject;
-  });
-  codePromise.catch(() => {});
-  const callbackPath = cfg.callbackPath ?? "/auth/callback";
-  const label = cfg.label ?? "codex";
-  const ports = cfg.callbackPort === 0 ? [0] : [cfg.callbackPort, ...cfg.fallbackCallbackPort !== undefined ? [cfg.fallbackCallbackPort] : []];
-  let server;
-  let lastError;
-  for (const port of ports) {
-    try {
-      server = Bun.serve({
-        port,
-        hostname: "127.0.0.1",
-        fetch(req) {
-          const url = new URL(req.url);
-          if (url.pathname !== callbackPath)
-            return new Response("not found", { status: 404 });
-          if (url.searchParams.get("state") !== state) {
-            rejectFlow(new Error("OAuth state mismatch — refusing to complete a login this process did not start"));
-            return new Response("state mismatch", { status: 400 });
-          }
-          const code = url.searchParams.get("code");
-          if (code === null || code.length === 0) {
-            rejectFlow(new Error("the OAuth callback carried no authorization code"));
-            return new Response("missing code", { status: 400 });
-          }
-          resolveCode(code);
-          return new Response("Signed in — you can close this tab.", { headers: { "content-type": "text/plain" } });
-        }
-      });
-      break;
-    } catch (err) {
-      lastError = err;
-    }
-  }
-  if (server === undefined) {
-    const detail = lastError instanceof Error ? lastError.message : String(lastError);
-    throw new ProviderRequestError2({ code: "capability", message: `could not open the ${label} login callback on port ${ports.join(" or ")} — is another login in progress? (${detail})`, retryable: false });
-  }
-  const redirectUri = `http://localhost:${server.port}${callbackPath}`;
-  const authUrl = new URL(cfg.authorizeUrl);
-  authUrl.search = new URLSearchParams({
-    response_type: "code",
-    client_id: cfg.clientId,
-    redirect_uri: redirectUri,
-    scope: cfg.scope,
-    state,
-    code_challenge: challenge,
-    code_challenge_method: "S256"
-  }).toString();
-  const timeout = setTimeout(() => rejectFlow(new Error(`the ${label} login timed out`)), cfg.timeoutMs ?? 5 * 60000);
-  try {
-    report("opening the browser for sign-in");
-    cfg.openUrl(authUrl.toString()).catch((err) => rejectFlow(new Error(`could not open the browser: ${err instanceof Error ? err.message : String(err)}`)));
-    const code = await codePromise;
-    report("exchanging the authorization code");
-    const tokens = await exchange(cfg.tokenUrl, {
-      grant_type: "authorization_code",
-      client_id: cfg.clientId,
-      code,
-      redirect_uri: redirectUri,
-      code_verifier: verifier,
-      ...cfg.includeStateInTokenRequest === true ? { state } : {}
-    }, label, cfg.bodyEncoding ?? "form");
-    cfg.onAuthStatus?.({ isAuthenticating: false, output: ["signed in"] });
-    return tokens;
-  } catch (err) {
-    cfg.onAuthStatus?.({ isAuthenticating: false, error: err instanceof Error ? err.message : String(err) });
-    throw err;
-  } finally {
-    clearTimeout(timeout);
-    server.stop(true);
-  }
-}
-
 // src/registry.ts
 class WinterProviderResolutionError2 extends Error {
   code;
@@ -43721,6 +43558,170 @@ function codexCredentialAccount2(accountId) {
   return `codex-oauth:${accountId}`;
 }
 
+// src/adapters/openai/pkce.ts
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function base64Url2(bytes) {
+  let out = "";
+  for (let i = 0;i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+    out += BASE64URL_ALPHABET[a >> 2];
+    out += BASE64URL_ALPHABET[(a & 3) << 4 | (b ?? 0) >> 4];
+    if (b === undefined)
+      break;
+    out += BASE64URL_ALPHABET[(b & 15) << 2 | (c ?? 0) >> 6];
+    if (c === undefined)
+      break;
+    out += BASE64URL_ALPHABET[c & 63];
+  }
+  return out;
+}
+function randomBase64Url(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return base64Url2(bytes);
+}
+async function generatePkce() {
+  const verifier = randomBase64Url(48);
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return { verifier, challenge: base64Url2(new Uint8Array(digest)) };
+}
+function decodeAccountId(idToken) {
+  try {
+    const payloadSegment = idToken.split(".")[1];
+    if (payloadSegment === undefined)
+      return;
+    const normalized = payloadSegment.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+    const payload = JSON.parse(atob(padded));
+    const auth = payload["https://api.openai.com/auth"];
+    if (auth === null || typeof auth !== "object")
+      return;
+    const accountId = auth.chatgpt_account_id;
+    return typeof accountId === "string" && accountId.length > 0 ? accountId : undefined;
+  } catch {
+    return;
+  }
+}
+async function exchange(tokenUrl, params, label = "codex", bodyEncoding = "form") {
+  const built = createEndpointPolicy2(new URL(tokenUrl).origin, { generated: true });
+  if (!built.ok)
+    throw new ProviderRequestError2({ code: "capability", message: built.reason, retryable: false });
+  const response = await boundedFetch2(tokenUrl, {
+    method: "POST",
+    headers: { "content-type": bodyEncoding === "json" ? "application/json" : "application/x-www-form-urlencoded", accept: "application/json", "user-agent": winterUserAgent2() },
+    body: bodyEncoding === "json" ? JSON.stringify(params) : new URLSearchParams(params).toString(),
+    policy: built.policy,
+    maxBodyBytes: 512 * 1024,
+    timeoutMs: 30000
+  });
+  if (!response.ok) {
+    await response.text().catch(() => "");
+    throw new ProviderRequestError2({ code: response.status === 400 || response.status === 401 ? "auth" : "server", message: `${label} token exchange failed: HTTP ${response.status}`, status: response.status, retryable: response.status >= 500 });
+  }
+  const payload = await response.json();
+  if (typeof payload.access_token !== "string" || payload.access_token.length === 0) {
+    throw new ProviderRequestError2({ code: "auth", message: `${label} token exchange returned no access token`, retryable: false });
+  }
+  const idToken = typeof payload.id_token === "string" ? payload.id_token : undefined;
+  const accountId = idToken !== undefined ? decodeAccountId(idToken) : undefined;
+  return {
+    accessToken: payload.access_token,
+    ...typeof payload.refresh_token === "string" ? { refreshToken: payload.refresh_token } : {},
+    ...idToken !== undefined ? { idToken } : {},
+    ...accountId !== undefined ? { accountId } : {},
+    expiresAt: Date.now() + (typeof payload.expires_in === "number" ? payload.expires_in : 3600) * 1000
+  };
+}
+function refreshTokens(tokenUrl, clientId, refreshToken) {
+  return exchange(tokenUrl, { grant_type: "refresh_token", client_id: clientId, refresh_token: refreshToken });
+}
+async function runLoginFlow(cfg) {
+  requireBunRuntime2(cfg.functionName ?? "runLoginFlow", "Bun.serve", "The authorization-code flow has to receive the vendor's redirect on 127.0.0.1, which needs a real HTTP listener. Run the login under Bun (or complete it in a Bun process and pass the resulting credential ref to your Node session).");
+  const { verifier, challenge } = await generatePkce();
+  const state = randomBase64Url(16);
+  const report = (output) => cfg.onAuthStatus?.({ isAuthenticating: true, output: [output] });
+  let resolveCode;
+  let rejectFlow;
+  const codePromise = new Promise((resolve, reject) => {
+    resolveCode = resolve;
+    rejectFlow = reject;
+  });
+  codePromise.catch(() => {});
+  const callbackPath = cfg.callbackPath ?? "/auth/callback";
+  const label = cfg.label ?? "codex";
+  const ports = cfg.callbackPort === 0 ? [0] : [cfg.callbackPort, ...cfg.fallbackCallbackPort !== undefined ? [cfg.fallbackCallbackPort] : []];
+  let server;
+  let lastError;
+  for (const port of ports) {
+    try {
+      server = Bun.serve({
+        port,
+        hostname: "127.0.0.1",
+        fetch(req) {
+          const url = new URL(req.url);
+          if (url.pathname !== callbackPath)
+            return new Response("not found", { status: 404 });
+          if (url.searchParams.get("state") !== state) {
+            rejectFlow(new Error("OAuth state mismatch — refusing to complete a login this process did not start"));
+            return new Response("state mismatch", { status: 400 });
+          }
+          const code = url.searchParams.get("code");
+          if (code === null || code.length === 0) {
+            rejectFlow(new Error("the OAuth callback carried no authorization code"));
+            return new Response("missing code", { status: 400 });
+          }
+          resolveCode(code);
+          return new Response("Signed in — you can close this tab.", { headers: { "content-type": "text/plain" } });
+        }
+      });
+      break;
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  if (server === undefined) {
+    const detail = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new ProviderRequestError2({ code: "capability", message: `could not open the ${label} login callback on port ${ports.join(" or ")} — is another login in progress? (${detail})`, retryable: false });
+  }
+  const redirectUri = `http://localhost:${server.port}${callbackPath}`;
+  const authUrl = new URL(cfg.authorizeUrl);
+  authUrl.search = new URLSearchParams({
+    response_type: "code",
+    client_id: cfg.clientId,
+    redirect_uri: redirectUri,
+    scope: cfg.scope,
+    state,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    ...cfg.extraAuthorizeParams ?? {}
+  }).toString();
+  const timeout = setTimeout(() => rejectFlow(new Error(`the ${label} login timed out`)), cfg.timeoutMs ?? 5 * 60000);
+  try {
+    report("opening the browser for sign-in");
+    cfg.openUrl(authUrl.toString()).catch((err) => rejectFlow(new Error(`could not open the browser: ${err instanceof Error ? err.message : String(err)}`)));
+    const code = await codePromise;
+    report("exchanging the authorization code");
+    const tokens = await exchange(cfg.tokenUrl, {
+      grant_type: "authorization_code",
+      client_id: cfg.clientId,
+      code,
+      redirect_uri: redirectUri,
+      code_verifier: verifier,
+      ...cfg.includeStateInTokenRequest === true ? { state } : {}
+    }, label, cfg.bodyEncoding ?? "form");
+    cfg.onAuthStatus?.({ isAuthenticating: false, output: ["signed in"] });
+    return tokens;
+  } catch (err) {
+    cfg.onAuthStatus?.({ isAuthenticating: false, error: err instanceof Error ? err.message : String(err) });
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+    server.stop(true);
+  }
+}
+
 // src/adapters/openai/quota.ts
 class QuotaManager2 {
   maxConcurrent;
@@ -43995,4 +43996,4 @@ function crc32(bytes, seed = 0) {
   return (c ^ 4294967295) >>> 0;
 }
 
-export { isLocalAddressClass2, classifyAddress2, isDisallowedAddress2, CredentialResolutionError2, redactMaterial2, redactRef2, isNoCredential, unsupported, readOnlyWriteRefusal, createCompositeCredentialStore2, createMemoryCredentialStore2, connectionEndpointOptions2, CREDENTIAL_HEADER_NAMES2, stripCredentialHeaders2, applyPrivilegedHeaders2, evaluateEndpoint2, createEndpointPolicy2, stampFamilyFields, loadCatalog, ProviderStallError2, parseProviderErrorCode2, parseRetryAfterMs2, redactCredentialMaterial2, normalizeHttpError2, isProviderError2, normalizeThrown2, toSdkAssistantMessageError2, DEFAULT_MAX_RETRIES2, RETRY_BACKOFF_BASE_MS2, RETRY_BACKOFF_CAP_MS2, RETRY_AFTER_HONOUR_CEILING_MS2, createRetryPolicy2, withRetry2, DEFAULT_MAX_REDIRECTS2, ProviderRequestError2, ProviderBodyLimitError2, boundedFetch2, WINTER_BRAND, activeWinterIdentity2, setWinterIdentity2, winterUserAgent2, renderIdentityHeaders2, identityHeaderLookup, winterIdentityHeaders, BunRequiredError2, hasBunRuntime2, requireBunRuntime2, PRIVILEGED_IDENTITY_HEADERS2, WINTER_IDENTITY_HEADERS, hostHeaders2, THINKING_ENABLED_NEEDS_BUDGET2, containsImage, parseSse2, base64Url2, refreshTokens, runLoginFlow, WinterProviderResolutionError2, estimateCostUsd2, createRegistry2, GOOGLE_ADAPTER_ID2, GOOGLE_DEFAULT_BASE_URL2, GOOGLE_API_VERSION_PATH2, googleCompletionMarker2, toContents2, mapGoogleEffort2, createGoogleFamilyAdapter2, geminiTransport2, createGoogleGenerateContentAdapter2, RS2562, base64UrlEncode2, pkcs8DerFromPem2, importRs256PrivateKey2, signRs256Jwt2, GCP_CLOUD_PLATFORM_SCOPE2, createServiceAccountTokenSource2, VERTEX_ADAPTER_ID2, VERTEX_API_VERSION_PATH2, vertexEndpointUrl2, vertexModelPath2, vertexTransport2, createVertexGeminiAdapter2, crc32, BEDROCK_SERVICE, sha256Hex, buildCanonicalRequest, buildStringToSign, computeSignature, signRequest2, parseAuthorization2, DEFAULT_HEADER_TIMEOUT_MS, capabilityRefusal, resolveEndpoint, resolveAuth, buildHeaders, identityFor, mapEffortAgainst, resolveReasoning, assertWithinLimits, capabilitiesFrom, assertRepresentableTools, EventQueue, httpErrorFrom, errorEvent, fetchOpenAiModels, validateViaModels, OPENAI_API_BASE_URL2, buildResponsesBody, streamResponsesTurn, createResponsesAdapter2, privilegedHeaders, responsesTurn, OPENAI_CHAT_BASE_URL2, DEEPSEEK_BASE_URL2, OPENROUTER_BASE_URL2, chatTurn, createChatCompletionsAdapter2, openRouterProfile2, deepSeekProfile2, CODEX2, CODEX_ORIGINATOR2, CODEX_MODELS, codexCredentialAccount2, QuotaManager2, quotaEvent, AZURE_PREVIEW_API_VERSION2, createAzureOpenAIAdapter2, sameDomain2, sameFamily2, readableStateOf2, summaryRequestOf2, shouldRequestSummary2, createEndpointResolver2, endpointFromOrigin2 };
+export { isLocalAddressClass2, classifyAddress2, isDisallowedAddress2, CredentialResolutionError2, redactMaterial2, redactRef2, isNoCredential, unsupported, readOnlyWriteRefusal, createCompositeCredentialStore2, createMemoryCredentialStore2, connectionEndpointOptions2, CREDENTIAL_HEADER_NAMES2, stripCredentialHeaders2, applyPrivilegedHeaders2, evaluateEndpoint2, createEndpointPolicy2, stampFamilyFields, loadCatalog, ProviderStallError2, parseProviderErrorCode2, parseRetryAfterMs2, redactCredentialMaterial2, normalizeHttpError2, isProviderError2, normalizeThrown2, toSdkAssistantMessageError2, DEFAULT_MAX_RETRIES2, RETRY_BACKOFF_BASE_MS2, RETRY_BACKOFF_CAP_MS2, RETRY_AFTER_HONOUR_CEILING_MS2, createRetryPolicy2, withRetry2, DEFAULT_MAX_REDIRECTS2, ProviderRequestError2, ProviderBodyLimitError2, boundedFetch2, WINTER_BRAND, activeWinterIdentity2, setWinterIdentity2, winterUserAgent2, renderIdentityHeaders2, identityHeaderLookup, winterIdentityHeaders, BunRequiredError2, hasBunRuntime2, requireBunRuntime2, PRIVILEGED_IDENTITY_HEADERS2, WINTER_IDENTITY_HEADERS, hostHeaders2, THINKING_ENABLED_NEEDS_BUDGET2, containsImage, parseSse2, WinterProviderResolutionError2, estimateCostUsd2, createRegistry2, GOOGLE_ADAPTER_ID2, GOOGLE_DEFAULT_BASE_URL2, GOOGLE_API_VERSION_PATH2, googleCompletionMarker2, toContents2, mapGoogleEffort2, createGoogleFamilyAdapter2, geminiTransport2, createGoogleGenerateContentAdapter2, RS2562, base64UrlEncode2, pkcs8DerFromPem2, importRs256PrivateKey2, signRs256Jwt2, GCP_CLOUD_PLATFORM_SCOPE2, createServiceAccountTokenSource2, VERTEX_ADAPTER_ID2, VERTEX_API_VERSION_PATH2, vertexEndpointUrl2, vertexModelPath2, vertexTransport2, createVertexGeminiAdapter2, crc32, BEDROCK_SERVICE, sha256Hex, buildCanonicalRequest, buildStringToSign, computeSignature, signRequest2, parseAuthorization2, DEFAULT_HEADER_TIMEOUT_MS, capabilityRefusal, resolveEndpoint, resolveAuth, buildHeaders, identityFor, mapEffortAgainst, resolveReasoning, assertWithinLimits, capabilitiesFrom, assertRepresentableTools, EventQueue, httpErrorFrom, errorEvent, fetchOpenAiModels, validateViaModels, OPENAI_API_BASE_URL2, buildResponsesBody, streamResponsesTurn, createResponsesAdapter2, privilegedHeaders, responsesTurn, OPENAI_CHAT_BASE_URL2, DEEPSEEK_BASE_URL2, OPENROUTER_BASE_URL2, chatTurn, createChatCompletionsAdapter2, openRouterProfile2, deepSeekProfile2, CODEX2, CODEX_ORIGINATOR2, CODEX_MODELS, codexCredentialAccount2, base64Url2, refreshTokens, runLoginFlow, QuotaManager2, quotaEvent, AZURE_PREVIEW_API_VERSION2, createAzureOpenAIAdapter2, sameDomain2, sameFamily2, readableStateOf2, summaryRequestOf2, shouldRequestSummary2, createEndpointResolver2, endpointFromOrigin2 };

package/dist/index.d.ts

@@ -26,8 +26,9 @@ export type { KeychainRef, OauthMaterial, RefreshOauthMaterialInput } from "./ad
 export { runDeviceCodeFlow } from "./adapters/oauth/device-code.js";
 export type { DeviceCodeConfig } from "./adapters/oauth/device-code.js";
 export { BunRequiredError, hasBunRuntime, requireBunRuntime } from "./bun-required.js";
-export { CONSOLE_OAUTH, OAUTH_REFRESH_WINDOW_MS, anthropicCredentialRef, startAnthropicConsoleLogin } from "./adapters/anthropic/index.js";
-export type { AnthropicConsoleLoginOptions, AnthropicConsoleLoginResult } from "./adapters/anthropic/index.js";
+export { CONSOLE_BEARER, anthropicCredentialRef } from "./adapters/anthropic/index.js";
+export { DEFAULT_ANTHROPIC_CONSOLE_PROFILE, anthropicConsoleProfileExists, logoutAnthropicConsole, refreshAnthropicBearer, startAnthropicConsoleBrokerLogin, } from "./adapters/anthropic/index.js";
+export type { AnthropicConsoleBrokerOptions, AnthropicConsoleLoginHandle } from "./adapters/anthropic/index.js";
 export { parseSse } from "./sse.js";
 export type { SseEvent, SseOptions } from "./sse.js";
 export { WinterProviderResolutionError, createRegistry, estimateCostUsd } from "./registry.js";

package/dist/index.js

@@ -51,8 +51,6 @@ import {
   THINKING_ENABLED_NEEDS_BUDGET2,
   containsImage,
   parseSse2,
-  refreshTokens,
-  runLoginFlow,
   WinterProviderResolutionError2,
   estimateCostUsd2,
   createRegistry2,
@@ -105,6 +103,8 @@ import {
   CODEX_ORIGINATOR2,
   CODEX_MODELS,
   codexCredentialAccount2,
+  refreshTokens,
+  runLoginFlow,
   QuotaManager2,
   quotaEvent,
   createAzureOpenAIAdapter2,
@@ -115,7 +115,7 @@ import {
   shouldRequestSummary2,
   createEndpointResolver2,
   endpointFromOrigin2
-} from "./index-446qxzss.js";
+} from "./index-r2frr72q.js";
 // src/credentials/env.ts
 var NAME = "env credential store";
 function createEnvCredentialStore(opts) {
@@ -443,92 +443,13 @@ async function runDeviceCodeFlow(cfg) {
   }
 }
 // src/adapters/anthropic/console-oauth.ts
-var CONSOLE_OAUTH = {
-  clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
-  authorizeUrl: "https://platform.claude.com/oauth/authorize",
-  tokenUrl: "https://platform.claude.com/v1/oauth/token",
-  profileUrl: "https://api.anthropic.com/api/oauth/profile",
-  scope: "user:inference user:profile",
-  callbackPort: 0,
-  callbackPath: "/callback",
-  betaHeader: "oauth-2025-04-20",
-  accountIdPath: "account.uuid"
-};
-var OAUTH_REFRESH_WINDOW_MS = 60000;
 var ANTHROPIC_CONSOLE_PROVIDER_ID = "anthropic";
+var CONSOLE_BEARER = {
+  betaHeader: "oauth-2025-04-20"
+};
 function anthropicCredentialRef(accountId, service) {
   return { kind: "keychain", account: `anthropic:${accountId}`, ...service !== undefined ? { service } : {} };
 }
-async function startAnthropicConsoleLogin(store, options) {
-  const tokens = await runLoginFlow({
-    clientId: CONSOLE_OAUTH.clientId,
-    authorizeUrl: options.authorizeUrl ?? CONSOLE_OAUTH.authorizeUrl,
-    tokenUrl: options.tokenUrl ?? CONSOLE_OAUTH.tokenUrl,
-    callbackPort: options.callbackPort ?? CONSOLE_OAUTH.callbackPort,
-    callbackPath: CONSOLE_OAUTH.callbackPath,
-    label: "Anthropic Console",
-    functionName: "startAnthropicConsoleLogin",
-    bodyEncoding: "json",
-    includeStateInTokenRequest: true,
-    scope: CONSOLE_OAUTH.scope,
-    ...options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {},
-    openUrl: options.openUrl,
-    ...options.onAuthStatus !== undefined ? { onAuthStatus: options.onAuthStatus } : {}
-  });
-  const accountId = await fetchAccountId(options.profileUrl ?? CONSOLE_OAUTH.profileUrl, tokens.accessToken);
-  if (accountId === undefined) {
-    throw new ProviderRequestError2({
-      code: "capability",
-      message: "the Anthropic Console sign-in completed but the profile lookup reported no account id, so the credential has no per-account record to occupy (R6-10)",
-      retryable: false
-    });
-  }
-  const ref = anthropicCredentialRef(accountId, options.service);
-  await store.set(ref, materialFor(tokens, accountId));
-  return { ref, accountId, expiresAt: tokens.expiresAt };
-}
-async function fetchAccountId(profileUrl, accessToken) {
-  const built = createEndpointPolicy2(new URL(profileUrl).origin, { generated: true });
-  if (!built.ok)
-    throw new ProviderRequestError2({ code: "capability", message: built.reason, retryable: false });
-  const response = await boundedFetch2(profileUrl, {
-    method: "GET",
-    headers: {
-      authorization: `Bearer ${accessToken}`,
-      accept: "application/json",
-      "user-agent": winterUserAgent2()
-    },
-    policy: built.policy,
-    maxBodyBytes: 512 * 1024,
-    timeoutMs: 30000
-  });
-  if (!response.ok) {
-    await response.text().catch(() => "");
-    throw new ProviderRequestError2({
-      code: response.status === 401 || response.status === 403 ? "auth" : "server",
-      message: `the Anthropic Console profile lookup failed: HTTP ${response.status}`,
-      status: response.status,
-      retryable: response.status >= 500
-    });
-  }
-  let payload;
-  try {
-    payload = await response.json();
-  } catch {
-    throw new ProviderRequestError2({ code: "server", message: "the Anthropic Console profile lookup returned a body that is not JSON", retryable: false });
-  }
-  const uuid = payload.account?.uuid;
-  return typeof uuid === "string" && uuid.length > 0 ? uuid : undefined;
-}
-function materialFor(tokens, accountId) {
-  return {
-    kind: "oauth",
-    accessToken: tokens.accessToken,
-    ...tokens.refreshToken !== undefined ? { refreshToken: tokens.refreshToken } : {},
-    accountId,
-    expiresAt: tokens.expiresAt
-  };
-}
 
 // src/adapters/anthropic/messages.ts
 var ANTHROPIC_ADAPTER_ID = "winter.anthropic-messages";
@@ -741,32 +662,12 @@ function resolveEndpoint2(ctx, defaultBaseUrl) {
 function isConsoleProvider(ctx) {
   return ctx.connection.providerId === ANTHROPIC_CONSOLE_PROVIDER_ID;
 }
-async function resolveFreshMaterial(ctx, opts) {
-  const material = await ctx.credentials.get(ctx.authRef);
-  if (material === null || material.kind !== "oauth")
-    return material;
-  if (!isConsoleProvider(ctx))
-    return material;
-  if (ctx.authRef.kind !== "keychain")
-    return material;
-  if (material.refreshToken === undefined || material.refreshToken.length === 0)
-    return material;
-  if (material.expiresAt === undefined)
-    return material;
-  if (material.expiresAt - Date.now() >= OAUTH_REFRESH_WINDOW_MS)
-    return material;
-  return await refreshOauthMaterial({
-    store: ctx.credentials,
-    ref: ctx.authRef,
-    tokenUrl: opts.tokenUrl ?? CONSOLE_OAUTH.tokenUrl,
-    clientId: CONSOLE_OAUTH.clientId,
-    extraFields: { scope: CONSOLE_OAUTH.scope },
-    bodyEncoding: "json"
-  });
+async function resolveFreshMaterial(ctx) {
+  return await ctx.credentials.get(ctx.authRef);
 }
 async function buildHeaders2(ctx, policy, opts, json, identity = {}) {
-  const material = await resolveFreshMaterial(ctx, opts);
-  const betas = [...opts.betas ?? [], ...material?.kind === "oauth" && isConsoleProvider(ctx) ? [CONSOLE_OAUTH.betaHeader] : []].filter((value, index, all) => all.indexOf(value) === index);
+  const material = await resolveFreshMaterial(ctx);
+  const betas = [...opts.betas ?? [], ...material?.kind === "oauth" && isConsoleProvider(ctx) ? [CONSOLE_BEARER.betaHeader] : []].filter((value, index, all) => all.indexOf(value) === index);
   const headers = {
     "user-agent": winterUserAgent2(),
     ...identity,
@@ -1160,6 +1061,195 @@ function createAnthropicMessagesAdapter(opts = {}) {
     }
   };
 }
+// src/adapters/anthropic/console-broker.ts
+import { existsSync } from "node:fs";
+import { join as join2 } from "node:path";
+var DEFAULT_ANTHROPIC_CONSOLE_PROFILE = "winter";
+
+class SubmitCodeRefused extends Error {
+  name = "SubmitCodeRefused";
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+}
+var INHERITED_ENV_NAMES = ["PATH", "HOME", "TMPDIR", "TERM", "SHELL", "LANG"];
+function brokerEnv(options, profile) {
+  const env = {};
+  for (const name of INHERITED_ENV_NAMES) {
+    const value = process.env[name];
+    if (value !== undefined)
+      env[name] = value;
+  }
+  for (const [name, value] of Object.entries(process.env)) {
+    if (name.startsWith("LC_") && value !== undefined)
+      env[name] = value;
+  }
+  env["ANTHROPIC_PROFILE"] = profile;
+  env["ANTHROPIC_CONFIG_DIR"] = options.anthropicConfigDir;
+  env["CLAUDE_CONFIG_DIR"] = options.claudeConfigDir;
+  return env;
+}
+function redactUrlQuery(line) {
+  const urlRedacted = line.replace(/(https?:\/\/[^\s?]+)\?[^\s]*/g, "$1?…");
+  return urlRedacted.replace(/code=.*/i, "code=…");
+}
+function pump(chunk, buffer, onLine, record) {
+  let working = buffer + chunk;
+  let newlineAt;
+  while ((newlineAt = working.indexOf(`
+`)) !== -1) {
+    const raw = working.slice(0, newlineAt);
+    working = working.slice(newlineAt + 1);
+    const redacted = redactUrlQuery(raw);
+    if (record !== undefined && redacted.trim().length > 0)
+      record.push(redacted);
+    onLine(redacted);
+  }
+  return working;
+}
+async function drainStream(stream, onLine, record) {
+  if (stream === null || stream === undefined)
+    return;
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer = pump(decoder.decode(value, { stream: true }), buffer, onLine, record);
+  }
+  if (buffer.length > 0) {
+    const redacted = redactUrlQuery(buffer);
+    if (record !== undefined && redacted.trim().length > 0)
+      record.push(redacted);
+    onLine(redacted);
+  }
+}
+function startAnthropicConsoleBrokerLogin(store, options) {
+  requireBunRuntime2("startAnthropicConsoleBrokerLogin", "Bun.spawn", "The Console login has to spawn the `claude` binary and pipe its stdin/stdout/stderr, which needs Bun's subprocess API. Run the login under Bun (or complete it in a Bun process and pass the resulting credential ref to your Node session).");
+  const profile = options.profile ?? DEFAULT_ANTHROPIC_CONSOLE_PROFILE;
+  const onLine = options.onLine ?? (() => {});
+  const spawnFn = options.spawn ?? Bun.spawn;
+  let child;
+  try {
+    child = spawnFn([options.claudeExecutable, "auth", "login", "--console"], {
+      env: brokerEnv(options, profile),
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+  } catch (err) {
+    const reason = `"claude auth login --console" could not be started: ${err instanceof Error ? err.message : String(err)}`;
+    return {
+      submitCode: async () => {
+        throw new SubmitCodeRefused("not-running", "the console login process never started, so there is nothing to write the code to");
+      },
+      done: Promise.resolve({ ok: false, reason })
+    };
+  }
+  const stderrLines = [];
+  const stdoutPump = drainStream(child.stdout, onLine);
+  const stderrPump = drainStream(child.stderr, onLine, stderrLines);
+  let submitted = false;
+  let exited = false;
+  child.exited.then(() => {
+    exited = true;
+  });
+  const done = (async () => {
+    const [exitCode] = await Promise.all([child.exited, stdoutPump, stderrPump]);
+    if (exitCode !== 0) {
+      const reason = stderrLines.at(-1) ?? `"claude auth login --console" exited with code ${exitCode}`;
+      return { ok: false, reason };
+    }
+    const refreshed = await refreshAnthropicBearer(store, options);
+    if (!refreshed.ok)
+      return { ok: false, reason: refreshed.reason };
+    return { ok: true, profile };
+  })();
+  return {
+    async submitCode(code) {
+      if (exited)
+        throw new SubmitCodeRefused("not-running", "the console login process has already exited; there is nothing left to write the code to");
+      if (submitted)
+        throw new SubmitCodeRefused("already-submitted", "submitCode was already called once for this login; a second call cannot un-write what was already sent");
+      submitted = true;
+      const stdin = child.stdin;
+      if (stdin === undefined || stdin === null || typeof stdin === "number")
+        return;
+      stdin.write(`${code}
+`);
+      await stdin.end();
+    },
+    done
+  };
+}
+async function refreshAnthropicBearer(store, options) {
+  requireBunRuntime2("refreshAnthropicBearer", "Bun.spawn", "Minting the native provider's bearer token spawns the `ant` binary, which needs Bun's subprocess API. Run it under Bun.");
+  if (options.antExecutable === undefined) {
+    return { ok: false, reason: 'the "ant" broker is not installed/resolved (settings.runtimes.antExecutable, or `brew install anthropics/tap/ant`) -- the console login itself succeeded, but nothing can mint the native provider\'s bearer token without it' };
+  }
+  const profile = options.profile ?? DEFAULT_ANTHROPIC_CONSOLE_PROFILE;
+  const spawnFn = options.spawn ?? Bun.spawn;
+  let child;
+  try {
+    child = spawnFn([options.antExecutable, "auth", "print-credentials", "--profile", profile, "--access-token"], {
+      env: brokerEnv(options, profile),
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+  } catch (err) {
+    return { ok: false, reason: `"ant auth print-credentials" could not be started: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  if (exitCode !== 0) {
+    const lastLine = stderr.trim().split(`
+`).map((line) => redactUrlQuery(line)).filter((line) => line.length > 0).at(-1);
+    return { ok: false, reason: lastLine ?? `"ant auth print-credentials" exited with code ${exitCode}` };
+  }
+  const token = stdout.trim();
+  if (token.length === 0)
+    return { ok: false, reason: '"ant auth print-credentials" printed no token' };
+  const now = options.now ?? Date.now;
+  const expiresAt = await readProfileExpiresAt(options.anthropicConfigDir, profile) ?? now() + 3600000;
+  const material = { kind: "bearer", token, expiresAt };
+  const ref = anthropicCredentialRef("default", options.service);
+  try {
+    await store.set(ref, material);
+  } catch {
+    return { ok: false, reason: "the bearer credential could not be written" };
+  }
+  return { ok: true, expiresAt };
+}
+var MAX_PROFILE_FILE_BYTES = 64 * 1024;
+async function readProfileExpiresAt(anthropicConfigDir, profile) {
+  try {
+    const raw = await Bun.file(join2(anthropicConfigDir, "credentials", `${profile}.json`)).slice(0, MAX_PROFILE_FILE_BYTES).text();
+    const parsed = JSON.parse(raw);
+    return typeof parsed.expires_at === "number" ? parsed.expires_at : undefined;
+  } catch {
+    return;
+  }
+}
+function anthropicConsoleProfileExists(anthropicConfigDir, profile = DEFAULT_ANTHROPIC_CONSOLE_PROFILE) {
+  return existsSync(join2(anthropicConfigDir, "credentials", `${profile}.json`));
+}
+async function logoutAnthropicConsole(store, options) {
+  requireBunRuntime2("logoutAnthropicConsole", "Bun.spawn", "Signing out spawns the `claude` binary, which needs Bun's subprocess API. Run it under Bun.");
+  const profile = options.profile ?? DEFAULT_ANTHROPIC_CONSOLE_PROFILE;
+  const spawnFn = options.spawn ?? Bun.spawn;
+  try {
+    const child = spawnFn([options.claudeExecutable, "auth", "logout"], { env: brokerEnv(options, profile), stdout: "pipe", stderr: "pipe" });
+    await child.exited;
+  } catch {}
+  await store.delete(anthropicCredentialRef("default", options.service));
+}
 // src/discovery.ts
 var MAX_MODEL_ID_CHARS = 256;
 var MAX_DISPLAY_NAME_CHARS = 512;
@@ -2237,10 +2327,10 @@ async function startCodexLogin(store, options) {
     throw capabilityRefusal("the codex token exchange returned no ChatGPT account id, so the credential has no per-account record to occupy (R6-10)");
   }
   const ref = codexCredentialRef(tokens.accountId, options.service);
-  await store.set(ref, materialFor2(tokens));
+  await store.set(ref, materialFor(tokens));
   return { ref, accountId: tokens.accountId, expiresAt: tokens.expiresAt };
 }
-function materialFor2(tokens) {
+function materialFor(tokens) {
   return {
     kind: "oauth",
     accessToken: tokens.accessToken,
@@ -2436,7 +2526,7 @@ function decodeSubject(idToken) {
     return;
   }
 }
-function materialFor3(tokens, accountId) {
+function materialFor2(tokens, accountId) {
   return {
     kind: "oauth",
     accessToken: tokens.accessToken,
@@ -2470,7 +2560,7 @@ async function startXaiLogin(store, options = {}) {
     throw capabilityRefusal("the xAI token exchange returned no account subject, so the credential has no per-account record to occupy (R6-10)");
   }
   const ref = xaiCredentialRef(accountId, options.service);
-  await store.set(ref, materialFor3(tokens, accountId));
+  await store.set(ref, materialFor2(tokens, accountId));
   return { ref, accountId, expiresAt: tokens.expiresAt };
 }
 var REFRESH_WINDOW_MS = 60000;
@@ -2749,7 +2839,7 @@ function createHistoryRenderer(registry, options = {}) {
         report.droppedNativeState++;
       report.strippedInDialectBlocks += strippedBlocks;
       const link = message.uuid !== undefined ? chain.get(message.uuid) : undefined;
-      const material = materialFor4(link, source, allowExposed);
+      const material = materialFor3(link, source, allowExposed);
       if (material === undefined) {
         report.withoutMaterial++;
       } else {
@@ -2800,7 +2890,7 @@ function createHistoryRenderer(registry, options = {}) {
     renderWithReport
   };
 }
-function materialFor4(link, source, allowExposed) {
+function materialFor3(link, source, allowExposed) {
   const text = link?.summary;
   if (text === undefined || text.length === 0)
     return;
@@ -3068,10 +3158,11 @@ export {
   BEDROCK_ADAPTER_VERSION,
   BunRequiredError2 as BunRequiredError,
   CODEX_ORIGINATOR2 as CODEX_ORIGINATOR,
-  CONSOLE_OAUTH,
+  CONSOLE_BEARER,
   CREDENTIAL_HEADER_NAMES2 as CREDENTIAL_HEADER_NAMES,
   CredentialResolutionError2 as CredentialResolutionError,
   DEEPSEEK_BASE_URL2 as DEEPSEEK_BASE_URL,
+  DEFAULT_ANTHROPIC_CONSOLE_PROFILE,
   DEFAULT_MAX_REDIRECTS2 as DEFAULT_MAX_REDIRECTS,
   DEFAULT_MAX_RETRIES2 as DEFAULT_MAX_RETRIES,
   DERIVED_XAI,
@@ -3082,7 +3173,6 @@ export {
   GOOGLE_DEFAULT_BASE_URL2 as GOOGLE_DEFAULT_BASE_URL,
   INSTRUCTION_FILE_BASENAMES,
   MIN_DECORATION_BODY_CHARS,
-  OAUTH_REFRESH_WINDOW_MS,
   OPENAI_API_BASE_URL2 as OPENAI_API_BASE_URL,
   OPENAI_CHAT_BASE_URL2 as OPENAI_CHAT_BASE_URL,
   OPENROUTER_BASE_URL2 as OPENROUTER_BASE_URL,
@@ -3103,6 +3193,7 @@ export {
   XAI_OAUTH,
   XAI_OAUTH_ADAPTER_ID,
   activeWinterIdentity2 as activeWinterIdentity,
+  anthropicConsoleProfileExists,
   anthropicCredentialRef,
   applyDecorationToContent,
   applyPrivilegedHeaders2 as applyPrivilegedHeaders,
@@ -3152,6 +3243,7 @@ export {
   isDisallowedAddress2 as isDisallowedAddress,
   isLocalAddressClass2 as isLocalAddressClass,
   isProviderError2 as isProviderError,
+  logoutAnthropicConsole,
   mapAnthropicEffort,
   mapBedrockEffort,
   mapGoogleEffort2 as mapGoogleEffort,
@@ -3166,6 +3258,7 @@ export {
   redactCredentialMaterial2 as redactCredentialMaterial,
   redactMaterial2 as redactMaterial,
   redactRef2 as redactRef,
+  refreshAnthropicBearer,
   refreshOauthMaterial,
   renderIdentityHeaders2 as renderIdentityHeaders,
   requireBunRuntime2 as requireBunRuntime,
@@ -3177,7 +3270,7 @@ export {
   setWinterIdentity2 as setWinterIdentity,
   shouldRequestSummary2 as shouldRequestSummary,
   signRequest2 as signRequest,
-  startAnthropicConsoleLogin,
+  startAnthropicConsoleBrokerLogin,
   startCodexLogin,
   startXaiLogin,
   stripCredentialHeaders2 as stripCredentialHeaders,

package/dist/testing.js

@@ -5,7 +5,6 @@ import {
   requireBunRuntime2,
   hostHeaders2,
   THINKING_ENABLED_NEEDS_BUDGET2,
-  base64Url2,
   googleCompletionMarker2,
   RS2562,
   base64UrlEncode2,
@@ -22,10 +21,11 @@ import {
   computeSignature,
   parseAuthorization2,
   CODEX2,
+  base64Url2,
   QuotaManager2,
   AZURE_PREVIEW_API_VERSION2,
   readableStateOf2
-} from "./index-446qxzss.js";
+} from "./index-r2frr72q.js";
 
 // src/adapters/bedrock/testing.ts
 function encodeHeader(header) {

package/dist/types.d.ts

@@ -45,6 +45,14 @@ export type CredentialMaterial = {
 } | {
     kind: "bearer";
     token: string;
+    /**
+     * P10a-4 (2026-09-13): when the token is host-brokered and renewable (Anthropic Console's
+     * `ant auth print-credentials`, refreshed on a timer ahead of expiry), the host stamps this so
+     * the renewer knows when to run again. OPTIONAL: most `bearer` material (a gateway or proxy
+     * token a host pastes in by hand) has no known expiry, and absence must read as "unknown", not
+     * "already expired" -- the same reasoning `oauth`'s own `expiresAt` already follows below.
+     */
+    expiresAt?: number;
 } | {
     kind: "oauth";
     accessToken: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanlinglabs/winter-provider-runtime",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -42,8 +42,8 @@
     }
   },
   "dependencies": {
-    "@yanlinglabs/winter-agent-sdk": "0.0.5",
-    "@yanlinglabs/winter-provider-catalog": "0.0.5"
+    "@yanlinglabs/winter-agent-sdk": "0.0.6",
+    "@yanlinglabs/winter-provider-catalog": "0.0.6"
   },
   "scripts": {}
 }