@kervnet/opencode-kiro-auth 1.5.1

package/dist/core/auth/idc-auth-method.js

@@ -0,0 +1,200 @@
+import { exec } from 'node:child_process';
+import { authorizeKiroIDC } from '../../kiro/oauth-idc.js';
+import { createDeterministicAccountId } from '../../plugin/accounts.js';
+import { promptAddAnotherAccount, promptDeleteAccount, promptLoginMode } from '../../plugin/cli.js';
+import * as logger from '../../plugin/logger.js';
+import { startIDCAuthServer } from '../../plugin/server.js';
+import { fetchUsageLimits } from '../../plugin/usage.js';
+const openBrowser = (url) => {
+    const escapedUrl = url.replace(/"/g, '\\"');
+    const platform = process.platform;
+    const cmd = platform === 'win32'
+        ? `cmd /c start "" "${escapedUrl}"`
+        : platform === 'darwin'
+            ? `open "${escapedUrl}"`
+            : `xdg-open "${escapedUrl}"`;
+    exec(cmd, (error) => {
+        if (error)
+            logger.warn(`Browser error: ${error.message}`);
+    });
+};
+export class IdcAuthMethod {
+    config;
+    repository;
+    constructor(config, repository) {
+        this.config = config;
+        this.repository = repository;
+    }
+    async authorize(inputs) {
+        return new Promise(async (resolve) => {
+            const region = this.config.default_region;
+            if (inputs) {
+                await this.handleMultipleLogin(region, resolve);
+            }
+            else {
+                await this.handleSingleLogin(region, resolve);
+            }
+        });
+    }
+    async handleMultipleLogin(region, resolve) {
+        const accounts = [];
+        let startFresh = true;
+        while (true) {
+            const existingAccounts = await this.repository.findAll();
+            const idcAccs = existingAccounts.filter((a) => a.authMethod === 'idc');
+            if (idcAccs.length === 0) {
+                break;
+            }
+            const existingAccountsList = idcAccs.map((acc, idx) => ({
+                email: acc.email,
+                index: idx
+            }));
+            const mode = await promptLoginMode(existingAccountsList);
+            if (mode === 'delete') {
+                const deleteIndices = await promptDeleteAccount(existingAccountsList);
+                if (deleteIndices !== null && deleteIndices.length > 0) {
+                    for (const idx of deleteIndices) {
+                        const accToDelete = idcAccs[idx];
+                        if (accToDelete) {
+                            await this.repository.delete(accToDelete.id);
+                            console.log(`[Success] Deleted: ${accToDelete.email}`);
+                        }
+                    }
+                    console.log(`\n[Success] Deleted ${deleteIndices.length} account(s)\n`);
+                }
+                continue;
+            }
+            if (mode === 'add') {
+                startFresh = false;
+                break;
+            }
+            if (mode === 'fresh') {
+                startFresh = true;
+                break;
+            }
+        }
+        while (true) {
+            try {
+                const authData = await authorizeKiroIDC(region);
+                const { url, waitForAuth } = await startIDCAuthServer(authData, this.config.auth_server_port_start, this.config.auth_server_port_range);
+                openBrowser(url);
+                const res = await waitForAuth();
+                const u = await fetchUsageLimits({
+                    refresh: '',
+                    access: res.accessToken,
+                    expires: res.expiresAt,
+                    authMethod: 'idc',
+                    region,
+                    clientId: res.clientId,
+                    clientSecret: res.clientSecret
+                });
+                if (!u.email) {
+                    console.log('\n[Error] Failed to fetch account email. Skipping...\n');
+                    continue;
+                }
+                accounts.push(res);
+                if (accounts.length === 1 && startFresh) {
+                    const allAccounts = await this.repository.findAll();
+                    const idcAccountsToRemove = allAccounts.filter((a) => a.authMethod === 'idc');
+                    for (const acc of idcAccountsToRemove) {
+                        await this.repository.delete(acc.id);
+                    }
+                }
+                const id = createDeterministicAccountId(u.email, 'idc', res.clientId);
+                const acc = {
+                    id,
+                    email: u.email,
+                    authMethod: 'idc',
+                    region,
+                    clientId: res.clientId,
+                    clientSecret: res.clientSecret,
+                    refreshToken: res.refreshToken,
+                    accessToken: res.accessToken,
+                    expiresAt: res.expiresAt,
+                    rateLimitResetTime: 0,
+                    isHealthy: true,
+                    failCount: 0,
+                    usedCount: u.usedCount,
+                    limitCount: u.limitCount
+                };
+                await this.repository.save(acc);
+                const currentCount = (await this.repository.findAll()).length;
+                console.log(`\n[Success] Added: ${u.email} (Quota: ${u.usedCount}/${u.limitCount})\n`);
+                if (!(await promptAddAnotherAccount(currentCount)))
+                    break;
+            }
+            catch (e) {
+                console.log(`\n[Error] Login failed: ${e.message}\n`);
+                break;
+            }
+        }
+        const finalAccounts = await this.repository.findAll();
+        return resolve({
+            url: '',
+            instructions: `Complete (${finalAccounts.length} accounts).`,
+            method: 'auto',
+            callback: async () => ({
+                type: 'success',
+                key: finalAccounts[0]?.accessToken || ''
+            })
+        });
+    }
+    async handleSingleLogin(region, resolve) {
+        try {
+            const authData = await authorizeKiroIDC(region);
+            const { url, waitForAuth } = await startIDCAuthServer(authData, this.config.auth_server_port_start, this.config.auth_server_port_range);
+            openBrowser(url);
+            resolve({
+                url,
+                instructions: `Open: ${url}`,
+                method: 'auto',
+                callback: async () => {
+                    try {
+                        const res = await waitForAuth();
+                        const u = await fetchUsageLimits({
+                            refresh: '',
+                            access: res.accessToken,
+                            expires: res.expiresAt,
+                            authMethod: 'idc',
+                            region,
+                            clientId: res.clientId,
+                            clientSecret: res.clientSecret
+                        });
+                        if (!u.email)
+                            throw new Error('No email');
+                        const id = createDeterministicAccountId(u.email, 'idc', res.clientId);
+                        const acc = {
+                            id,
+                            email: u.email,
+                            authMethod: 'idc',
+                            region,
+                            clientId: res.clientId,
+                            clientSecret: res.clientSecret,
+                            refreshToken: res.refreshToken,
+                            accessToken: res.accessToken,
+                            expiresAt: res.expiresAt,
+                            rateLimitResetTime: 0,
+                            isHealthy: true,
+                            failCount: 0,
+                            usedCount: u.usedCount,
+                            limitCount: u.limitCount
+                        };
+                        await this.repository.save(acc);
+                        return { type: 'success', key: res.accessToken };
+                    }
+                    catch (e) {
+                        return { type: 'failed' };
+                    }
+                }
+            });
+        }
+        catch (e) {
+            resolve({
+                url: '',
+                instructions: 'Failed',
+                method: 'auto',
+                callback: async () => ({ type: 'failed' })
+            });
+        }
+    }
+}

package/dist/core/auth/token-refresher.d.ts

@@ -0,0 +1,22 @@
+import type { AccountRepository } from '../../infrastructure/database/account-repository';
+import type { AccountManager } from '../../plugin/accounts';
+import type { KiroAuthDetails, ManagedAccount } from '../../plugin/types';
+type ToastFunction = (message: string, variant: 'info' | 'warning' | 'success' | 'error') => void;
+interface TokenRefresherConfig {
+    token_expiry_buffer_ms: number;
+    auto_sync_kiro_cli: boolean;
+    account_selection_strategy: 'sticky' | 'round-robin' | 'lowest-usage';
+}
+export declare class TokenRefresher {
+    private config;
+    private accountManager;
+    private syncFromKiroCli;
+    private repository;
+    constructor(config: TokenRefresherConfig, accountManager: AccountManager, syncFromKiroCli: () => Promise<void>, repository: AccountRepository);
+    refreshIfNeeded(account: ManagedAccount, auth: KiroAuthDetails, showToast: ToastFunction): Promise<{
+        account: ManagedAccount;
+        shouldContinue: boolean;
+    }>;
+    private handleRefreshError;
+}
+export {};

package/dist/core/auth/token-refresher.js

@@ -0,0 +1,53 @@
+import { accessTokenExpired } from '../../kiro/auth';
+import { KiroTokenRefreshError } from '../../plugin/errors';
+import { refreshAccessToken } from '../../plugin/token';
+export class TokenRefresher {
+    config;
+    accountManager;
+    syncFromKiroCli;
+    repository;
+    constructor(config, accountManager, syncFromKiroCli, repository) {
+        this.config = config;
+        this.accountManager = accountManager;
+        this.syncFromKiroCli = syncFromKiroCli;
+        this.repository = repository;
+    }
+    async refreshIfNeeded(account, auth, showToast) {
+        if (!accessTokenExpired(auth, this.config.token_expiry_buffer_ms)) {
+            return { account, shouldContinue: false };
+        }
+        try {
+            const newAuth = await refreshAccessToken(auth);
+            this.accountManager.updateFromAuth(account, newAuth);
+            await this.repository.batchSave(this.accountManager.getAccounts());
+            return { account, shouldContinue: false };
+        }
+        catch (e) {
+            return await this.handleRefreshError(e, account, showToast);
+        }
+    }
+    async handleRefreshError(error, account, showToast) {
+        if (this.config.auto_sync_kiro_cli) {
+            await this.syncFromKiroCli();
+        }
+        this.repository.invalidateCache();
+        const accounts = await this.repository.findAll();
+        const stillAcc = accounts.find((a) => a.id === account.id);
+        if (stillAcc &&
+            !accessTokenExpired(this.accountManager.toAuthDetails(stillAcc), this.config.token_expiry_buffer_ms)) {
+            showToast('Credentials recovered from Kiro CLI sync.', 'info');
+            return { account: stillAcc, shouldContinue: true };
+        }
+        if (error instanceof KiroTokenRefreshError &&
+            (error.code === 'ExpiredTokenException' ||
+                error.code === 'InvalidTokenException' ||
+                error.code === 'HTTP_401' ||
+                error.code === 'HTTP_403' ||
+                error.message.includes('Invalid refresh token provided'))) {
+            this.accountManager.markUnhealthy(account, error.message);
+            await this.repository.batchSave(this.accountManager.getAccounts());
+            return { account, shouldContinue: true };
+        }
+        throw error;
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+export * from './account/account-selector.js';
+export * from './account/usage-tracker.js';
+export * from './auth/auth-handler.js';
+export * from './auth/idc-auth-method.js';
+export * from './auth/token-refresher.js';
+export * from './request/error-handler.js';
+export * from './request/request-handler.js';
+export * from './request/response-handler.js';
+export * from './request/retry-strategy.js';

package/dist/core/index.js

@@ -0,0 +1,9 @@
+export * from './account/account-selector.js';
+export * from './account/usage-tracker.js';
+export * from './auth/auth-handler.js';
+export * from './auth/idc-auth-method.js';
+export * from './auth/token-refresher.js';
+export * from './request/error-handler.js';
+export * from './request/request-handler.js';
+export * from './request/response-handler.js';
+export * from './request/retry-strategy.js';

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

@@ -0,0 +1,30 @@
+import type { AccountRepository } from '../../infrastructure/database/account-repository';
+import type { AccountManager } from '../../plugin/accounts';
+import type { ManagedAccount } from '../../plugin/types';
+type ToastFunction = (message: string, variant: 'info' | 'warning' | 'success' | 'error') => void;
+interface RequestContext {
+    reductionFactor: number;
+    retry: number;
+}
+interface ErrorHandlerConfig {
+    rate_limit_max_retries: number;
+    rate_limit_retry_delay_ms: number;
+}
+export declare class ErrorHandler {
+    private config;
+    private accountManager;
+    private repository;
+    constructor(config: ErrorHandlerConfig, accountManager: AccountManager, repository: AccountRepository);
+    handle(error: any, response: Response, account: ManagedAccount, context: RequestContext, showToast: ToastFunction): Promise<{
+        shouldRetry: boolean;
+        newContext?: RequestContext;
+        switchAccount?: boolean;
+    }>;
+    handleNetworkError(error: any, context: RequestContext, showToast: ToastFunction): Promise<{
+        shouldRetry: boolean;
+        newContext?: RequestContext;
+    }>;
+    private isNetworkError;
+    private sleep;
+}
+export {};

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

@@ -0,0 +1,113 @@
+export class ErrorHandler {
+    config;
+    accountManager;
+    repository;
+    constructor(config, accountManager, repository) {
+        this.config = config;
+        this.accountManager = accountManager;
+        this.repository = repository;
+    }
+    async handle(error, response, account, context, showToast) {
+        if (response.status === 400 && context.reductionFactor > 0.4) {
+            const newFactor = context.reductionFactor - 0.2;
+            showToast(`Context too long. Retrying with ${Math.round(newFactor * 100)}%...`, 'warning');
+            return {
+                shouldRetry: true,
+                newContext: { ...context, reductionFactor: newFactor }
+            };
+        }
+        if (response.status === 401 && context.retry < this.config.rate_limit_max_retries) {
+            return {
+                shouldRetry: true,
+                newContext: { ...context, retry: context.retry + 1 }
+            };
+        }
+        if (response.status === 500) {
+            account.failCount = (account.failCount || 0) + 1;
+            let errorMessage = 'Internal Server Error';
+            try {
+                const errorBody = await response.text();
+                const errorData = JSON.parse(errorBody);
+                if (errorData.message) {
+                    errorMessage = errorData.message;
+                }
+                else if (errorData.Message) {
+                    errorMessage = errorData.Message;
+                }
+            }
+            catch (e) { }
+            if (account.failCount < 5) {
+                const delay = 1000 * Math.pow(2, account.failCount - 1);
+                showToast(`Server Error (500): ${errorMessage}. Retrying in ${Math.ceil(delay / 1000)}s...`, 'warning');
+                await this.sleep(delay);
+                return { shouldRetry: true };
+            }
+            else {
+                this.accountManager.markUnhealthy(account, `Server Error (500) after 5 attempts: ${errorMessage}`);
+                await this.repository.batchSave(this.accountManager.getAccounts());
+                showToast(`Server Error (500): ${errorMessage}. Marking account as unhealthy and switching...`, 'warning');
+                return { shouldRetry: true, switchAccount: true };
+            }
+        }
+        if (response.status === 429) {
+            const w = parseInt(response.headers.get('retry-after') || '60') * 1000;
+            this.accountManager.markRateLimited(account, w);
+            await this.repository.batchSave(this.accountManager.getAccounts());
+            const count = this.accountManager.getAccountCount();
+            if (count > 1) {
+                showToast(`Rate limited (${account.email}). Switching account...`, 'warning');
+                return { shouldRetry: true, switchAccount: true };
+            }
+            showToast(`Rate limited. Waiting ${Math.ceil(w / 1000)}s...`, 'warning');
+            await this.sleep(w);
+            return { shouldRetry: true };
+        }
+        if ((response.status === 402 || response.status === 403) &&
+            this.accountManager.getAccountCount() > 1) {
+            let errorReason = response.status === 402 ? 'Quota' : 'Forbidden';
+            let isPermanent = false;
+            try {
+                const errorBody = await response.text();
+                const errorData = JSON.parse(errorBody);
+                if (errorData.reason === 'INVALID_MODEL_ID') {
+                    throw new Error(`Invalid model: ${errorData.message}`);
+                }
+                if (errorData.reason === 'TEMPORARILY_SUSPENDED') {
+                    errorReason = 'Account Suspended';
+                    isPermanent = true;
+                }
+            }
+            catch (e) {
+                if (e instanceof Error && e.message.includes('Invalid model')) {
+                    throw e;
+                }
+            }
+            if (isPermanent) {
+                account.failCount = 10;
+            }
+            this.accountManager.markUnhealthy(account, errorReason);
+            await this.repository.batchSave(this.accountManager.getAccounts());
+            showToast(`${errorReason} (${account.email}). Switching account...`, 'warning');
+            return { shouldRetry: true, switchAccount: true };
+        }
+        return { shouldRetry: false };
+    }
+    async handleNetworkError(error, context, showToast) {
+        if (this.isNetworkError(error) && context.retry < this.config.rate_limit_max_retries) {
+            const d = this.config.rate_limit_retry_delay_ms * Math.pow(2, context.retry);
+            showToast(`Network error. Retrying in ${Math.ceil(d / 1000)}s...`, 'warning');
+            await this.sleep(d);
+            return {
+                shouldRetry: true,
+                newContext: { ...context, retry: context.retry + 1 }
+            };
+        }
+        return { shouldRetry: false };
+    }
+    isNetworkError(e) {
+        return (e instanceof Error && /econnreset|etimedout|enotfound|network|fetch failed/i.test(e.message));
+    }
+    sleep(ms) {
+        return new Promise((r) => setTimeout(r, ms));
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { AccountRepository } from '../../infrastructure/database/account-repository';
+import type { AccountManager } from '../../plugin/accounts';
+import type { KiroConfig } from '../../plugin/config';
+type ToastFunction = (message: string, variant: 'info' | 'warning' | 'success' | 'error') => void;
+export declare class RequestHandler {
+    private accountManager;
+    private config;
+    private repository;
+    private accountSelector;
+    private tokenRefresher;
+    private errorHandler;
+    private responseHandler;
+    private usageTracker;
+    private retryStrategy;
+    constructor(accountManager: AccountManager, config: KiroConfig, repository: AccountRepository);
+    handle(input: any, init: any, showToast: ToastFunction): Promise<Response>;
+    private handleKiroRequest;
+    private extractModel;
+    private prepareRequest;
+    private handleSuccessfulRequest;
+    private logRequest;
+    private logResponse;
+    private logError;
+    private allAccountsPermanentlyUnhealthy;
+    private sleep;
+}
+export {};

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

@@ -0,0 +1,199 @@
+import { isPermanentError } from '../../plugin/health';
+import * as logger from '../../plugin/logger';
+import { transformToCodeWhisperer } from '../../plugin/request';
+import { syncFromKiroCli } from '../../plugin/sync/kiro-cli';
+import { AccountSelector } from '../account/account-selector';
+import { UsageTracker } from '../account/usage-tracker';
+import { TokenRefresher } from '../auth/token-refresher';
+import { ErrorHandler } from './error-handler';
+import { ResponseHandler } from './response-handler';
+import { RetryStrategy } from './retry-strategy';
+const KIRO_API_PATTERN = /^(https?:\/\/)?q\.[a-z0-9-]+\.amazonaws\.com/;
+export class RequestHandler {
+    accountManager;
+    config;
+    repository;
+    accountSelector;
+    tokenRefresher;
+    errorHandler;
+    responseHandler;
+    usageTracker;
+    retryStrategy;
+    constructor(accountManager, config, repository) {
+        this.accountManager = accountManager;
+        this.config = config;
+        this.repository = repository;
+        this.accountSelector = new AccountSelector(accountManager, config, syncFromKiroCli, repository);
+        this.tokenRefresher = new TokenRefresher(config, accountManager, syncFromKiroCli, repository);
+        this.errorHandler = new ErrorHandler(config, accountManager, repository);
+        this.responseHandler = new ResponseHandler();
+        this.usageTracker = new UsageTracker(config, accountManager, repository);
+        this.retryStrategy = new RetryStrategy(config);
+    }
+    async handle(input, init, showToast) {
+        const url = typeof input === 'string' ? input : input.url;
+        if (!KIRO_API_PATTERN.test(url)) {
+            return fetch(input, init);
+        }
+        return this.handleKiroRequest(url, init, showToast);
+    }
+    async handleKiroRequest(url, init, showToast) {
+        const body = init?.body ? JSON.parse(init.body) : {};
+        const model = this.extractModel(url) || body.model || 'claude-sonnet-4-5';
+        const think = model.endsWith('-thinking') || !!body.providerOptions?.thinkingConfig;
+        const budget = body.providerOptions?.thinkingConfig?.thinkingBudget || 20000;
+        let reductionFactor = 1.0;
+        let retry = 0;
+        let consecutiveNullAccounts = 0;
+        const retryContext = this.retryStrategy.createContext();
+        while (true) {
+            const check = this.retryStrategy.shouldContinue(retryContext);
+            if (!check.canContinue) {
+                throw new Error(check.error);
+            }
+            if (this.allAccountsPermanentlyUnhealthy()) {
+                throw new Error('All accounts are permanently unhealthy (quota exceeded or suspended)');
+            }
+            let acc = await this.accountSelector.selectHealthyAccount(showToast);
+            if (!acc) {
+                consecutiveNullAccounts++;
+                const backoffDelay = Math.min(1000 * Math.pow(2, consecutiveNullAccounts - 1), 10000);
+                await this.sleep(backoffDelay);
+                continue;
+            }
+            consecutiveNullAccounts = 0;
+            const auth = this.accountManager.toAuthDetails(acc);
+            const tokenResult = await this.tokenRefresher.refreshIfNeeded(acc, auth, showToast);
+            if (tokenResult.shouldContinue) {
+                acc = tokenResult.account;
+                await this.sleep(500);
+                continue;
+            }
+            const prep = this.prepareRequest(url, init?.body, model, auth, think, budget, reductionFactor);
+            const apiTimestamp = this.config.enable_log_api_request ? logger.getTimestamp() : null;
+            if (apiTimestamp) {
+                this.logRequest(prep, acc, apiTimestamp);
+            }
+            try {
+                const res = await fetch(prep.url, prep.init);
+                if (apiTimestamp) {
+                    this.logResponse(res, prep, apiTimestamp);
+                }
+                if (res.ok) {
+                    this.handleSuccessfulRequest(acc);
+                    this.usageTracker.syncUsage(acc, auth);
+                    return await this.responseHandler.handleSuccess(res, model, prep.conversationId, prep.streaming);
+                }
+                const errorResult = await this.errorHandler.handle(null, res, acc, { reductionFactor, retry }, showToast);
+                if (errorResult.shouldRetry) {
+                    if (errorResult.newContext) {
+                        reductionFactor = errorResult.newContext.reductionFactor;
+                        retry = errorResult.newContext.retry;
+                    }
+                    if (errorResult.switchAccount) {
+                        continue;
+                    }
+                    continue;
+                }
+                this.logError(prep, res, acc, apiTimestamp);
+                throw new Error(`Kiro Error: ${res.status}`);
+            }
+            catch (e) {
+                const networkResult = await this.errorHandler.handleNetworkError(e, { reductionFactor, retry }, showToast);
+                if (networkResult.shouldRetry) {
+                    if (networkResult.newContext) {
+                        retry = networkResult.newContext.retry;
+                    }
+                    continue;
+                }
+                throw e;
+            }
+        }
+    }
+    extractModel(url) {
+        return url.match(/models\/([^/:]+)/)?.[1] || null;
+    }
+    prepareRequest(url, body, model, auth, think, budget, reductionFactor) {
+        return transformToCodeWhisperer(url, body, model, auth, think, budget, reductionFactor);
+    }
+    handleSuccessfulRequest(acc) {
+        if (acc.failCount && acc.failCount > 0) {
+            if (!isPermanentError(acc.unhealthyReason)) {
+                acc.failCount = 0;
+                acc.isHealthy = true;
+                delete acc.unhealthyReason;
+                delete acc.recoveryTime;
+                this.repository.save(acc).catch(() => { });
+            }
+        }
+    }
+    logRequest(prep, acc, timestamp) {
+        let b = null;
+        try {
+            b = prep.init.body ? JSON.parse(prep.init.body) : null;
+        }
+        catch { }
+        logger.logApiRequest({
+            url: prep.url,
+            method: prep.init.method,
+            headers: prep.init.headers,
+            body: b,
+            conversationId: prep.conversationId,
+            model: prep.effectiveModel,
+            email: acc.email
+        }, timestamp);
+    }
+    logResponse(res, prep, timestamp) {
+        const h = {};
+        res.headers.forEach((v, k) => {
+            h[k] = v;
+        });
+        logger.logApiResponse({
+            status: res.status,
+            statusText: res.statusText,
+            headers: h,
+            conversationId: prep.conversationId,
+            model: prep.effectiveModel
+        }, timestamp);
+    }
+    logError(prep, res, acc, apiTimestamp) {
+        const h = {};
+        res.headers.forEach((v, k) => {
+            h[k] = v;
+        });
+        const rData = {
+            status: res.status,
+            statusText: res.statusText,
+            headers: h,
+            error: `Kiro Error: ${res.status}`,
+            conversationId: prep.conversationId,
+            model: prep.effectiveModel
+        };
+        let lastB = null;
+        try {
+            lastB = prep.init.body ? JSON.parse(prep.init.body) : null;
+        }
+        catch { }
+        if (!this.config.enable_log_api_request) {
+            logger.logApiError({
+                url: prep.url,
+                method: prep.init.method,
+                headers: prep.init.headers,
+                body: lastB,
+                conversationId: prep.conversationId,
+                model: prep.effectiveModel,
+                email: acc.email
+            }, rData, logger.getTimestamp());
+        }
+    }
+    allAccountsPermanentlyUnhealthy() {
+        const accounts = this.accountManager.getAccounts();
+        if (accounts.length === 0) {
+            return false;
+        }
+        return accounts.every((acc) => !acc.isHealthy && isPermanentError(acc.unhealthyReason));
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

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

@@ -0,0 +1,5 @@
+export declare class ResponseHandler {
+    handleSuccess(response: Response, model: string, conversationId: string, streaming: boolean): Promise<Response>;
+    private handleStreaming;
+    private handleNonStreaming;
+}