@cortexkit/anthropic-auth-core 1.4.1 → 1.6.0

package/dist/relay.js

@@ -241,6 +241,22 @@ function toBinaryChunk(data) {
 function parseRelayControlMessage(data) {
     return JSON.parse(data);
 }
+function formatCloseEvent(event) {
+    const close = event;
+    const parts = [
+        `code=${close.code ?? 'unknown'}`,
+        `wasClean=${close.wasClean ?? 'unknown'}`,
+    ];
+    if (close.reason)
+        parts.push(`reason=${JSON.stringify(close.reason)}`);
+    return parts.join(' ');
+}
+function relayControlErrorMessage(message) {
+    const detail = message.message || 'relay websocket error';
+    return message.status
+        ? `relay websocket error ${message.status}: ${detail}`
+        : detail;
+}
 class PersistentRelaySession {
     config;
     affinity;
@@ -358,7 +374,7 @@ class PersistentRelaySession {
                 reject(error);
                 this.failPending(error);
             });
-            socket.addEventListener('close', () => {
+            socket.addEventListener('close', (event) => {
                 clearTimeout(timeout);
                 if (this.socket === socket) {
                     this.socket = undefined;
@@ -368,9 +384,16 @@ class PersistentRelaySession {
                 if (this.pending) {
                     if (this.pending.retryingBeforeResponse)
                         return;
-                    if (this.retryPendingBeforeResponse(this.pending, 'closed before response'))
+                    const closedAfterResponseStart = this.pending.responseStartedAt != null;
+                    const reason = closedAfterResponseStart
+                        ? 'closed after response_start before stream bytes'
+                        : 'closed before response';
+                    if (this.retryPendingBeforeResponse(this.pending, reason, event))
                         return;
-                    const error = new Error('relay websocket closed before response');
+                    const error = new Error(closedAfterResponseStart
+                        ? 'relay websocket closed during response stream'
+                        : 'relay websocket closed before response');
+                    relayLog(`websocket ${closedAfterResponseStart ? 'closed during response stream' : 'closed before response without retry'} session=${shortAffinity(this.affinity)} request=${this.pending.payload.id} chunks=${this.pending.streamChunkCount} bytes=${this.pending.streamByteCount} ${formatCloseEvent(event)}`);
                     this.failPending(error);
                 }
             });
@@ -404,6 +427,8 @@ class PersistentRelaySession {
                 rejectDone,
                 sentAt,
                 optimisticResponse,
+                streamChunkCount: 0,
+                streamByteCount: 0,
                 retryAttempts: 0,
                 retryingBeforeResponse: false,
             };
@@ -430,8 +455,8 @@ class PersistentRelaySession {
             this.socket?.close();
         }, 45_000);
     }
-    retryPendingBeforeResponse(pending, reason) {
-        if (pending.responseStartedAt != null)
+    retryPendingBeforeResponse(pending, reason, closeEvent) {
+        if (pending.responseStartedAt != null && pending.streamByteCount > 0)
             return false;
         if (pending.streamDone)
             return false;
@@ -442,7 +467,7 @@ class PersistentRelaySession {
         clearTimeout(pending.timeout);
         const attempt = pending.retryAttempts;
         const originalId = pending.payload.id;
-        relayLog(`websocket ${reason}; reconnecting and retrying full_sync session=${shortAffinity(this.affinity)} request=${originalId} retry=${attempt}`);
+        relayLog(`websocket ${reason}; reconnecting and retrying full_sync session=${shortAffinity(this.affinity)} request=${originalId} retry=${attempt} chunks=${pending.streamChunkCount} bytes=${pending.streamByteCount}${closeEvent ? ` ${formatCloseEvent(closeEvent)}` : ''}`);
         this.socket?.close();
         this.socket = undefined;
         this.serverState = undefined;
@@ -478,11 +503,16 @@ class PersistentRelaySession {
         })();
         return true;
     }
+    enqueueStreamChunk(pending, chunk) {
+        pending.streamChunkCount += 1;
+        pending.streamByteCount += chunk.byteLength;
+        pending.streamController?.enqueue(chunk);
+    }
     handleBinaryChunk(data) {
         const pending = this.pending;
         if (!pending?.responseStarted)
             return;
-        pending.streamController?.enqueue(toBinaryChunk(data));
+        this.enqueueStreamChunk(pending, toBinaryChunk(data));
     }
     resolvePendingResponse(pending, status, statusText, headers) {
         if (pending.responseStarted)
@@ -536,7 +566,7 @@ class PersistentRelaySession {
             return;
         }
         if (message.type === 'chunk') {
-            pending.streamController?.enqueue(decodeRelayChunk(message.base64));
+            this.enqueueStreamChunk(pending, decodeRelayChunk(message.base64));
             return;
         }
         if (message.type === 'done') {
@@ -549,7 +579,7 @@ class PersistentRelaySession {
             // would reject a settled promise and leave the stream hanging. Instead,
             // 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'}`);
+                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}`);
                 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();
@@ -561,7 +591,7 @@ class PersistentRelaySession {
             }
             const error = message.status === 409
                 ? new RelayStateMismatchError(message.message || 'state mismatch')
-                : new Error(message.message || 'relay websocket error');
+                : new Error(relayControlErrorMessage(message));
             this.failPending(error);
         }
     }
@@ -570,7 +600,7 @@ class PersistentRelaySession {
         if (!pending)
             return;
         const finishedAt = perfNowMs();
-        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)}`);
+        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}`);
         clearTimeout(pending.timeout);
         if (!pending.streamDone) {
             pending.streamDone = true;

package/package.json

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