@sunerpy/opencode-kiro-auth 0.13.3 → 0.13.5

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

@@ -75,22 +75,26 @@ export class RequestHandler {
         else
             inboundSignal?.addEventListener('abort', abortFromInbound, { once: true });
         let timeout;
-        const refreshRequestDeadline = () => {
+        const beginUpstreamWait = (phase, timeoutMs) => {
             if (requestController.signal.aborted)
                 return;
             if (timeout)
                 clearDeadlineTimeout(timeout);
-            timeout = setDeadlineTimeout(() => requestController.abort(new DOMException('Kiro request timed out', 'TimeoutError')), this.config.request_timeout_ms);
+            timeout = setDeadlineTimeout(() => requestController.abort(new DOMException(`Kiro request timed out waiting for ${phase}`, 'TimeoutError')), timeoutMs);
+        };
+        const endUpstreamWait = () => {
+            if (!timeout)
+                return;
+            clearDeadlineTimeout(timeout);
+            timeout = undefined;
         };
-        refreshRequestDeadline();
         let requestCleanupDone = false;
         let responseOwnsLifecycle = false;
         const cleanupRequest = () => {
             if (requestCleanupDone)
                 return;
             requestCleanupDone = true;
-            if (timeout)
-                clearDeadlineTimeout(timeout);
+            endUpstreamWait();
             inboundSignal?.removeEventListener('abort', abortFromInbound);
         };
         const signal = requestController.signal;
@@ -196,15 +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', this.config.sdk_response_timeout_ms);
+                    try {
+                        sdkResponse = await client.send(command, { abortSignal: signal });
+                    }
+                    finally {
+                        endUpstreamWait();
+                    }
                     sendResolved = true;
-                    refreshRequestDeadline();
                     if (apiTimestamp) {
                         this.logSdkResponse(sdkPrep, apiTimestamp);
                     }
                     const response = await this.responseHandler.handleSdkSuccess(sdkResponse, model, sdkPrep.conversationId, sdkPrep.streaming, {
                         signal,
-                        onActivity: refreshRequestDeadline,
+                        onUpstreamWaitStart: () => beginUpstreamWait('stream event', this.config.request_timeout_ms),
+                        onUpstreamWaitEnd: endUpstreamWait,
                         onComplete: completeRequest,
                         onTerminal: cleanupRequest,
                         onCancel: (reason) => requestController.abort(reason),

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

@@ -1,7 +1,8 @@
 import { SdkEventStreamIterationError } from './stream-error.js';
 export interface SdkResponseLifecycle {
     signal?: AbortSignal;
-    onActivity?: () => void;
+    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, onActivity) {
+function wrapSdkEventStream(sdkResponse, signal, onUpstreamWaitStart, onUpstreamWaitEnd) {
     const eventStream = sdkResponse.generateAssistantResponseResponse;
     if (!eventStream || typeof eventStream[Symbol.asyncIterator] !== 'function') {
         return { response: sdkResponse, closeRaw: async () => { } };
@@ -25,33 +25,34 @@ function wrapSdkEventStream(sdkResponse, signal, onActivity) {
         await closeIterator(rawIterator);
     };
     const nextRaw = async () => {
-        const recordActivity = (result) => {
-            if (!result.done)
-                onActivity?.();
-            return result;
-        };
-        if (!signal)
-            return rawIterator.next().then(recordActivity);
-        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(recordActivity(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() {
@@ -118,7 +119,7 @@ export class ResponseHandler {
         }), { headers: { 'Content-Type': 'text/event-stream' } });
     }
     async handleSdkStreaming(sdkResponse, model, conversationId, lifecycle) {
-        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onActivity);
+        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd);
         const transformed = transformSdkStream(wrapped.response, model, conversationId);
         const buffered = [];
         let firstSemantic;
@@ -227,7 +228,7 @@ export class ResponseHandler {
         const toolCalls = [];
         let inputTokens = 0;
         let outputTokens = 0;
-        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onActivity);
+        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd);
         const eventStream = wrapped.response.generateAssistantResponseResponse;
         if (eventStream) {
             try {

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/dist/plugin/config/loader.js

@@ -135,6 +135,7 @@ function applyEnvOverrides(config) {
         rate_limit_retry_delay_ms: parseNumberEnv(env.KIRO_RATE_LIMIT_RETRY_DELAY_MS, config.rate_limit_retry_delay_ms),
         rate_limit_max_retries: parseNumberEnv(env.KIRO_RATE_LIMIT_MAX_RETRIES, config.rate_limit_max_retries),
         max_request_iterations: parseNumberEnv(env.KIRO_MAX_REQUEST_ITERATIONS, config.max_request_iterations),
+        sdk_response_timeout_ms: parseNumberEnv(env.KIRO_SDK_RESPONSE_TIMEOUT_MS, config.sdk_response_timeout_ms),
         request_timeout_ms: parseNumberEnv(env.KIRO_REQUEST_TIMEOUT_MS, config.request_timeout_ms),
         token_expiry_buffer_ms: parseNumberEnv(env.KIRO_TOKEN_EXPIRY_BUFFER_MS, config.token_expiry_buffer_ms),
         usage_sync_max_retries: parseNumberEnv(env.KIRO_USAGE_SYNC_MAX_RETRIES, config.usage_sync_max_retries),

package/dist/plugin/config/schema.d.ts

@@ -55,6 +55,15 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
     rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
     max_request_iterations: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Maximum wait for client.send() to return the initial SDK response.
+     * High-effort models can legitimately take several minutes before the
+     * event stream becomes available.
+     */
+    sdk_response_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Maximum inactivity while waiting for the next upstream stream event.
+     */
     request_timeout_ms: z.ZodDefault<z.ZodNumber>;
     token_expiry_buffer_ms: z.ZodDefault<z.ZodNumber>;
     /**
@@ -104,6 +113,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: number;
     rate_limit_max_retries: number;
     max_request_iterations: number;
+    sdk_response_timeout_ms: number;
     request_timeout_ms: number;
     token_expiry_buffer_ms: number;
     token_keepalive_enabled: boolean;
@@ -137,6 +147,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms?: number | undefined;
     rate_limit_max_retries?: number | undefined;
     max_request_iterations?: number | undefined;
+    sdk_response_timeout_ms?: number | undefined;
     request_timeout_ms?: number | undefined;
     token_expiry_buffer_ms?: number | undefined;
     token_keepalive_enabled?: boolean | undefined;

package/dist/plugin/config/schema.js

@@ -87,6 +87,15 @@ export const KiroConfigSchema = z.object({
     rate_limit_retry_delay_ms: z.number().min(1000).max(60000).default(5000),
     rate_limit_max_retries: z.number().min(0).max(10).default(3),
     max_request_iterations: z.number().min(5).max(1000).default(20),
+    /**
+     * Maximum wait for client.send() to return the initial SDK response.
+     * High-effort models can legitimately take several minutes before the
+     * event stream becomes available.
+     */
+    sdk_response_timeout_ms: z.number().min(30000).max(600000).default(300000),
+    /**
+     * Maximum inactivity while waiting for the next upstream stream event.
+     */
     request_timeout_ms: z.number().min(30000).max(600000).default(120000),
     token_expiry_buffer_ms: z.number().min(30000).max(300000).default(300000),
     /**
@@ -137,6 +146,7 @@ export const DEFAULT_CONFIG = {
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,
     max_request_iterations: 20,
+    sdk_response_timeout_ms: 300000,
     request_timeout_ms: 120000,
     token_expiry_buffer_ms: 300000,
     token_keepalive_enabled: false,

package/package.json

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