@sunerpy/opencode-kiro-auth 0.13.2 → 0.13.4

package/dist/core/request/request-handler.js

@@ -74,14 +74,27 @@ export class RequestHandler {
             abortFromInbound();
         else
             inboundSignal?.addEventListener('abort', abortFromInbound, { once: true });
-        const timeout = setDeadlineTimeout(() => requestController.abort(new DOMException('Kiro request timed out', 'TimeoutError')), this.config.request_timeout_ms);
+        let timeout;
+        const beginUpstreamWait = (phase) => {
+            if (requestController.signal.aborted)
+                return;
+            if (timeout)
+                clearDeadlineTimeout(timeout);
+            timeout = setDeadlineTimeout(() => requestController.abort(new DOMException(`Kiro request timed out waiting for ${phase}`, 'TimeoutError')), this.config.request_timeout_ms);
+        };
+        const endUpstreamWait = () => {
+            if (!timeout)
+                return;
+            clearDeadlineTimeout(timeout);
+            timeout = undefined;
+        };
         let requestCleanupDone = false;
         let responseOwnsLifecycle = false;
         const cleanupRequest = () => {
             if (requestCleanupDone)
                 return;
             requestCleanupDone = true;
-            clearDeadlineTimeout(timeout);
+            endUpstreamWait();
             inboundSignal?.removeEventListener('abort', abortFromInbound);
         };
         const signal = requestController.signal;
@@ -187,13 +200,22 @@ export class RequestHandler {
                         this.handleSuccessfulRequest(acc);
                         await this.usageTracker.syncUsage(acc, auth, isCurrentAttempt);
                     };
-                    const sdkResponse = await client.send(command, { abortSignal: signal });
+                    let sdkResponse;
+                    beginUpstreamWait('SDK response');
+                    try {
+                        sdkResponse = await client.send(command, { abortSignal: signal });
+                    }
+                    finally {
+                        endUpstreamWait();
+                    }
                     sendResolved = true;
                     if (apiTimestamp) {
                         this.logSdkResponse(sdkPrep, apiTimestamp);
                     }
                     const response = await this.responseHandler.handleSdkSuccess(sdkResponse, model, sdkPrep.conversationId, sdkPrep.streaming, {
                         signal,
+                        onUpstreamWaitStart: () => beginUpstreamWait('stream event'),
+                        onUpstreamWaitEnd: endUpstreamWait,
                         onComplete: completeRequest,
                         onTerminal: cleanupRequest,
                         onCancel: (reason) => requestController.abort(reason),

package/dist/core/request/response-handler.d.ts

@@ -1,6 +1,8 @@
 import { SdkEventStreamIterationError } from './stream-error.js';
 export interface SdkResponseLifecycle {
     signal?: AbortSignal;
+    onUpstreamWaitStart?: () => void;
+    onUpstreamWaitEnd?: () => void;
     onComplete?: () => void | Promise<void>;
     onTerminal?: () => void;
     onCancel?: (reason: unknown) => void;

package/dist/core/request/response-handler.js

@@ -11,7 +11,7 @@ async function closeIterator(iterator) {
     }
     catch { }
 }
-function wrapSdkEventStream(sdkResponse, signal) {
+function wrapSdkEventStream(sdkResponse, signal, onUpstreamWaitStart, onUpstreamWaitEnd) {
     const eventStream = sdkResponse.generateAssistantResponseResponse;
     if (!eventStream || typeof eventStream[Symbol.asyncIterator] !== 'function') {
         return { response: sdkResponse, closeRaw: async () => { } };
@@ -25,28 +25,34 @@ function wrapSdkEventStream(sdkResponse, signal) {
         await closeIterator(rawIterator);
     };
     const nextRaw = async () => {
-        if (!signal)
-            return rawIterator.next();
-        if (signal.aborted) {
+        if (signal?.aborted) {
             await closeRaw();
             throw abortReason(signal);
         }
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const settle = (callback) => {
-                if (settled)
-                    return;
-                settled = true;
-                signal.removeEventListener('abort', onAbort);
-                callback();
-            };
-            const onAbort = () => {
-                void closeRaw();
-                settle(() => reject(abortReason(signal)));
-            };
-            signal.addEventListener('abort', onAbort, { once: true });
-            Promise.resolve(rawIterator.next()).then((result) => settle(() => resolve(result)), (error) => settle(() => reject(error)));
-        });
+        onUpstreamWaitStart?.();
+        try {
+            if (!signal)
+                return await rawIterator.next();
+            return await new Promise((resolve, reject) => {
+                let settled = false;
+                const settle = (callback) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    signal.removeEventListener('abort', onAbort);
+                    callback();
+                };
+                const onAbort = () => {
+                    void closeRaw();
+                    settle(() => reject(abortReason(signal)));
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                Promise.resolve(rawIterator.next()).then((result) => settle(() => resolve(result)), (error) => settle(() => reject(error)));
+            });
+        }
+        finally {
+            onUpstreamWaitEnd?.();
+        }
     };
     const wrappedIterator = {
         async next() {
@@ -94,7 +100,7 @@ export class ResponseHandler {
         if (streaming) {
             return this.handleSdkStreaming(sdkResponse, model, conversationId, lifecycle);
         }
-        return this.handleSdkNonStreaming(sdkResponse, model, conversationId, lifecycle.signal);
+        return this.handleSdkNonStreaming(sdkResponse, model, conversationId, lifecycle);
     }
     async handleStreaming(response, model, conversationId) {
         const s = transformKiroStream(response, model, conversationId);
@@ -113,7 +119,7 @@ export class ResponseHandler {
         }), { headers: { 'Content-Type': 'text/event-stream' } });
     }
     async handleSdkStreaming(sdkResponse, model, conversationId, lifecycle) {
-        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal);
+        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd);
         const transformed = transformSdkStream(wrapped.response, model, conversationId);
         const buffered = [];
         let firstSemantic;
@@ -215,14 +221,14 @@ export class ResponseHandler {
             }
         }, { highWaterMark: 0 }), { headers: { 'Content-Type': 'text/event-stream' } });
     }
