@cortexkit/anthropic-auth-core 2.2.6 → 2.2.8

package/dist/index.d.ts

@@ -62,6 +62,7 @@ export type { NativePiAuthSlot, NativePiAuthSlotErrorCode, NativePiAuthSlotInspe
 export { disconnectNativeVaultForHost, NativePiAuthSlotError, nativePiAuthSlotPaths, openNativePiAuthSlot, } from './native-vault-connection.ts';
 export type { NativeVaultQuotaPurpose, NativeVaultRuntime, NativeVaultRuntimeOptions, NativeVaultWatch, NativeVaultWatchOptions, } from './native-vault-runtime.ts';
 export { acquireNativeVaultRuntime, createNativeVaultRuntime, discoverNativeVaultInventory, publishNativeVaultRosterSeed, publishNativeVaultRuntimeSeed, } from './native-vault-runtime.ts';
+export * from './oauth-origin.ts';
 export * from './oauth-profile.ts';
 export { createWindowsOwnerOnly, ensureWindowsOwnerOnlyDirectory, isOwnerOnly, type OwnerOnlyOptions, } from './owner-only.ts';
 export * from './pkce.ts';

package/dist/index.js

@@ -4918,6 +4918,7 @@ async function fetchOAuthQuotaSnapshot(input) {
   const fetchImpl = input.fetchImpl ?? fetch;
   const response = await fetchImpl(QUOTA_URL, {
     method: "GET",
+    redirect: "error",
     headers: {
       Authorization: `Bearer ${input.accessToken}`,
       Accept: "application/json",
@@ -9397,6 +9398,7 @@ async function fetchOAuthAccountProfile(input) {
   assertNotCustodyTombstone(input.accessToken, "anthropic");
   const response = await (input.fetchImpl ?? fetch)(PROFILE_URL, {
     method: "GET",
+    redirect: "error",
     signal: input.signal,
     headers: {
       Authorization: `Bearer ${input.accessToken}`,
@@ -24193,27 +24195,30 @@ function decideStickyQuotaFailure(input) {
   const quota2 = knownQuota(input.quota);
   if (!quota2)
     return { action: "retain", reason: "unknown" };
-  const scoped = getScopedQuotaWindowForModel(quota2, input.modelId);
-  if (scoped && Number.isFinite(scoped.remainingPercent) && scoped.remainingPercent <= 0) {
-    return { action: "migrate", reason: "model-scoped" };
-  }
-  const sevenDay = quota2.seven_day;
-  if (sevenDay && Number.isFinite(sevenDay.remainingPercent) && sevenDay.remainingPercent <= 0) {
-    return { action: "migrate", reason: "seven-day" };
-  }
-  const fiveHour = quota2.five_hour;
-  if (fiveHour && Number.isFinite(fiveHour.remainingPercent) && fiveHour.remainingPercent <= 0) {
-    const resetAt = fiveHour.resetsAt ? Date.parse(fiveHour.resetsAt) : NaN;
-    if (Number.isFinite(resetAt) && resetAt > now && resetAt - now <= STICKY_ROUTING_SHORT_RESET_GRACE_MS) {
-      return {
-        action: "hold",
-        reason: "five-hour-short-reset",
-        retryAfterSeconds: Math.max(1, Math.ceil((resetAt - now) / 1000))
-      };
-    }
-    return { action: "migrate", reason: "five-hour" };
+  let blocking;
+  for (const [reason, window2] of [
+    ["model-scoped", getScopedQuotaWindowForModel(quota2, input.modelId)],
+    ["seven-day", quota2.seven_day],
+    ["five-hour", quota2.five_hour]
+  ]) {
+    if (!window2 || !Number.isFinite(window2.remainingPercent) || window2.remainingPercent > 0)
+      continue;
+    const resetAt = window2.resetsAt ? Date.parse(window2.resetsAt) : NaN;
+    if (!Number.isFinite(resetAt) || resetAt <= now)
+      return { action: "migrate", reason };
+    if (!blocking || resetAt > blocking.resetAt)
+      blocking = { resetAt, reason };
+  }
+  if (!blocking)
+    return { action: "retain", reason: "not-exhausted" };
+  if (blocking.resetAt - now <= STICKY_ROUTING_SHORT_RESET_GRACE_MS) {
+    return {
+      action: "hold",
+      reason: `${blocking.reason}-short-reset`,
+      retryAfterSeconds: Math.max(1, Math.ceil((blocking.resetAt - now) / 1000))
+    };
   }
-  return { action: "retain", reason: "not-exhausted" };
+  return { action: "migrate", reason: blocking.reason };
 }
 function getStickyRoutingStatePath(accountStoragePath) {
   const name = basename6(accountStoragePath);
@@ -25824,8 +25829,10 @@ async function sendViaRelay(options) {
     dumpTag,
     onDumpCreated,
     setTimeoutImpl = globalThis.setTimeout,
-    clearTimeoutImpl = globalThis.clearTimeout
+    clearTimeoutImpl = globalThis.clearTimeout,
+    requireUpstreamUrl
   } = options;
+  requireUpstreamUrl?.(input instanceof Request ? input.url : input.toString());
   if (!config || !isRelayableAnthropicRequest(input, body))
     return fallback();
   const affinity = explicitAffinity || headers.get("x-session-affinity") || headers.get("x-opencode-session");
@@ -25864,6 +25871,11 @@ async function sendViaRelay(options) {
     responseMode ??= requestResponseMode(bodyText);
     return responseMode;
   };
+  let directFallbackStarted = false;
+  const directFallback = () => {
+    directFallbackStarted = true;
+    return fallback();
+  };
   try {
     let result;
     const sendStart = perfNowMs();
@@ -25884,7 +25896,7 @@ async function sendViaRelay(options) {
           payload,
           bodyText,
           requestMode,
-          fallback,
+          fallback: directFallback,
           signal: init?.signal,
           authorizeAttempt
         });
@@ -25895,7 +25907,7 @@ async function sendViaRelay(options) {
         payload,
         bodyText,
         requestMode,
-        fallback,
+        fallback: directFallback,
         signal: init?.signal,
         authorizeAttempt
       });
@@ -25955,6 +25967,10 @@ async function sendViaRelay(options) {
       throw error.failure;
     if (error instanceof RelayResponseMetadataError)
       throw error;
+    if (directFallbackStarted) {
+      relayLog(`direct fallback failed session=${shortAffinity2(affinity)}; not sending it again code=relay_transport_error`);
+      throw error;
+    }
     if (!config.fallbackToDirect) {
       relayLog(`relay failed session=${shortAffinity2(affinity)} and fallbackToDirect=false code=relay_transport_error`);
       throw error;
@@ -26997,11 +27013,12 @@ function createNativeAccountRuntime(options) {
       } catch {
         throw new Error("Claude account identity could not be verified; retry sign-in. No account changes were saved.");
       }
+      const { access, refresh, expires } = input.credential;
       return runtime2.putAccount({
         ...input,
         accountIdentity,
         replace: input.replace ?? true,
-        credential: { type: "oauth", ...input.credential }
+        credential: { type: "oauth", access, refresh, expires }
       });
     },
     async putAccount(input) {
@@ -31350,6 +31367,57 @@ async function disconnectNativeVaultForHost(options) {
     closeNativeVaultAuthority(paths.tokenPath);
   return result;
 }
+// src/oauth-origin.ts
+var ANTHROPIC_OAUTH_ORIGIN = "https://api.anthropic.com";
+var ANTHROPIC_OAUTH_ORIGIN_REFUSAL = "Claude OAuth requests can only go to https://api.anthropic.com. A provider baseURL that points elsewhere is not used for Claude sign-in accounts.";
+
+class AnthropicOAuthOriginError extends Error {
+  check = "oauth_destination";
+  constructor() {
+    super(ANTHROPIC_OAUTH_ORIGIN_REFUSAL);
+    this.name = "AnthropicOAuthOriginError";
+  }
+}
+function sameOrigin(url, origin) {
+  let allowed;
+  try {
+    allowed = new URL(origin);
+  } catch {
+    return false;
+  }
+  return url.protocol === allowed.protocol && url.origin === allowed.origin;
+}
+function requireAnthropicOAuthOrigin(value, options = {}) {
+  const refuse5 = options.refusal ?? (() => new AnthropicOAuthOriginError);
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw refuse5("unparseable");
+  }
+  if (url.username || url.password)
+    throw refuse5("destination");
+  if (url.protocol === "https:" && url.origin === ANTHROPIC_OAUTH_ORIGIN)
+    return url;
+  if (options.extraOrigin && sameOrigin(url, options.extraOrigin))
+    return url;
+  throw refuse5("destination");
+}
+function fetchInputUrl(input) {
+  return input instanceof Request ? input.url : String(input);
+}
+function createAnthropicOAuthFetch(options = {}) {
+  const current = () => typeof options === "function" ? options() : options;
+  return Object.assign(async (input, init) => {
+    requireAnthropicOAuthOrigin(fetchInputUrl(input), current());
+    return fetch(input, { ...init, redirect: "error" });
+  }, {
+    preconnect: (...args) => {
+      requireAnthropicOAuthOrigin(String(args[0]), current());
+      return fetch.preconnect(...args);
+    }
+  });
+}
 // src/prime.ts
 import { createHash as createHash21 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
@@ -33080,6 +33148,7 @@ export {
   resetCache1hState,
   resetBillingHeaderCCH,
   requireNoSupervisedAuthContentSnapshot,
+  requireAnthropicOAuthOrigin,
   requestGzipPadding,
   remapRequestBodyModel,
   remapModelId,
@@ -33315,6 +33384,7 @@ export {
   createNativeCustody,
   createNativeAccountRuntime,
   createEmptyStorage,
+  createAnthropicOAuthFetch,
   countUserPrompts,
   connectClaustrumEnrollmentClient2 as connectClaustrumEnrollmentClient,
   configuredAnthropicOAuthAccountCount,
@@ -33511,8 +33581,11 @@ export {
   CACHE_KEEP_EXTENDED_TTL_BETA,
   CACHE_1H_MODES,
   CACHE_1H_COMMAND_NAME,
+  AnthropicOAuthOriginError,
   AXIOS_USER_AGENT,
   AUTHORIZE_URLS,
+  ANTHROPIC_OAUTH_ORIGIN_REFUSAL,
+  ANTHROPIC_OAUTH_ORIGIN,
   ANTHROPIC_CUSTOM_HEADERS_ENV,
   ACCOUNT_STATE_FILE_NAME,
   ACCOUNT_FILE_NAME

package/dist/oauth-origin.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Where a Claude OAuth access token may be sent.
+ *
+ * A Claude sign-in (OAuth) access token is sent only to Anthropic's own HTTPS
+ * API server, unless a caller explicitly allows one test-only loopback origin
+ * (see `extraOrigin`). Hosts take the request URL from provider configuration,
+ * and that configuration can come from a project file in a repository the
+ * user opened, so the URL alone is not trusted: every OAuth send checks its
+ * final URL here before the token leaves the process. API-key routes are not
+ * checked here; they keep whatever base URL the user configured.
+ */
+export declare const ANTHROPIC_OAUTH_ORIGIN = "https://api.anthropic.com";
+/** Fixed refusal text. It never includes the refused URL or any credential. */
+export declare const ANTHROPIC_OAUTH_ORIGIN_REFUSAL = "Claude OAuth requests can only go to https://api.anthropic.com. A provider baseURL that points elsewhere is not used for Claude sign-in accounts.";
+/**
+ * A Claude OAuth request was refused locally because its destination is not
+ * Anthropic's API server. Nothing was sent, and another account cannot help,
+ * so callers treat it as a terminal request error, not an account failure.
+ */
+export declare class AnthropicOAuthOriginError extends Error {
+    readonly check = "oauth_destination";
+    constructor();
+}
+export interface AnthropicOAuthOriginOptions {
+    /**
+     * One more exact origin (scheme, host and port) the caller accepts besides
+     * Anthropic's. Hosts use it only for a test-only loopback server; it is
+     * never derived from provider configuration.
+     */
+    readonly extraOrigin?: string;
+    /**
+     * Builds the error thrown for a refused URL. `unparseable` means the value
+     * is not a URL at all. Defaults to AnthropicOAuthOriginError for both.
+     */
+    readonly refusal?: (reason: 'unparseable' | 'destination') => Error;
+}
+/**
+ * Returns the parsed URL when an OAuth token may be sent to it: HTTPS on
+ * api.anthropic.com's default port (or the caller's extra origin), with no
+ * user name or password in the URL. Throws otherwise.
+ */
+export declare function requireAnthropicOAuthOrigin(value: string, options?: AnthropicOAuthOriginOptions): URL;
+/**
+ * A fetch for OAuth sends. It checks each URL with
+ * requireAnthropicOAuthOrigin before dispatch and always sets
+ * `redirect: 'error'`, so an approved destination cannot forward the token
+ * elsewhere with a redirect. It calls the global fetch at call time, so test
+ * stubs installed later still apply. Options are read on every call when
+ * given as a function.
+ */
+export declare function createAnthropicOAuthFetch(options?: AnthropicOAuthOriginOptions | (() => AnthropicOAuthOriginOptions)): typeof fetch;

package/dist/relay.d.ts

@@ -76,5 +76,11 @@ export declare function sendViaRelay(options: {
     onDumpCreated?: (handle: import('./dump.ts').DumpHandle) => void;
     setTimeoutImpl?: typeof globalThis.setTimeout;
     clearTimeoutImpl?: typeof globalThis.clearTimeout;
+    /**
+     * Checks the URL the relay will forward to (the envelope's upstream.url)
+     * and throws to refuse it. Runs before anything is sent, relay or direct;
+     * its error reaches the caller unchanged and never triggers a fallback.
+     */
+    requireUpstreamUrl?: (url: string) => unknown;
 }): Promise<Response>;
 export declare const WORKER_SCRIPT = "\nasync function hashBody(body) {\n  const bytes = new TextEncoder().encode(body)\n  const digest = await crypto.subtle.digest('SHA-256', bytes)\n  const hex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('')\n  return 'sha256:' + hex\n}\n\nfunction applyPatch(base, patch) {\n  return base.slice(0, patch.start) + patch.insert + base.slice(patch.start + patch.deleteCount)\n}\n\nfunction applyPatchSet(base, patch) {\n  if (!Array.isArray(patch)) return applyPatch(base, patch)\n  if (patch.length === 0) return base\n\n  let result = ''\n  let cursor = 0\n  for (const item of patch) {\n    if (item.start < cursor) return { error: 'overlapping patch', status: 400 }\n    result += base.slice(cursor, item.start)\n    result += item.insert\n    cursor = item.start + item.deleteCount\n  }\n  return result + base.slice(cursor)\n}\n\nasync function readState(env, affinity) {\n  const raw = await env.RELAY_STATE.get('session:' + affinity)\n  return raw ? JSON.parse(raw) : null\n}\n\nasync function writeState(env, affinity, state) {\n  await env.RELAY_STATE.put('session:' + affinity, JSON.stringify(state), { expirationTtl: 86400 })\n}\n\nasync function resolveBody(env, payload) {\n  if (payload.mode === 'full_sync') return payload.body\n  if (payload.mode === 'patch') {\n    const state = await readState(env, payload.affinity)\n    if (!state || state.hash !== payload.base_hash) {\n      return { error: 'state mismatch', status: 409 }\n    }\n    return applyPatchSet(state.body, payload.patch)\n  }\n  return { error: 'unknown mode', status: 400 }\n}\n\nasync function prepareUpstream(env, payload) {\n  if ((payload.protocol !== 1 && payload.protocol !== 2) || payload.type !== 'request' || !payload.affinity || !payload.upstream?.url || !payload.next_hash) {\n    return { error: 'invalid payload', status: 400 }\n  }\n\n  const body = await resolveBody(env, payload)\n  if (body && typeof body === 'object' && 'error' in body) return body\n\n  if (typeof body !== 'string' || (await hashBody(body)) !== payload.next_hash) {\n    return { error: 'hash mismatch', status: 409 }\n  }\n\n  const stateWrite = writeState(env, payload.affinity, { body, hash: payload.next_hash, revision: payload.revision }).catch(() => {})\n  console.log(JSON.stringify({\n    relay: 'opencode-anthropic-auth',\n    transport: 'relay',\n    mode: payload.mode,\n    revision: payload.revision,\n    affinity: String(payload.affinity).slice(0, 12),\n    bodyBytes: body.length,\n  }))\n\n  return { body, stateWrite }\n}\n\nfunction resolveBodyFromState(state, payload) {\n  if (payload.mode === 'full_sync') return payload.body\n  if (payload.mode === 'patch') {\n    if (!state || state.hash !== payload.base_hash) {\n      return { error: 'state mismatch', status: 409 }\n    }\n    return applyPatchSet(state.body, payload.patch)\n  }\n  return { error: 'unknown mode', status: 400 }\n}\n\nfunction deferWorkerTask(task) {\n  return new Promise((resolve) => setTimeout(resolve, 0)).then(task)\n}\n\nconst WEBSOCKET_STREAM_FLUSH_BYTES = 1024\nconst WEBSOCKET_STREAM_FLUSH_MS = 20\n\nfunction createWebSocketStreamCoalescer(socket, options = {}) {\n  const flushBytes = options.flushBytes || WEBSOCKET_STREAM_FLUSH_BYTES\n  const flushMs = options.flushMs ?? WEBSOCKET_STREAM_FLUSH_MS\n  let chunks = []\n  let byteLength = 0\n  let flushTimer = null\n  const stats = {\n    upstreamChunks: 0,\n    upstreamBytes: 0,\n    frames: 0,\n    frameBytes: 0,\n  }\n\n  const clearFlushTimer = () => {\n    if (flushTimer === null) return\n    clearTimeout(flushTimer)\n    flushTimer = null\n  }\n\n  const mergeChunks = () => {\n    if (chunks.length === 1) return chunks[0]\n    const frame = new Uint8Array(byteLength)\n    let offset = 0\n    for (const chunk of chunks) {\n      frame.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n    return frame\n  }\n\n  const flush = () => {\n    clearFlushTimer()\n    if (byteLength === 0) return\n    const frame = mergeChunks()\n    chunks = []\n    byteLength = 0\n    socket.send(frame)\n    stats.frames += 1\n    stats.frameBytes += frame.byteLength\n  }\n\n  const scheduleFlush = () => {\n    if (flushTimer !== null) return\n    flushTimer = setTimeout(flush, flushMs)\n  }\n\n  return {\n    push(value) {\n      const chunk = value instanceof Uint8Array ? value : new Uint8Array(value)\n      if (chunk.byteLength === 0) return\n      stats.upstreamChunks += 1\n      stats.upstreamBytes += chunk.byteLength\n      chunks.push(chunk)\n      byteLength += chunk.byteLength\n      if (byteLength >= flushBytes) flush()\n      else scheduleFlush()\n    },\n    flush,\n    stats() {\n      return { ...stats, pendingBytes: byteLength }\n    },\n  }\n}\n\nfunction checkpointWebSocketState(env, payload, body, nextState) {\n  return deferWorkerTask(async () => {\n    try {\n      if ((await hashBody(body)) !== payload.next_hash) {\n        throw new Error('hash mismatch')\n      }\n      await writeState(env, payload.affinity, nextState)\n    } catch {\n      console.log(JSON.stringify({\n        relay: 'opencode-anthropic-auth',\n        transport: 'websocket',\n        event: 'checkpoint_write_failed',\n        affinity: String(payload.affinity).slice(0, 12),\n        code: 'checkpoint_write_error',\n      }))\n    }\n  })\n}\n\nasync function prepareWebSocketUpstream(env, state, payload) {\n  if (payload.protocol !== 2 || payload.type !== 'request' || !payload.id || !payload.affinity || !payload.upstream?.url || !payload.next_hash) {\n    return { error: 'invalid payload', status: 400 }\n  }\n\n  const body = resolveBodyFromState(state, payload)\n  if (body && typeof body === 'object' && 'error' in body) return body\n  if (typeof body !== 'string') return { error: 'invalid body', status: 400 }\n  if ((await hashBody(body)) !== payload.next_hash) {\n    return { error: 'hash mismatch', status: 409 }\n  }\n\n  const nextState = { body, hash: payload.next_hash, revision: payload.revision }\n  const checkpoint = checkpointWebSocketState(env, payload, body, nextState)\n  const logAccepted = () => console.log(JSON.stringify({\n    relay: 'opencode-anthropic-auth',\n    transport: 'websocket',\n    mode: payload.mode,\n    revision: payload.revision,\n    affinity: String(payload.affinity).slice(0, 12),\n    bodyBytes: body.length,\n  }))\n\n  return { body, state: nextState, checkpoint, logAccepted }\n}\n\nfunction headersToObject(headers) {\n  const result = {}\n  for (const [key, value] of headers.entries()) result[key] = value\n  return result\n}\n\nasync function handleRelayPayload(env, payload) {\n  const prepared = await prepareUpstream(env, payload)\n  if (prepared.error) return prepared\n  const upstream = await fetch(payload.upstream.url, {\n    method: payload.upstream.method || 'POST',\n    headers: payload.upstream.headers,\n    body: prepared.body,\n  })\n  return { upstream, stateWrite: prepared.stateWrite }\n}\n\nasync function handleWebSocket(socket, env, ctx, payload, getState, setState) {\n  const heartbeat = setInterval(() => {\n    try {\n      socket.send(JSON.stringify({ protocol: 2, type: 'keepalive' }))\n    } catch {\n      clearInterval(heartbeat)\n    }\n  }, 15000)\n  let streamCoalescer = null\n  try {\n    const result = await prepareWebSocketUpstream(env, getState(), payload)\n    if (result.error) {\n      socket.send(JSON.stringify({ protocol: 2, type: 'error', id: payload.id, status: result.status, message: result.error }))\n      return\n    }\n\n    setState(result.state)\n    socket.send(JSON.stringify({ protocol: 2, type: 'accepted', id: payload.id, hash: result.state.hash, revision: result.state.revision }))\n    ctx?.waitUntil?.(deferWorkerTask(result.logAccepted))\n\n    const upstreamPromise = fetch(payload.upstream.url, {\n      method: payload.upstream.method || 'POST',\n      headers: payload.upstream.headers,\n      body: result.body,\n    })\n    ctx?.waitUntil?.(result.checkpoint)\n    const upstream = await upstreamPromise\n    socket.send(JSON.stringify({\n      protocol: 2,\n      type: 'response_start',\n      id: payload.id,\n      status: upstream.status,\n      statusText: upstream.statusText,\n      headers: headersToObject(upstream.headers),\n    }))\n\n    const reader = upstream.body?.getReader()\n    if (reader) {\n      streamCoalescer = createWebSocketStreamCoalescer(socket)\n      while (true) {\n        const { done, value } = await reader.read()\n        if (done) break\n        streamCoalescer.push(value)\n      }\n      streamCoalescer.flush()\n    }\n    const stats = streamCoalescer?.stats?.() || {}\n    socket.send(JSON.stringify({ protocol: 2, type: 'done', id: payload.id, ...stats }))\n  } catch (error) {\n    try {\n      streamCoalescer?.flush?.()\n    } catch {}\n    socket.send(JSON.stringify({ protocol: 2, type: 'error', id: payload.id, status: 500, message: error instanceof Error ? error.message : String(error) }))\n  } finally {\n    clearInterval(heartbeat)\n  }\n}\n\nexport default {\n  async fetch(request, env, ctx) {\n    if (request.headers.get('Upgrade') === 'websocket') {\n      const url = new URL(request.url)\n      const token = url.searchParams.get('token')\n      const affinity = url.searchParams.get('affinity')\n      if (token !== env.RELAY_TOKEN) return new Response('unauthorized', { status: 401 })\n      if (!affinity) return new Response('missing affinity', { status: 400 })\n      const pair = new WebSocketPair()\n      const client = pair[0]\n      const server = pair[1]\n      server.binaryType = 'arraybuffer'\n      let state = null\n      let ready = false\n      server.accept()\n      const loadState = readState(env, affinity).then((loadedState) => {\n        state = loadedState\n        ready = true\n        server.send(JSON.stringify({\n          protocol: 2,\n          type: 'ready',\n          state: state ? { hash: state.hash, revision: state.revision } : null,\n        }))\n      }).catch((error) => {\n        server.send(JSON.stringify({ protocol: 2, type: 'error', status: 500, message: error instanceof Error ? error.message : String(error) }))\n        server.close(1011, 'state load failed')\n      })\n      ctx?.waitUntil?.(loadState)\n      if (!ctx?.waitUntil) void loadState\n      let busy = false\n      server.addEventListener('message', (event) => {\n        if (!ready) {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 425, message: 'relay state is not ready' }))\n          return\n        }\n        if (busy) {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 429, message: 'request already in flight' }))\n          return\n        }\n        let payload\n        try {\n          payload = JSON.parse(event.data)\n        } catch {\n          server.send(JSON.stringify({ protocol: 2, type: 'error', status: 400, message: 'invalid JSON payload' }))\n          return\n        }\n        payload.affinity = affinity\n        busy = true\n        const run = handleWebSocket(server, env, ctx, payload, () => state, (nextState) => { state = nextState }).finally(() => { busy = false })\n        ctx?.waitUntil?.(run)\n        if (!ctx?.waitUntil) void run\n      })\n      return new Response(null, { status: 101, webSocket: client })\n    }\n\n    if (request.method === 'GET') {\n      return Response.json({ status: 'ok', transports: ['http', 'websocket'] })\n    }\n    if (request.method !== 'POST') return new Response('method not allowed', { status: 405 })\n    if (request.headers.get('x-relay-token') !== env.RELAY_TOKEN) {\n      return new Response('unauthorized', { status: 401 })\n    }\n\n    try {\n      const payload = await request.json()\n      const result = await handleRelayPayload(env, payload)\n      if (result.error) return Response.json({ error: result.error }, { status: result.status })\n\n      if (result.stateWrite) ctx.waitUntil(result.stateWrite)\n\n      const upstream = result.upstream\n      return new Response(upstream.body, {\n        status: upstream.status,\n        statusText: upstream.statusText,\n        headers: upstream.headers,\n      })\n    } catch (error) {\n      return Response.json(\n        { error: error instanceof Error ? error.message : 'internal relay error' },\n        { status: 502 },\n      )\n    }\n  },\n}\n";

package/dist/sticky-routing.d.ts

@@ -45,7 +45,7 @@ export type StickyQuotaFailureDecision = {
     reason: 'not-exhausted' | 'unknown';
 } | {
     action: 'hold';
-    reason: 'five-hour-short-reset';
+    reason: 'five-hour-short-reset' | 'seven-day-short-reset' | 'model-scoped-short-reset';
     retryAfterSeconds: number;
 } | {
     action: 'migrate';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "type": "module",
   "repository": {
     "type": "git",