@sunerpy/opencode-kiro-auth 0.1.0

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

@@ -0,0 +1,159 @@
+export class ErrorHandler {
+    config;
+    accountManager;
+    repository;
+    forceRefresh;
+    constructor(config, accountManager, repository, forceRefresh) {
+        this.config = config;
+        this.accountManager = accountManager;
+        this.repository = repository;
+        this.forceRefresh = forceRefresh;
+    }
+    async handle(error, response, account, context, showToast) {
+        const readBody = async () => {
+            try {
+                const body = JSON.parse(await response.clone().text());
+                return body.message || body.Message || body.__type || JSON.stringify(body);
+            }
+            catch {
+                return '';
+            }
+        };
+        if (response.status === 400) {
+            const reason = await readBody();
+            showToast(`400: ${reason || 'unknown'}`, 'error');
+            return { shouldRetry: false };
+        }
+        if (response.status === 401 && context.retry < this.config.rate_limit_max_retries) {
+            const reason = await readBody();
+            showToast(`401: ${reason || 'Unauthorized'}. Retrying...`, 'warning');
+            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(`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(`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) {
+                return { shouldRetry: true, switchAccount: true };
+            }
+            showToast(`429: Rate limited. Waiting ${Math.ceil(w / 1000)}s...`, 'warning');
+            await this.sleep(w);
+            return { shouldRetry: true };
+        }
+        if (response.status === 402 || response.status === 403) {
+            let errorReason = response.status === 402 ? 'Quota' : 'Forbidden';
+            let isPermanent = false;
+            const errorBody = await response.text();
+            const errorData = (() => {
+                try {
+                    return JSON.parse(errorBody);
+                }
+                catch {
+                    return null;
+                }
+            })();
+            if (errorData?.message) {
+                errorReason = errorData.message;
+            }
+            if (errorData?.reason === 'INVALID_MODEL_ID') {
+                throw new Error(`Invalid model: ${errorData.message}`);
+            }
+            if (errorData?.reason === 'TEMPORARILY_SUSPENDED') {
+                errorReason = 'Account Suspended';
+                isPermanent = true;
+            }
+            const isInvalidBearer = errorReason.includes('bearer token included in the request is invalid') ||
+                errorReason.includes('The bearer token included in the request is invalid');
+            if (response.status === 403 &&
+                isInvalidBearer &&
+                !context.bearerRefreshAttempted &&
+                this.forceRefresh) {
+                const refreshed = await this.forceRefresh(account, showToast);
+                if (refreshed) {
+                    showToast('403: Stale token detected. Refreshed and retrying...', 'warning');
+                    return {
+                        shouldRetry: true,
+                        newContext: { ...context, bearerRefreshAttempted: true }
+                    };
+                }
+            }
+            if (isInvalidBearer) {
+                isPermanent = true;
+            }
+            if (isPermanent) {
+                account.failCount = 10;
+            }
+            if (this.accountManager.getAccountCount() > 1) {
+                showToast(`${response.status}: ${errorReason}. Switching account...`, 'warning');
+                this.accountManager.markUnhealthy(account, errorReason);
+                await this.repository.batchSave(this.accountManager.getAccounts());
+                return { shouldRetry: true, switchAccount: true };
+            }
+            if (response.status === 403 &&
+                !isPermanent &&
+                context.retry < this.config.rate_limit_max_retries) {
+                const delay = this.config.rate_limit_retry_delay_ms * Math.pow(2, context.retry);
+                showToast(`403: ${errorReason}. Retrying in ${Math.ceil(delay / 1000)}s...`, 'warning');
+                await this.sleep(delay);
+                return {
+                    shouldRetry: true,
+                    newContext: { ...context, retry: context.retry + 1 }
+                };
+            }
+            showToast(`${response.status}: ${errorReason}`, 'error');
+            return { shouldRetry: false };
+        }
+        const reason = await readBody();
+        showToast(`${response.status}: ${reason || response.statusText}`, 'error');
+        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,35 @@
+import type { AccountRepository } from '../../infrastructure/database/account-repository.js';
+import type { AccountManager } from '../../plugin/accounts.js';
+import type { KiroConfig } from '../../plugin/config/index.js';
+type ToastFunction = (message: string, variant: 'info' | 'warning' | 'success' | 'error') => void;
+export declare class RequestHandler {
+    private accountManager;
+    private config;
+    private repository;
+    private client?;
+    private accountSelector;
+    private tokenRefresher;
+    private errorHandler;
+    private responseHandler;
+    private usageTracker;
+    private retryStrategy;
+    private reauthInFlight;
+    private lastFailedReauthAt;
+    private static kiroRequestQueue;
+    constructor(accountManager: AccountManager, config: KiroConfig, repository: AccountRepository, client?: any | undefined);
+    handle(input: any, init: any, showToast: ToastFunction): Promise<Response>;
+    private enqueueKiroRequest;
+    private handleKiroRequest;
+    private extractModel;
+    private prepareSdkRequest;
+    private handleSuccessfulRequest;
+    private logSdkRequest;
+    private logSdkResponse;
+    private logSdkError;
+    private triggerReauth;
+    private performReauth;
+    private hasUsableAccount;
+    private allAccountsPermanentlyUnhealthy;
+    private sleep;
+}
+export {};

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

@@ -0,0 +1,296 @@
+import { GenerateAssistantResponseCommand } from '@aws/codewhisperer-streaming-client';
+import { isPermanentError } from '../../plugin/health.js';
+import * as logger from '../../plugin/logger.js';
+import { transformToSdkRequest } from '../../plugin/request.js';
+import { createSdkClient } from '../../plugin/sdk-client.js';
+import { syncFromKiroCli } from '../../plugin/sync/kiro-cli.js';
+import { AccountSelector } from '../account/account-selector.js';
+import { UsageTracker } from '../account/usage-tracker.js';
+import { TokenRefresher } from '../auth/token-refresher.js';
+import { ErrorHandler } from './error-handler.js';
+import { ResponseHandler } from './response-handler.js';
+import { RetryStrategy } from './retry-strategy.js';
+const KIRO_API_PATTERN = /^(https?:\/\/)?q\.[a-z0-9-]+\.amazonaws\.com/;
+const REAUTH_FAILURE_COOLDOWN_MS = 60000;
+export class RequestHandler {
+    accountManager;
+    config;
+    repository;
+    client;
+    accountSelector;
+    tokenRefresher;
+    errorHandler;
+    responseHandler;
+    usageTracker;
+    retryStrategy;
+    reauthInFlight = null;
+    lastFailedReauthAt = 0;
+    static kiroRequestQueue = Promise.resolve();
+    constructor(accountManager, config, repository, client) {
+        this.accountManager = accountManager;
+        this.config = config;
+        this.repository = repository;
+        this.client = client;
+        this.accountSelector = new AccountSelector(accountManager, config, syncFromKiroCli, repository);
+        this.tokenRefresher = new TokenRefresher(config, accountManager, syncFromKiroCli, repository);
+        this.errorHandler = new ErrorHandler(config, accountManager, repository, (acc, toast) => this.tokenRefresher.forceRefresh(acc, toast));
+        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.enqueueKiroRequest(() => this.handleKiroRequest(url, init, showToast));
+    }
+    async enqueueKiroRequest(run) {
+        const previous = RequestHandler.kiroRequestQueue;
+        let release;
+        RequestHandler.kiroRequestQueue = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous.catch(() => { });
+        try {
+            return await run();
+        }
+        finally {
+            release();
+        }
+    }
+    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 || !!body.thinkingConfig;
+        const budget = body.providerOptions?.thinkingConfig?.thinkingBudget ||
+            body.thinkingConfig?.thinkingBudget ||
+            body.thinkingConfig?.budget_tokens ||
+            20000;
+        let handlerContext = { 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()) {
+                const reauthed = await this.triggerReauth(showToast);
+                if (!reauthed) {
+                    throw new Error('All accounts are permanently unhealthy. Please re-authenticate.');
+                }
+                continue;
+            }
+            let acc = await this.accountSelector.selectHealthyAccount(showToast).catch(async (e) => {
+                if (e instanceof Error && e.message.includes('reauth required')) {
+                    const reauthed = await this.triggerReauth(showToast);
+                    if (!reauthed)
+                        throw new Error('All accounts are unhealthy or rate-limited. Please re-authenticate.');
+                    return null;
+                }
+                throw e;
+            });
+            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 sdkPrep = this.prepareSdkRequest(init?.body, model, auth, think, budget, showToast);
+            const apiTimestamp = this.config.enable_log_api_request ? logger.getTimestamp() : null;
+            if (apiTimestamp) {
+                this.logSdkRequest(sdkPrep, acc, apiTimestamp);
+            }
+            try {
+                const client = createSdkClient(auth, sdkPrep.region, sdkPrep.effort);
+                const command = new GenerateAssistantResponseCommand({
+                    conversationState: sdkPrep.conversationState,
+                    profileArn: sdkPrep.profileArn
+                });
+                const sdkResponse = await client.send(command);
+                if (apiTimestamp) {
+                    this.logSdkResponse(sdkPrep, apiTimestamp);
+                }
+                this.handleSuccessfulRequest(acc);
+                this.usageTracker.syncUsage(acc, auth);
+                return await this.responseHandler.handleSdkSuccess(sdkResponse, model, sdkPrep.conversationId, sdkPrep.streaming);
+            }
+            catch (e) {
+                const httpStatus = e?.$metadata?.httpStatusCode;
+                if (httpStatus) {
+                    if (apiTimestamp) {
+                        this.logSdkError(sdkPrep, e, acc, apiTimestamp);
+                    }
+                    const mockResponse = new Response(JSON.stringify({ message: e.message, __type: e.name }), {
+                        status: httpStatus,
+                        statusText: e.name || 'Error',
+                        headers: { 'Content-Type': 'application/json' }
+                    });
+                    const errorResult = await this.errorHandler.handle(e, mockResponse, acc, handlerContext, showToast);
+                    if (errorResult.shouldRetry) {
+                        if (errorResult.newContext) {
+                            handlerContext = errorResult.newContext;
+                        }
+                        if (errorResult.switchAccount) {
+                            continue;
+                        }
+                        continue;
+                    }
+                    throw new Error(`Kiro Error: ${httpStatus}`);
+                }
+                const networkResult = await this.errorHandler.handleNetworkError(e, handlerContext, showToast);
+                if (networkResult.shouldRetry) {
+                    if (networkResult.newContext) {
+                        handlerContext = { ...handlerContext, ...networkResult.newContext };
+                    }
+                    continue;
+                }
+                throw e;
+            }
+        }
+    }
+    extractModel(url) {
+        return url.match(/models\/([^/:]+)/)?.[1] || null;
+    }
+    prepareSdkRequest(body, model, auth, think, budget, showToast) {
+        return transformToSdkRequest(body, model, auth, think, budget, showToast, {
+            effort: this.config.effort,
+            autoEffortMapping: this.config.auto_effort_mapping
+        });
+    }
+    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(() => { });
+            }
+        }
+    }
+    logSdkRequest(prep, acc, timestamp) {
+        logger.logApiRequest({
+            url: `https://q.${prep.region}.amazonaws.com/generateAssistantResponse`,
+            method: 'POST',
+            headers: { 'x-amzn-kiro-agent-mode': 'vibe' },
+            body: {
+                conversationState: {
+                    chatTriggerType: prep.conversationState.chatTriggerType,
+                    conversationId: prep.conversationState.conversationId,
+                    historyLength: prep.conversationState.history?.length || 0,
+                    currentMessage: prep.conversationState.currentMessage
+                },
+                profileArn: prep.profileArn
+            },
+            conversationId: prep.conversationId,
+            model: prep.effectiveModel,
+            email: acc.email
+        }, timestamp);
+    }
+    logSdkResponse(prep, timestamp) {
+        logger.logApiResponse({
+            status: 200,
+            statusText: 'OK',
+            headers: {},
+            conversationId: prep.conversationId,
+            model: prep.effectiveModel
+        }, timestamp);
+    }
+    logSdkError(prep, error, acc, apiTimestamp) {
+        const status = error?.$metadata?.httpStatusCode || 0;
+        const rData = {
+            status,
+            statusText: error?.name || 'Error',
+            headers: {},
+            error: `Kiro Error: ${status} - ${error?.message || 'Unknown'}`,
+            conversationId: prep.conversationId,
+            model: prep.effectiveModel
+        };
+        if (!this.config.enable_log_api_request) {
+            logger.logApiError({
+                url: `https://q.${prep.region}.amazonaws.com/generateAssistantResponse`,
+                method: 'POST',
+                headers: {},
+                body: null,
+                conversationId: prep.conversationId,
+                model: prep.effectiveModel,
+                email: acc.email
+            }, rData, logger.getTimestamp());
+        }
+        else {
+            logger.logApiResponse(rData, apiTimestamp);
+        }
+    }
+    async triggerReauth(showToast) {
+        if (!this.client)
+            return false;
+        const cooldownRemaining = REAUTH_FAILURE_COOLDOWN_MS - (Date.now() - this.lastFailedReauthAt);
+        if (cooldownRemaining > 0) {
+            showToast('Recent re-authentication failed. Please complete authentication manually.', 'error');
+            return false;
+        }
+        if (this.reauthInFlight) {
+            return this.reauthInFlight;
+        }
+        this.reauthInFlight = this.performReauth(showToast);
+        const success = await this.reauthInFlight.finally(() => {
+            this.reauthInFlight = null;
+        });
+        if (!success)
+            this.lastFailedReauthAt = Date.now();
+        return success;
+    }
+    async performReauth(showToast) {
+        try {
+            showToast('Session expired. Re-authenticating...', 'warning');
+            await this.client.provider.oauth.authorize({
+                path: { id: 'kiro-auth' },
+                body: { method: 0 }
+            });
+            await this.client.provider.oauth.callback({
+                path: { id: 'kiro-auth' },
+                body: { method: 0 }
+            });
+            this.repository.invalidateCache();
+            const accounts = await this.repository.findAll();
+            for (const acc of accounts) {
+                this.accountManager.addAccount(acc);
+            }
+            if (!this.hasUsableAccount(accounts)) {
+                logger.warn('Re-auth completed but no usable Kiro account was found');
+                showToast('Re-authentication completed but no usable Kiro account was found.', 'error');
+                return false;
+            }
+            showToast('Re-authentication successful.', 'success');
+            return true;
+        }
+        catch (e) {
+            logger.error('Re-auth failed', e instanceof Error ? e : new Error(String(e)));
+            return false;
+        }
+    }
+    hasUsableAccount(accounts) {
+        const now = Date.now();
+        return accounts.some((acc) => acc.isHealthy && acc.expiresAt > now && !isPermanentError(acc.unhealthyReason));
+    }
+    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,8 @@
+export declare class ResponseHandler {
+    handleSuccess(response: Response, model: string, conversationId: string, streaming: boolean): Promise<Response>;
+    handleSdkSuccess(sdkResponse: any, model: string, conversationId: string, streaming: boolean): Promise<Response>;
+    private handleStreaming;
+    private handleSdkStreaming;
+    private handleNonStreaming;
+    private handleSdkNonStreaming;
+}

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

