@sunerpy/opencode-kiro-auth 0.13.4 → 0.13.6

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

@@ -75,12 +75,26 @@ export class RequestHandler {
         else
             inboundSignal?.addEventListener('abort', abortFromInbound, { once: true });
         let timeout;
-        const beginUpstreamWait = (phase) => {
+        const beginUpstreamWait = (phase, timeoutMs, details = {}) => {
             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);
+            if (timeoutMs <= 0) {
+                timeout = undefined;
+                return;
+            }
+            const startedAt = Date.now();
+            timeout = setDeadlineTimeout(() => {
+                logger.warn('Kiro upstream wait timed out', {
+                    phase,
+                    configuredTimeoutMs: timeoutMs,
+                    elapsedMs: Date.now() - startedAt,
+                    platform: process.platform,
+                    ...details
+                });
+                requestController.abort(new DOMException(`Kiro request timed out waiting for ${phase}`, 'TimeoutError'));
+            }, timeoutMs);
         };
         const endUpstreamWait = () => {
             if (!timeout)
@@ -201,7 +215,17 @@ export class RequestHandler {
                         await this.usageTracker.syncUsage(acc, auth, isCurrentAttempt);
                     };
                     let sdkResponse;
-                    beginUpstreamWait('SDK response');
+                    if (this.config.sdk_response_timeout_enabled) {
+                        const messageContext = sdkPrep.conversationState.currentMessage?.userInputMessage?.userInputMessageContext;
+                        beginUpstreamWait('SDK response', this.config.sdk_response_timeout_ms, {
+                            model,
+                            effectiveModel: sdkPrep.effectiveModel,
+                            effort: sdkPrep.effort,
+                            region: sdkPrep.region,
+                            historyLength: sdkPrep.conversationState.history?.length ?? 0,
+                            toolCount: messageContext?.tools?.length ?? 0
+                        });
+                    }
                     try {
                         sdkResponse = await client.send(command, { abortSignal: signal });
                     }
@@ -214,7 +238,11 @@ export class RequestHandler {
                     }
                     const response = await this.responseHandler.handleSdkSuccess(sdkResponse, model, sdkPrep.conversationId, sdkPrep.streaming, {
                         signal,
-                        onUpstreamWaitStart: () => beginUpstreamWait('stream event'),
+                        onUpstreamWaitStart: () => beginUpstreamWait('stream event', this.config.request_timeout_ms, {
+                            model,
+                            effectiveModel: sdkPrep.effectiveModel,
+                            region: sdkPrep.region
+                        }),
                         onUpstreamWaitEnd: endUpstreamWait,
                         onComplete: completeRequest,
                         onTerminal: cleanupRequest,

package/dist/plugin/config/loader.js

@@ -135,6 +135,8 @@ 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_enabled: parseBooleanEnv(env.KIRO_SDK_RESPONSE_TIMEOUT_ENABLED, config.sdk_response_timeout_enabled),
+        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,20 @@ 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>;
+    /**
+     * Opt into a fixed deadline while waiting for client.send() to return.
+     * Disabled by default because a pending request is ambiguous: Kiro may
+     * still be performing a valid long-running generation.
+     */
+    sdk_response_timeout_enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum wait for client.send() to return the initial SDK response.
+     * Only used when sdk_response_timeout_enabled is true.
+     */
+    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 +118,8 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: number;
     rate_limit_max_retries: number;
     max_request_iterations: number;
+    sdk_response_timeout_enabled: boolean;
+    sdk_response_timeout_ms: number;
     request_timeout_ms: number;
     token_expiry_buffer_ms: number;
     token_keepalive_enabled: boolean;
@@ -137,6 +153,8 @@ 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_enabled?: boolean | 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,20 @@ 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),
+    /**
+     * Opt into a fixed deadline while waiting for client.send() to return.
+     * Disabled by default because a pending request is ambiguous: Kiro may
+     * still be performing a valid long-running generation.
+     */
+    sdk_response_timeout_enabled: z.boolean().default(false),
+    /**
+     * Maximum wait for client.send() to return the initial SDK response.
+     * Only used when sdk_response_timeout_enabled is true.
+     */
+    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 +151,8 @@ export const DEFAULT_CONFIG = {
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,
     max_request_iterations: 20,
+    sdk_response_timeout_enabled: false,
+    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.4",
+  "version": "0.13.6",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",