@sunerpy/opencode-kiro-auth 0.13.6 → 0.13.8

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

@@ -14,6 +14,19 @@ 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;
+function describeError(error, depth = 0) {
+    if (!(error instanceof Error))
+        return String(error);
+    const code = error.code;
+    return {
+        name: error.name,
+        message: error.message,
+        ...(code !== undefined ? { code } : {}),
+        ...(depth < 2 && error.cause !== undefined
+            ? { cause: describeError(error.cause, depth + 1) }
+            : {})
+    };
+}
 export class RequestHandler {
     accountManager;
     config;
@@ -244,6 +257,15 @@ export class RequestHandler {
                             region: sdkPrep.region
                         }),
                         onUpstreamWaitEnd: endUpstreamWait,
+                        onIterationError: (error, afterCompletionMetadata) => logger.warn('Kiro SDK event stream iteration failed', {
+                            model,
+                            effectiveModel: sdkPrep.effectiveModel,
+                            region: sdkPrep.region,
+                            platform: process.platform,
+                            afterCompletionMetadata,
+                            recovered: afterCompletionMetadata,
+                            error: describeError(error)
+                        }),
                         onComplete: completeRequest,
                         onTerminal: cleanupRequest,
                         onCancel: (reason) => requestController.abort(reason),

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

@@ -3,6 +3,7 @@ export interface SdkResponseLifecycle {
     signal?: AbortSignal;
     onUpstreamWaitStart?: () => void;
     onUpstreamWaitEnd?: () => void;
+    onIterationError?: (error: unknown, afterCompletionMetadata: boolean) => void;
     onComplete?: () => void | Promise<void>;
     onTerminal?: () => void;
     onCancel?: (reason: unknown) => void;

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

@@ -11,13 +11,22 @@ async function closeIterator(iterator) {
     }
     catch { }
 }
-function wrapSdkEventStream(sdkResponse, signal, onUpstreamWaitStart, onUpstreamWaitEnd) {
+function isCompletionMetadataEvent(event) {
+    if (typeof event !== 'object' || event === null || !('metadataEvent' in event))
+        return false;
+    const metadata = event.metadataEvent;
+    if (typeof metadata !== 'object' || metadata === null || !('tokenUsage' in metadata))
+        return false;
+    return typeof metadata.tokenUsage === 'object' && metadata.tokenUsage !== null;
+}
+function wrapSdkEventStream(sdkResponse, signal, onUpstreamWaitStart, onUpstreamWaitEnd, onIterationError) {
     const eventStream = sdkResponse.generateAssistantResponseResponse;
     if (!eventStream || typeof eventStream[Symbol.asyncIterator] !== 'function') {
         return { response: sdkResponse, closeRaw: async () => { } };
     }
     const rawIterator = eventStream[Symbol.asyncIterator]();
     let closed = false;
+    let completionMetadataSeen = false;
     const closeRaw = async () => {
         if (closed)
             return;
@@ -57,11 +66,20 @@ function wrapSdkEventStream(sdkResponse, signal, onUpstreamWaitStart, onUpstream
     const wrappedIterator = {
         async next() {
             try {
-                return await nextRaw();
+                const result = await nextRaw();
+                if (!result.done && isCompletionMetadataEvent(result.value)) {
+                    completionMetadataSeen = true;
+                }
+                return result;
             }
             catch (error) {
                 if (signal?.aborted)
                     throw abortReason(signal);
+                onIterationError?.(error, completionMetadataSeen);
+                if (completionMetadataSeen) {
+                    await closeRaw();
+                    return { done: true, value: undefined };
+                }
                 throw new SdkEventStreamIterationError(error);
             }
         },
@@ -119,7 +137,7 @@ export class ResponseHandler {
         }), { headers: { 'Content-Type': 'text/event-stream' } });
     }
     async handleSdkStreaming(sdkResponse, model, conversationId, lifecycle) {
-        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd);
+        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd, lifecycle.onIterationError);
         const transformed = transformSdkStream(wrapped.response, model, conversationId);
         const buffered = [];
         let firstSemantic;
@@ -228,7 +246,7 @@ export class ResponseHandler {
         const toolCalls = [];
         let inputTokens = 0;
         let outputTokens = 0;
-        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd);
+        const wrapped = wrapSdkEventStream(sdkResponse, lifecycle.signal, lifecycle.onUpstreamWaitStart, lifecycle.onUpstreamWaitEnd, lifecycle.onIterationError);
         const eventStream = wrapped.response.generateAssistantResponseResponse;
         if (eventStream) {
             try {

package/dist/plugin/storage/locked-operations.js

@@ -5,16 +5,14 @@ import lockfile from 'proper-lockfile';
 import { isPermanentError } from '../health.js';
 import { getKeepAliveLockPath, getRefreshLockPath } from '../paths.js';
 export { getKeepAliveLockPath, getRefreshLockPath } from '../paths.js';
-const LOCK_OPTIONS = {
+const DATABASE_LOCK_OPTIONS = {
     stale: 10000,
-    retries: {
-        retries: 5,
-        minTimeout: 100,
-        maxTimeout: 1000,
-        factor: 2
-    },
+    retries: 0,
     realpath: false
 };
+const DATABASE_LOCK_DEADLINE_MS = 10000;
+const DATABASE_LOCK_MIN_BACKOFF_MS = 25;
+const DATABASE_LOCK_MAX_BACKOFF_MS = 250;
 const REFRESH_LOCK_OPTIONS = {
     stale: 15000,
     retries: {
@@ -38,6 +36,29 @@ function blockingBackoff(ms) {
 function isLockContention(e) {
     return typeof e === 'object' && e !== null && 'code' in e && e.code === 'ELOCKED';
 }
+function asyncBackoff(attempt, remainingMs) {
+    const ceiling = Math.min(DATABASE_LOCK_MIN_BACKOFF_MS * 2 ** Math.min(attempt, 4), DATABASE_LOCK_MAX_BACKOFF_MS, remainingMs);
+    const floor = Math.max(1, Math.floor(ceiling / 2));
+    const delay = floor + Math.floor(Math.random() * (ceiling - floor + 1));
+    return new Promise((resolve) => setTimeout(resolve, delay));
+}
+async function acquireDatabaseLock(dbPath) {
+    // A deadline avoids fixed retry-count starvation; jitter keeps contenders
+    // from repeatedly attempting the atomic mkdir in lockstep.
+    const deadline = Date.now() + DATABASE_LOCK_DEADLINE_MS;
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await lockfile.lock(dbPath, DATABASE_LOCK_OPTIONS);
+        }
+        catch (e) {
+            const remainingMs = deadline - Date.now();
+            if (!isLockContention(e) || remainingMs <= 0)
+                throw e;
+            await asyncBackoff(attempt++, remainingMs);
+        }
+    }
+}
 export function withDatabaseLockSync(dbPath, fn) {
     if (!existsSync(dbPath)) {
         mkdirSync(dirname(dbPath), { recursive: true });
@@ -73,13 +94,12 @@ export function withDatabaseLockSync(dbPath, fn) {
 }
 export async function withDatabaseLock(dbPath, fn) {
     if (!existsSync(dbPath)) {
-        const dir = dbPath.substring(0, dbPath.lastIndexOf('/'));
-        await fs.mkdir(dir, { recursive: true });
+        await fs.mkdir(dirname(dbPath), { recursive: true });
         await fs.writeFile(dbPath, '');
     }
     let release = null;
     try {
-        release = await lockfile.lock(dbPath, LOCK_OPTIONS);
+        release = await acquireDatabaseLock(dbPath);
         return await fn();
     }
     finally {

package/package.json

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