-    async handleSdkNonStreaming(sdkResponse, model, conversationId, signal) {
+    async handleSdkNonStreaming(sdkResponse, model, conversationId, lifecycle) {
         // For non-streaming SDK responses, collect all events
         let content = '';
         let reasoningContent = '';
         const toolCalls = [];
         let inputTokens = 0;
         let outputTokens = 0;
-        const wrapped = wrapSdkEventStream(sdkResponse, signal);
+        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd);
         const eventStream = wrapped.response.generateAssistantResponseResponse;
         if (eventStream) {
             try {
@@ -243,7 +249,7 @@ export class ResponseHandler {
                 }
             }
             finally {
-                if (signal?.aborted)
+                if (lifecycle.signal?.aborted)
                     await wrapped.closeRaw();
             }
         }

package/dist/core/request/retry-strategy.d.ts

@@ -1,10 +1,8 @@
 interface RetryConfig {
     max_request_iterations: number;
-    request_timeout_ms: number;
 }
 interface RetryContext {
     iterations: number;
-    startTime: number;
 }
 export declare class RetryStrategy {
     private config;

package/dist/core/request/retry-strategy.js

@@ -11,18 +11,11 @@ export class RetryStrategy {
                 error: `Exceeded max iterations (${this.config.max_request_iterations})`
             };
         }
-        if (Date.now() - context.startTime > this.config.request_timeout_ms) {
-            return {
-                canContinue: false,
-                error: 'Request timeout'
-            };
-        }
         return { canContinue: true };
     }
     createContext() {
         return {
-            iterations: 0,
-            startTime: Date.now()
+            iterations: 0
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sunerpy/opencode-kiro-auth",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",