@sunerpy/opencode-kiro-auth 0.14.0 → 0.14.2

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

@@ -242,8 +242,9 @@ export class RequestHandler {
                     try {
                         sdkResponse = await client.send(command, { abortSignal: signal });
                     }
-                    finally {
+                    catch (error) {
                         endUpstreamWait();
+                        throw error;
                     }
                     sendResolved = true;
                     if (apiTimestamp) {
@@ -251,11 +252,21 @@ export class RequestHandler {
                     }
                     const response = await this.responseHandler.handleSdkSuccess(sdkResponse, model, sdkPrep.conversationId, sdkPrep.streaming, {
                         signal,
-                        onUpstreamWaitStart: () => beginUpstreamWait('stream event', this.config.request_timeout_ms, {
-                            model,
-                            effectiveModel: sdkPrep.effectiveModel,
-                            region: sdkPrep.region
-                        }),
+                        onUpstreamWaitStart: ({ eventIndex }) => {
+                            if (eventIndex === 0) {
+                                if (!this.config.sdk_response_timeout_enabled)
+                                    endUpstreamWait();
+                                return;
+                            }
+                            if (!this.config.stream_event_timeout_enabled)
+                                return;
+                            beginUpstreamWait('stream event', this.config.request_timeout_ms, {
+                                model,
+                                effectiveModel: sdkPrep.effectiveModel,
+                                region: sdkPrep.region,
+                                eventIndex
+                            });
+                        },
                         onUpstreamWaitEnd: endUpstreamWait,
                         onIterationError: (error, afterCompletionMetadata) => logger.warn('Kiro SDK event stream iteration failed', {
                             model,

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

@@ -1,7 +1,9 @@
 import { SdkEventStreamIterationError } from './stream-error.js';
 export interface SdkResponseLifecycle {
     signal?: AbortSignal;
-    onUpstreamWaitStart?: () => void;
+    onUpstreamWaitStart?: (context: {
+        eventIndex: number;
+    }) => void;
     onUpstreamWaitEnd?: () => void;
     onIterationError?: (error: unknown, afterCompletionMetadata: boolean) => void;
     onComplete?: () => void | Promise<void>;

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

@@ -27,6 +27,7 @@ function wrapSdkEventStream(sdkResponse, signal, onUpstreamWaitStart, onUpstream
     const rawIterator = eventStream[Symbol.asyncIterator]();
     let closed = false;
     let completionMetadataSeen = false;
+    let eventIndex = 0;
     const closeRaw = async () => {
         if (closed)
             return;
@@ -38,26 +39,33 @@ function wrapSdkEventStream(sdkResponse, signal, onUpstreamWaitStart, onUpstream
             await closeRaw();
             throw abortReason(signal);
         }
-        onUpstreamWaitStart?.();
+        onUpstreamWaitStart?.({ eventIndex });
         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)));
-            });
+            let result;
+            if (!signal) {
+                result = await rawIterator.next();
+            }
+            else {
+                result = 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((nextResult) => settle(() => resolve(nextResult)), (error) => settle(() => reject(error)));
+                });
+            }
+            if (!result.done)
+                eventIndex++;
+            return result;
         }
         finally {
             onUpstreamWaitEnd?.();

package/dist/plugin/config/loader.js

@@ -137,6 +137,7 @@ function applyEnvOverrides(config) {
         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),
+        stream_event_timeout_enabled: parseBooleanEnv(env.KIRO_STREAM_EVENT_TIMEOUT_ENABLED, config.stream_event_timeout_enabled),
         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

@@ -56,18 +56,25 @@ export declare const KiroConfigSchema: z.ZodObject<{
     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.
+     * Opt into a fixed deadline covering client.send() and the first stream event.
      * 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.
+     * Maximum wait for the initial SDK response and first stream event.
      * 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.
+     * Opt into a fixed inactivity deadline between upstream stream events.
+     * Disabled by default because a silent event gap is ambiguous: Kiro may
+     * still be performing a valid long-running generation.
+     */
+    stream_event_timeout_enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum inactivity between upstream stream events.
+     * Only used when stream_event_timeout_enabled is true.
      */
     request_timeout_ms: z.ZodDefault<z.ZodNumber>;
     token_expiry_buffer_ms: z.ZodDefault<z.ZodNumber>;
@@ -120,6 +127,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     max_request_iterations: number;
     sdk_response_timeout_enabled: boolean;
     sdk_response_timeout_ms: number;
+    stream_event_timeout_enabled: boolean;
     request_timeout_ms: number;
     token_expiry_buffer_ms: number;
     token_keepalive_enabled: boolean;
@@ -155,6 +163,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     max_request_iterations?: number | undefined;
     sdk_response_timeout_enabled?: boolean | undefined;
     sdk_response_timeout_ms?: number | undefined;
+    stream_event_timeout_enabled?: boolean | undefined;
     request_timeout_ms?: number | undefined;
     token_expiry_buffer_ms?: number | undefined;
     token_keepalive_enabled?: boolean | undefined;

package/dist/plugin/config/schema.js

@@ -88,18 +88,25 @@ export const KiroConfigSchema = z.object({
     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.
+     * Opt into a fixed deadline covering client.send() and the first stream event.
      * 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.
+     * Maximum wait for the initial SDK response and first stream event.
      * 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.
+     * Opt into a fixed inactivity deadline between upstream stream events.
+     * Disabled by default because a silent event gap is ambiguous: Kiro may
+     * still be performing a valid long-running generation.
+     */
+    stream_event_timeout_enabled: z.boolean().default(false),
+    /**
+     * Maximum inactivity between upstream stream events.
+     * Only used when stream_event_timeout_enabled is true.
      */
     request_timeout_ms: z.number().min(30000).max(600000).default(120000),
     token_expiry_buffer_ms: z.number().min(30000).max(300000).default(300000),
@@ -153,6 +160,7 @@ export const DEFAULT_CONFIG = {
     max_request_iterations: 20,
     sdk_response_timeout_enabled: false,
     sdk_response_timeout_ms: 300000,
+    stream_event_timeout_enabled: false,
     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.14.0",
+  "version": "0.14.2",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",