@@ -0,0 +1,137 @@
+import { parseEventStream } from '../../plugin/response.js';
+import { transformKiroStream } from '../../plugin/streaming/index.js';
+import { transformSdkStream } from '../../plugin/streaming/sdk-stream-transformer.js';
+export class ResponseHandler {
+    async handleSuccess(response, model, conversationId, streaming) {
+        if (streaming) {
+            return this.handleStreaming(response, model, conversationId);
+        }
+        return this.handleNonStreaming(response, model, conversationId);
+    }
+    async handleSdkSuccess(sdkResponse, model, conversationId, streaming) {
+        if (streaming) {
+            return this.handleSdkStreaming(sdkResponse, model, conversationId);
+        }
+        return this.handleSdkNonStreaming(sdkResponse, model, conversationId);
+    }
+    async handleStreaming(response, model, conversationId) {
+        const s = transformKiroStream(response, model, conversationId);
+        return new Response(new ReadableStream({
+            async start(c) {
+                try {
+                    for await (const e of s) {
+                        c.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(e)}\n\n`));
+                    }
+                    c.close();
+                }
+                catch (err) {
+                    c.error(err);
+                }
+            }
+        }), { headers: { 'Content-Type': 'text/event-stream' } });
+    }
+    async handleSdkStreaming(sdkResponse, model, conversationId) {
+        const s = transformSdkStream(sdkResponse, model, conversationId);
+        return new Response(new ReadableStream({
+            async start(c) {
+                try {
+                    for await (const e of s) {
+                        c.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(e)}\n\n`));
+                    }
+                    c.close();
+                }
+                catch (err) {
+                    c.error(err);
+                }
+            }
+        }), { headers: { 'Content-Type': 'text/event-stream' } });
+    }
+    async handleNonStreaming(response, model, conversationId) {
+        const text = await response.text();
+        const p = parseEventStream(text, model);
+        const oai = {
+            id: conversationId,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [
+                {
+                    index: 0,
+                    message: { role: 'assistant', content: p.content },
+                    finish_reason: p.stopReason === 'tool_use' ? 'tool_calls' : 'stop'
+                }
+            ],
+            usage: {
+                prompt_tokens: p.inputTokens || 0,
+                completion_tokens: p.outputTokens || 0,
+                total_tokens: (p.inputTokens || 0) + (p.outputTokens || 0)
+            }
+        };
+        if (p.toolCalls.length > 0) {
+            oai.choices[0].message.tool_calls = p.toolCalls.map((tc) => ({
+                id: tc.toolUseId,
+                type: 'function',
+                function: {
+                    name: tc.name,
+                    arguments: typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input)
+                }
+            }));
+        }
+        return new Response(JSON.stringify(oai), {
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+    async handleSdkNonStreaming(sdkResponse, model, conversationId) {
+        // For non-streaming SDK responses, collect all events
+        let content = '';
+        const toolCalls = [];
+        let inputTokens = 0;
+        let outputTokens = 0;
+        const eventStream = sdkResponse.generateAssistantResponseResponse;
+        if (eventStream) {
+            for await (const event of eventStream) {
+                if (event.assistantResponseEvent?.content) {
+                    content += event.assistantResponseEvent.content;
+                }
+                if (event.toolUseEvent) {
+                    toolCalls.push(event.toolUseEvent);
+                }
+                if (event.metadataEvent?.tokenUsage) {
+                    inputTokens = event.metadataEvent.tokenUsage.inputTokens || 0;
+                    outputTokens = event.metadataEvent.tokenUsage.outputTokens || 0;
+                }
+            }
+        }
+        const oai = {
+            id: conversationId,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [
+                {
+                    index: 0,
+                    message: { role: 'assistant', content },
+                    finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop'
+                }
+            ],
+            usage: {
+                prompt_tokens: inputTokens,
+                completion_tokens: outputTokens,
+                total_tokens: inputTokens + outputTokens
+            }
+        };
+        if (toolCalls.length > 0) {
+            oai.choices[0].message.tool_calls = toolCalls.map((tc) => ({
+                id: tc.toolUseId,
+                type: 'function',
+                function: {
+                    name: tc.name,
+                    arguments: typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input)
+                }
+            }));
+        }
+        return new Response(JSON.stringify(oai), {
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+}

package/dist/core/request/retry-strategy.d.ts

@@ -0,0 +1,18 @@
+interface RetryConfig {
+    max_request_iterations: number;
+    request_timeout_ms: number;
+}
+interface RetryContext {
+    iterations: number;
+    startTime: number;
+}
+export declare class RetryStrategy {
+    private config;
+    constructor(config: RetryConfig);
+    shouldContinue(context: RetryContext): {
+        canContinue: boolean;
+        error?: string;
+    };
+    createContext(): RetryContext;
+}
+export {};

package/dist/core/request/retry-strategy.js

@@ -0,0 +1,28 @@
+export class RetryStrategy {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    shouldContinue(context) {
+        context.iterations++;
+        if (context.iterations > this.config.max_request_iterations) {
+            return {
+                canContinue: false,
+                error: `Exceeded max iterations (${this.config.max_request_iterations})`
+            };
+        }
+        if (Date.now() - context.startTime > this.config.request_timeout_ms) {
+            return {
+                canContinue: false,
+                error: 'Request timeout'
+            };
+        }
+        return { canContinue: true };
+    }
+    createContext() {
+        return {
+            iterations: 0,
+            startTime: Date.now()
+        };
+    }
+}