@cortexkit/anthropic-auth-core 1.16.0 → 1.18.0

package/dist/relay.js

@@ -323,12 +323,12 @@ class PersistentRelaySession {
         this.serverState = undefined;
         this.connecting = undefined;
     }
-    send(payload, bodyText, optimisticResponse = false) {
+    send(payload, bodyText, optimisticResponse = false, onResponseHeaders) {
         this.touch();
         const enqueuedAt = perfNowMs();
         const start = this.queue
             .catch(() => { })
-            .then(() => this.startQueued(payload, bodyText, enqueuedAt, optimisticResponse));
+            .then(() => this.startQueued(payload, bodyText, enqueuedAt, optimisticResponse, onResponseHeaders));
         const result = start.then(async ({ response, getPayload }) => ({
             response: await response,
             payload: getPayload(),
@@ -339,7 +339,7 @@ class PersistentRelaySession {
         this.queue = start.then(({ done }) => done.catch(() => { }), () => { });
         return result;
     }
-    async startQueued(payload, bodyText, enqueuedAt, optimisticResponse) {
+    async startQueued(payload, bodyText, enqueuedAt, optimisticResponse, onResponseHeaders) {
         const connectStart = perfNowMs();
         await this.ensureConnected();
         const connectedAt = perfNowMs();
@@ -363,7 +363,7 @@ class PersistentRelaySession {
         }
         relayLog(`perf websocket send_start session=${shortAffinity(this.affinity)} request=${requestPayload.id} mode=${requestPayload.mode} queueMs=${formatMs(connectedAt - enqueuedAt)} connectMs=${formatMs(connectedAt - connectStart)} bodyBytes=${bodyText.length} relayBytes=${JSON.stringify(requestPayload).length}`);
         let activePayload = requestPayload;
-        const first = this.sendPayload(requestPayload, bodyText, optimisticResponse);
+        const first = this.sendPayload(requestPayload, bodyText, optimisticResponse, onResponseHeaders);
         void first.done.catch(() => { });
         let activeDone = first.done;
         const response = first.response.catch((error) => {
@@ -376,7 +376,7 @@ class PersistentRelaySession {
             fullSync.id = createRequestId();
             fullSync.revision = (this.serverState?.revision ?? 0) + 1;
             activePayload = fullSync;
-            const retry = this.sendPayload(fullSync, bodyText, optimisticResponse);
+            const retry = this.sendPayload(fullSync, bodyText, optimisticResponse, onResponseHeaders);
             void retry.done.catch(() => { });
             activeDone = retry.done;
             return retry.response;
@@ -457,7 +457,7 @@ class PersistentRelaySession {
         });
         await this.connecting;
     }
-    sendPayload(payload, bodyText, optimisticResponse) {
+    sendPayload(payload, bodyText, optimisticResponse, onResponseHeaders) {
         const socket = this.socket;
         if (!socket || socket.readyState !== WebSocket.OPEN) {
             throw new Error('relay websocket is not connected');
@@ -486,6 +486,9 @@ class PersistentRelaySession {
                 streamByteCount: 0,
                 retryAttempts: 0,
                 retryingBeforeResponse: false,
+                onResponseHeaders,
+                stagedResponseHeaders: undefined,
+                responseHeadersDelivered: false,
             };
             this.pending = pending;
             this.resetPendingTimeout(pending);
@@ -540,6 +543,8 @@ class PersistentRelaySession {
                 pending.accepted = false;
                 pending.acceptedAt = undefined;
                 pending.responseStartedAt = undefined;
+                pending.stagedResponseHeaders = undefined;
+                pending.responseHeadersDelivered = false;
                 pending.sentAt = perfNowMs();
                 pending.retryingBeforeResponse = false;
                 const socket = this.socket;
@@ -559,10 +564,21 @@ class PersistentRelaySession {
         return true;
     }
     enqueueStreamChunk(pending, chunk) {
+        this.deliverResponseHeaders(pending);
         pending.streamChunkCount += 1;
         pending.streamByteCount += chunk.byteLength;
         pending.streamController?.enqueue(chunk);
     }
+    deliverResponseHeaders(pending) {
+        if (pending.responseHeadersDelivered ||
+            pending.stagedResponseHeaders == null)
+            return;
+        pending.responseHeadersDelivered = true;
+        try {
+            pending.onResponseHeaders?.(pending.stagedResponseHeaders);
+        }
+        catch { }
+    }
     handleBinaryChunk(data) {
         const pending = this.pending;
         if (!pending?.responseStarted)
@@ -609,12 +625,17 @@ class PersistentRelaySession {
             return;
         }
         if (message.type === 'response_start') {
+            if (pending.responseStartedAt != null)
+                return;
             const responseStartedAt = perfNowMs();
             pending.responseStartedAt = responseStartedAt;
             relayLog(`perf websocket response_start session=${shortAffinity(this.affinity)} request=${pending.payload.id} sentMs=${formatMs(responseStartedAt - pending.sentAt)} upstreamMs=${pending.acceptedAt == null ? 'unknown' : formatMs(responseStartedAt - pending.acceptedAt)} status=${message.status}`);
             clearTimeout(pending.timeout);
+            if (message.headers)
+                pending.stagedResponseHeaders = new Headers(message.headers);
             this.resolvePendingResponse(pending, message.status, message.statusText, message.headers);
             if (pending.optimisticResponse && message.status >= 400) {
+                this.deliverResponseHeaders(pending);
                 pending.streamController?.enqueue(new TextEncoder().encode(`event: error\ndata: ${JSON.stringify({ type: 'error', error: { type: 'relay_upstream_error', message: `Relay upstream returned HTTP ${message.status}` } })}\n\n`));
                 this.finishPending();
             }
@@ -635,6 +656,7 @@ class PersistentRelaySession {
             // inject an SSE error event and close cleanly.
             if (pending.optimisticResponse && pending.responseStartedAt != null) {
                 relayLog(`websocket relay error during optimistic response session=${shortAffinity(this.affinity)} request=${pending.payload.id} status=${message.status} message=${message.message || 'unknown'} chunks=${pending.streamChunkCount} bytes=${pending.streamByteCount}`);
+                this.deliverResponseHeaders(pending);
                 pending.streamController?.enqueue(new TextEncoder().encode(`event: error\ndata: ${JSON.stringify({ type: 'error', error: { type: 'relay_error', message: message.message || 'relay error' } })}\n\n`));
                 this.finishPending();
                 this.socket?.close();
@@ -661,6 +683,7 @@ class PersistentRelaySession {
         relayLog(`perf websocket done session=${shortAffinity(this.affinity)} request=${pending.payload.id} sentMs=${formatMs(finishedAt - pending.sentAt)} streamMs=${pending.responseStartedAt == null ? 'unknown' : formatMs(finishedAt - pending.responseStartedAt)} chunks=${pending.streamChunkCount} bytes=${pending.streamByteCount}${workerStats}`);
         clearTimeout(pending.timeout);
         if (!pending.streamDone) {
+            this.deliverResponseHeaders(pending);
             pending.streamDone = true;
             pending.streamController?.close();
         }
@@ -727,7 +750,7 @@ function getPersistentRelaySession(config, affinity) {
     return session;
 }
 export async function sendViaRelay(options) {
-    const { config, input, init, headers, body, fallback, affinity: explicitAffinity, optimisticResponse, } = options;
+    const { config, input, init, headers, body, fallback, affinity: explicitAffinity, optimisticResponse, onResponseHeaders, } = options;
     if (!config || !isRelayableAnthropicRequest(input, body))
         return fallback();
     const affinity = explicitAffinity ||
@@ -769,7 +792,7 @@ export async function sendViaRelay(options) {
         if (config.transport === 'websocket') {
             try {
                 const session = getPersistentRelaySession(config, affinity);
-                result = await session.send(payload, bodyText, optimisticResponse === true);
+                result = await session.send(payload, bodyText, optimisticResponse === true, onResponseHeaders);
             }
             catch (error) {
                 relayLog(`websocket relay failed session=${shortAffinity(affinity)}; trying http relay: ${error instanceof Error ? error.message : String(error)}`);
@@ -802,6 +825,12 @@ export async function sendViaRelay(options) {
         });
         if (!result.usedRelay)
             return result.response;
+        if (result.transport === 'http') {
+            try {
+                onResponseHeaders?.(result.response.headers);
+            }
+            catch { }
+        }
         if (result.transport === 'http') {
             updateLocalRelayState(affinity, bodyText, result.payload.next_hash, result.payload.revision);
         }

package/dist/token-fingerprint.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Stable, non-reversible fingerprint used to bind persisted state to an access
+ * token without storing another copy of the credential.
+ */
+export declare function tokenFingerprint(token: string): string;

package/dist/token-fingerprint.js

@@ -0,0 +1,8 @@
+import { createHash } from 'node:crypto';
+/**
+ * Stable, non-reversible fingerprint used to bind persisted state to an access
+ * token without storing another copy of the credential.
+ */
+export function tokenFingerprint(token) {
+    return createHash('sha256').update(token).digest('hex').slice(0, 16);
+}

package/package.json

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