@sunerpy/opencode-kiro-auth 0.15.2 → 0.15.3

package/README.md

@@ -109,6 +109,14 @@ multi-account or long-idle setups, enable
 (`token_keepalive_enabled: true`) to keep idle accounts' tokens fresh while
 OpenCode is running.
 
+For long-running agent tasks that are frequently interrupted by upstream
+`ECONNRESET` event-stream failures, enable
+`"stream_buffer_until_complete": true`. The plugin then withholds a failed
+attempt from OpenCode and safely retries it instead of exposing a partial
+assistant response or partial tool call. See
+[stream recovery configuration](docs/CONFIGURATION.md#options) for the latency
+and quota tradeoffs.
+
 Paid-overage protection is on by default; see
 [Overage protection](docs/CONFIGURATION.md#overage-protection) before disabling
 `stop_on_overage`.
@@ -231,6 +239,12 @@ accounts", `/connect` vs `opencode auth login`, and Kiro CLI OAuth users whose
 sync doesn't start — are covered in
 [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md).
 
+`Kiro upstream event stream failed unexpectedly` means the upstream HTTP 200
+event stream ended before completion metadata. Live-stream mode cannot safely
+replay after output because that could duplicate text or execute a tool twice.
+Enable `stream_buffer_until_complete` when task continuity is more important
+than seeing tokens arrive live.
+
 ## Migration
 
 If you're upgrading from a version that used the provider id `kiro` instead of

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

@@ -14,7 +14,6 @@ import { RetryStrategy } from './retry-strategy.js';
 import { SdkEventStreamIterationError, UpstreamUnexpectedError } from './stream-error.js';
 const KIRO_API_PATTERN = /^(https?:\/\/)?q\.[a-z0-9-]+\.amazonaws\.com/;
 const REAUTH_FAILURE_COOLDOWN_MS = 60000;
-const MAX_STREAM_ATTEMPTS = 3;
 function describeError(error, depth = 0) {
     if (!(error instanceof Error))
         return String(error);
@@ -192,7 +191,8 @@ export class RequestHandler {
                     account: acc.email,
                     accountId: acc.id,
                     streamAttempt,
-                    maxStreamAttempts: MAX_STREAM_ATTEMPTS,
+                    maxStreamAttempts: this.config.stream_max_attempts,
+                    streamDeliveryMode: this.config.stream_buffer_until_complete ? 'buffered' : 'live',
                     ...details
                 });
                 if (this.config.enable_log_effort_debug) {
@@ -296,6 +296,7 @@ export class RequestHandler {
                         onComplete: completeRequest,
                         onTerminal: cleanupRequest,
                         onCancel: (reason) => requestController.abort(reason),
+                        bufferUntilComplete: this.config.stream_buffer_until_complete,
                         mapError: (error) => {
                             logger.error('Kiro SDK event stream iteration failed', streamLogDetails({
                                 outcome: 'terminated_after_output',
@@ -323,7 +324,7 @@ export class RequestHandler {
                     if (e instanceof SdkEventStreamIterationError) {
                         streamFailureCount++;
                         const streamError = new UpstreamUnexpectedError(e, false);
-                        if (streamFailureCount >= MAX_STREAM_ATTEMPTS) {
+                        if (streamFailureCount >= this.config.stream_max_attempts) {
                             logger.error('Kiro SDK event stream iteration failed', streamLogDetails({
                                 outcome: 'exhausted',
                                 platform: process.platform,

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

@@ -10,6 +10,7 @@ export interface SdkResponseLifecycle {
     onTerminal?: () => void;
     onCancel?: (reason: unknown) => void;
     mapError?: (error: SdkEventStreamIterationError, emittedOutput: true) => unknown;
+    bufferUntilComplete?: boolean;
 }
 export declare class ResponseHandler {
     handleSuccess(response: Response, model: string, conversationId: string, streaming: boolean): Promise<Response>;

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

@@ -115,6 +115,18 @@ function isSemanticChunk(chunk) {
 function encodeSseChunk(chunk) {
     return new TextEncoder().encode(`data: ${JSON.stringify(chunk)}\n\n`);
 }
+function bufferedSseResponse(chunks) {
+    let index = 0;
+    return new Response(new ReadableStream({
+        pull(controller) {
+            const chunk = chunks[index++];
+            if (chunk)
+                controller.enqueue(chunk);
+            if (index >= chunks.length)
+                controller.close();
+        }
+    }, { highWaterMark: 0 }), { headers: { 'Content-Type': 'text/event-stream' } });
+}
 export class ResponseHandler {
     async handleSuccess(response, model, conversationId, streaming) {
         if (streaming) {
@@ -148,22 +160,34 @@ export class ResponseHandler {
         const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd, lifecycle.onIterationError);
         const transformed = transformSdkStream(wrapped.response, model, conversationId);
         const buffered = [];
+        if (lifecycle.bufferUntilComplete) {
+            try {
+                while (true) {
+                    const item = await transformed.next();
+                    if (item.done) {
+                        await lifecycle.onComplete?.();
+                        lifecycle.onTerminal?.();
+                        return bufferedSseResponse(buffered);
+                    }
+                    buffered.push(encodeSseChunk(item.value));
+                }
+            }
+            catch (error) {
+                try {
+                    await transformed.return(undefined);
+                }
+                catch { }
+                await wrapped.closeRaw();
+                throw error;
+            }
+        }
         let firstSemantic;
         while (true) {
             const item = await transformed.next();
             if (item.done) {
                 await lifecycle.onComplete?.();
                 lifecycle.onTerminal?.();
-                let index = 0;
-                return new Response(new ReadableStream({
-                    pull(controller) {
-                        const chunk = buffered[index++];
-                        if (chunk)
-                            controller.enqueue(chunk);
-                        if (index >= buffered.length)
-                            controller.close();
-                    }
-                }, { highWaterMark: 0 }), { headers: { 'Content-Type': 'text/event-stream' } });
+                return bufferedSseResponse(buffered);
             }
             const encoded = encodeSseChunk(item.value);
             if (isSemanticChunk(item.value)) {

package/dist/plugin/config/loader.js

@@ -139,6 +139,8 @@ function applyEnvOverrides(config) {
         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),
+        stream_buffer_until_complete: parseBooleanEnv(env.KIRO_STREAM_BUFFER_UNTIL_COMPLETE, config.stream_buffer_until_complete),
+        stream_max_attempts: parseNumberEnv(env.KIRO_STREAM_MAX_ATTEMPTS, config.stream_max_attempts),
         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),
         auth_server_port_start: parseNumberEnv(env.KIRO_AUTH_SERVER_PORT_START, config.auth_server_port_start),

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

@@ -77,6 +77,17 @@ export declare const KiroConfigSchema: z.ZodObject<{
      * Only used when stream_event_timeout_enabled is true.
      */
     request_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Consume the complete Kiro event stream before exposing any semantic output
+     * downstream. This trades live token display for safe retries after a
+     * mid-stream transport failure without duplicating content or tool calls.
+     */
+    stream_buffer_until_complete: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum number of complete event-stream attempts. Buffered mode can safely
+     * use every attempt even when the failed upstream stream produced output.
+     */
+    stream_max_attempts: z.ZodDefault<z.ZodNumber>;
     token_expiry_buffer_ms: z.ZodDefault<z.ZodNumber>;
     /**
      * Opt-in leader-elected keep-alive that proactively rotates idle-account
@@ -129,6 +140,8 @@ export declare const KiroConfigSchema: z.ZodObject<{
     sdk_response_timeout_ms: number;
     stream_event_timeout_enabled: boolean;
     request_timeout_ms: number;
+    stream_buffer_until_complete: boolean;
+    stream_max_attempts: number;
     token_expiry_buffer_ms: number;
     token_keepalive_enabled: boolean;
     token_keepalive_interval_ms: number;
@@ -165,6 +178,8 @@ export declare const KiroConfigSchema: z.ZodObject<{
     sdk_response_timeout_ms?: number | undefined;
     stream_event_timeout_enabled?: boolean | undefined;
     request_timeout_ms?: number | undefined;
+    stream_buffer_until_complete?: boolean | undefined;
+    stream_max_attempts?: number | undefined;
     token_expiry_buffer_ms?: number | undefined;
     token_keepalive_enabled?: boolean | undefined;
     token_keepalive_interval_ms?: number | undefined;

package/dist/plugin/config/schema.js

@@ -109,6 +109,17 @@ export const KiroConfigSchema = z.object({
      * Only used when stream_event_timeout_enabled is true.
      */
     request_timeout_ms: z.number().min(30000).max(600000).default(120000),
+    /**
+     * Consume the complete Kiro event stream before exposing any semantic output
+     * downstream. This trades live token display for safe retries after a
+     * mid-stream transport failure without duplicating content or tool calls.
+     */
+    stream_buffer_until_complete: z.boolean().default(false),
+    /**
+     * Maximum number of complete event-stream attempts. Buffered mode can safely
+     * use every attempt even when the failed upstream stream produced output.
+     */
+    stream_max_attempts: z.number().int().min(1).max(10).default(3),
     token_expiry_buffer_ms: z.number().min(30000).max(300000).default(300000),
     /**
      * Opt-in leader-elected keep-alive that proactively rotates idle-account
@@ -162,6 +173,8 @@ export const DEFAULT_CONFIG = {
     sdk_response_timeout_ms: 300000,
     stream_event_timeout_enabled: false,
     request_timeout_ms: 120000,
+    stream_buffer_until_complete: false,
+    stream_max_attempts: 3,
     token_expiry_buffer_ms: 300000,
     token_keepalive_enabled: false,
     token_keepalive_interval_ms: 600000,

package/package.json

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