@zhafron/opencode-kiro-auth 1.0.0

package/dist/src/plugin/config/loader.js

@@ -0,0 +1,143 @@
+import { existsSync, readFileSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { AccountSelectionStrategySchema, KiroConfigSchema, RegionSchema, DEFAULT_CONFIG } from "./schema";
+import * as logger from "../logger";
+function getConfigDir() {
+    const platform = process.platform;
+    if (platform === "win32") {
+        return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "opencode");
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    return join(xdgConfig, "opencode");
+}
+export function getUserConfigPath() {
+    return join(getConfigDir(), "kiro.json");
+}
+export function getProjectConfigPath(directory) {
+    return join(directory, ".opencode", "kiro.json");
+}
+export async function ensureConfigTemplate() {
+    const userConfigPath = getUserConfigPath();
+    if (existsSync(userConfigPath)) {
+        return;
+    }
+    const template = {
+        account_selection_strategy: "sticky",
+        proactive_token_refresh: true,
+        session_recovery: true,
+        default_region: "us-east-1",
+        thinking_enabled: false,
+        thinking_budget_tokens: 20000
+    };
+    try {
+        await fs.mkdir(dirname(userConfigPath), { recursive: true });
+        await fs.writeFile(userConfigPath, JSON.stringify(template, null, 2), 'utf-8');
+    }
+    catch (error) {
+        logger.warn(`Failed to create config template: ${String(error)}`);
+    }
+}
+function loadConfigFile(path) {
+    try {
+        if (!existsSync(path)) {
+            return null;
+        }
+        const content = readFileSync(path, "utf-8");
+        const rawConfig = JSON.parse(content);
+        const result = KiroConfigSchema.partial().safeParse(rawConfig);
+        if (!result.success) {
+            const issues = result.error.issues.map(i => `${i.path.join(".")}: ${i.message}`).join(", ");
+            logger.warn(`Config validation error at ${path}: ${issues}`);
+            return null;
+        }
+        return result.data;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            logger.warn(`Invalid JSON in config file ${path}: ${error.message}`);
+        }
+        else {
+            logger.warn(`Failed to load config file ${path}: ${String(error)}`);
+        }
+        return null;
+    }
+}
+function mergeConfigs(base, override) {
+    return {
+        ...base,
+        ...override,
+    };
+}
+function parseBooleanEnv(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (value === "1" || value === "true") {
+        return true;
+    }
+    if (value === "0" || value === "false") {
+        return false;
+    }
+    return fallback;
+}
+function parseNumberEnv(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (isNaN(parsed)) {
+        return fallback;
+    }
+    return parsed;
+}
+function applyEnvOverrides(config) {
+    const env = process.env;
+    return {
+        ...config,
+        quiet_mode: parseBooleanEnv(env.KIRO_QUIET_MODE, config.quiet_mode),
+        debug: parseBooleanEnv(env.KIRO_DEBUG, config.debug),
+        session_recovery: parseBooleanEnv(env.KIRO_SESSION_RECOVERY, config.session_recovery),
+        auto_resume: parseBooleanEnv(env.KIRO_AUTO_RESUME, config.auto_resume),
+        max_recovery_attempts: parseNumberEnv(env.KIRO_MAX_RECOVERY_ATTEMPTS, config.max_recovery_attempts),
+        proactive_token_refresh: parseBooleanEnv(env.KIRO_PROACTIVE_TOKEN_REFRESH, config.proactive_token_refresh),
+        token_refresh_interval_seconds: parseNumberEnv(env.KIRO_TOKEN_REFRESH_INTERVAL_SECONDS, config.token_refresh_interval_seconds),
+        token_refresh_buffer_seconds: parseNumberEnv(env.KIRO_TOKEN_REFRESH_BUFFER_SECONDS, config.token_refresh_buffer_seconds),
+        account_selection_strategy: env.KIRO_ACCOUNT_SELECTION_STRATEGY
+            ? AccountSelectionStrategySchema.catch('sticky').parse(env.KIRO_ACCOUNT_SELECTION_STRATEGY)
+            : config.account_selection_strategy,
+        thinking_enabled: parseBooleanEnv(env.KIRO_THINKING_ENABLED, config.thinking_enabled),
+        thinking_budget_tokens: parseNumberEnv(env.KIRO_THINKING_BUDGET_TOKENS, config.thinking_budget_tokens),
+        default_region: env.KIRO_DEFAULT_REGION
+            ? RegionSchema.catch('us-east-1').parse(env.KIRO_DEFAULT_REGION)
+            : config.default_region,
+        request_timeout_ms: parseNumberEnv(env.KIRO_REQUEST_TIMEOUT_MS, config.request_timeout_ms),
+        rate_limit_retry_delay_ms: parseNumberEnv(env.KIRO_RATE_LIMIT_RETRY_DELAY_MS, config.rate_limit_retry_delay_ms),
+        rate_limit_max_retries: parseNumberEnv(env.KIRO_RATE_LIMIT_MAX_RETRIES, config.rate_limit_max_retries),
+        quota_warning_threshold: parseNumberEnv(env.KIRO_QUOTA_WARNING_THRESHOLD, config.quota_warning_threshold),
+        usage_tracking_enabled: parseBooleanEnv(env.KIRO_USAGE_TRACKING_ENABLED, config.usage_tracking_enabled),
+        usage_fetch_interval_seconds: parseNumberEnv(env.KIRO_USAGE_FETCH_INTERVAL_SECONDS, config.usage_fetch_interval_seconds),
+    };
+}
+export function loadConfig(directory) {
+    let config = { ...DEFAULT_CONFIG };
+    const userConfigPath = getUserConfigPath();
+    const userConfig = loadConfigFile(userConfigPath);
+    if (userConfig) {
+        config = mergeConfigs(config, userConfig);
+    }
+    const projectConfigPath = getProjectConfigPath(directory);
+    const projectConfig = loadConfigFile(projectConfigPath);
+    if (projectConfig) {
+        config = mergeConfigs(config, projectConfig);
+    }
+    config = applyEnvOverrides(config);
+    return config;
+}
+export function configExists(path) {
+    return existsSync(path);
+}
+export function getDefaultLogsDir() {
+    return join(getConfigDir(), "kiro-logs");
+}

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

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export declare const AccountSelectionStrategySchema: z.ZodEnum<["sticky", "round-robin"]>;
+export type AccountSelectionStrategy = z.infer<typeof AccountSelectionStrategySchema>;
+export declare const RegionSchema: z.ZodEnum<["us-east-1", "us-west-2"]>;
+export type Region = z.infer<typeof RegionSchema>;
+export declare const KiroConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    quiet_mode: z.ZodDefault<z.ZodBoolean>;
+    debug: z.ZodDefault<z.ZodBoolean>;
+    session_recovery: z.ZodDefault<z.ZodBoolean>;
+    auto_resume: z.ZodDefault<z.ZodBoolean>;
+    max_recovery_attempts: z.ZodDefault<z.ZodNumber>;
+    proactive_token_refresh: z.ZodDefault<z.ZodBoolean>;
+    token_refresh_interval_seconds: z.ZodDefault<z.ZodNumber>;
+    token_refresh_buffer_seconds: z.ZodDefault<z.ZodNumber>;
+    account_selection_strategy: z.ZodDefault<z.ZodEnum<["sticky", "round-robin"]>>;
+    thinking_enabled: z.ZodDefault<z.ZodBoolean>;
+    thinking_budget_tokens: z.ZodDefault<z.ZodNumber>;
+    default_region: z.ZodDefault<z.ZodEnum<["us-east-1", "us-west-2"]>>;
+    request_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
+    rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
+    quota_warning_threshold: z.ZodDefault<z.ZodNumber>;
+    usage_tracking_enabled: z.ZodDefault<z.ZodBoolean>;
+    usage_fetch_interval_seconds: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    quiet_mode: boolean;
+    debug: boolean;
+    session_recovery: boolean;
+    auto_resume: boolean;
+    max_recovery_attempts: number;
+    proactive_token_refresh: boolean;
+    token_refresh_interval_seconds: number;
+    token_refresh_buffer_seconds: number;
+    account_selection_strategy: "sticky" | "round-robin";
+    thinking_enabled: boolean;
+    thinking_budget_tokens: number;
+    default_region: "us-east-1" | "us-west-2";
+    request_timeout_ms: number;
+    rate_limit_retry_delay_ms: number;
+    rate_limit_max_retries: number;
+    quota_warning_threshold: number;
+    usage_tracking_enabled: boolean;
+    usage_fetch_interval_seconds: number;
+    $schema?: string | undefined;
+}, {
+    $schema?: string | undefined;
+    quiet_mode?: boolean | undefined;
+    debug?: boolean | undefined;
+    session_recovery?: boolean | undefined;
+    auto_resume?: boolean | undefined;
+    max_recovery_attempts?: number | undefined;
+    proactive_token_refresh?: boolean | undefined;
+    token_refresh_interval_seconds?: number | undefined;
+    token_refresh_buffer_seconds?: number | undefined;
+    account_selection_strategy?: "sticky" | "round-robin" | undefined;
+    thinking_enabled?: boolean | undefined;
+    thinking_budget_tokens?: number | undefined;
+    default_region?: "us-east-1" | "us-west-2" | undefined;
+    request_timeout_ms?: number | undefined;
+    rate_limit_retry_delay_ms?: number | undefined;
+    rate_limit_max_retries?: number | undefined;
+    quota_warning_threshold?: number | undefined;
+    usage_tracking_enabled?: boolean | undefined;
+    usage_fetch_interval_seconds?: number | undefined;
+}>;
+export type KiroConfig = z.infer<typeof KiroConfigSchema>;
+export declare const DEFAULT_CONFIG: KiroConfig;

package/dist/src/plugin/config/schema.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export const AccountSelectionStrategySchema = z.enum(['sticky', 'round-robin']);
+export const RegionSchema = z.enum(['us-east-1', 'us-west-2']);
+export const KiroConfigSchema = z.object({
+    $schema: z.string().optional(),
+    quiet_mode: z.boolean().default(false),
+    debug: z.boolean().default(false),
+    session_recovery: z.boolean().default(true),
+    auto_resume: z.boolean().default(true),
+    max_recovery_attempts: z.number().min(1).max(10).default(3),
+    proactive_token_refresh: z.boolean().default(true),
+    token_refresh_interval_seconds: z.number().min(60).max(3600).default(300),
+    token_refresh_buffer_seconds: z.number().min(60).max(1800).default(600),
+    account_selection_strategy: AccountSelectionStrategySchema.default('sticky'),
+    thinking_enabled: z.boolean().default(false),
+    thinking_budget_tokens: z.number().min(1000).max(24576).default(20000),
+    default_region: RegionSchema.default('us-east-1'),
+    request_timeout_ms: z.number().min(10000).max(300000).default(120000),
+    rate_limit_retry_delay_ms: z.number().min(1000).max(60000).default(5000),
+    rate_limit_max_retries: z.number().min(0).max(10).default(3),
+    quota_warning_threshold: z.number().min(0).max(1).default(0.8),
+    usage_tracking_enabled: z.boolean().default(true),
+    usage_fetch_interval_seconds: z.number().min(60).max(3600).default(300),
+});
+export const DEFAULT_CONFIG = {
+    quiet_mode: false,
+    debug: false,
+    session_recovery: true,
+    auto_resume: true,
+    max_recovery_attempts: 3,
+    proactive_token_refresh: true,
+    token_refresh_interval_seconds: 300,
+    token_refresh_buffer_seconds: 600,
+    account_selection_strategy: 'sticky',
+    thinking_enabled: false,
+    thinking_budget_tokens: 20000,
+    default_region: 'us-east-1',
+    request_timeout_ms: 120000,
+    rate_limit_retry_delay_ms: 5000,
+    rate_limit_max_retries: 3,
+    quota_warning_threshold: 0.8,
+    usage_tracking_enabled: true,
+    usage_fetch_interval_seconds: 300,
+};

package/dist/src/plugin/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function isDebugEnabled(): boolean;
+export declare function debugLog(context: string, message: string, data?: unknown): void;

package/dist/src/plugin/debug.js

@@ -0,0 +1,9 @@
+export function isDebugEnabled() {
+    return !!process.env.DEBUG;
+}
+export function debugLog(context, message, data) {
+    if (isDebugEnabled()) {
+        const formattedData = data !== undefined ? ` ${JSON.stringify(data)}` : '';
+        console.debug(`[${context}] ${message}${formattedData}`);
+    }
+}

package/dist/src/plugin/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class KiroTokenRefreshError extends Error {
+    code?: string;
+    originalError?: Error;
+    constructor(message: string, code?: string, originalError?: Error);
+}
+export declare class KiroQuotaExhaustedError extends Error {
+    recoveryTime?: number;
+    constructor(message: string, recoveryTime?: number);
+}
+export declare class KiroRateLimitError extends Error {
+    retryAfter?: number;
+    constructor(message: string, retryAfter?: number);
+}
+export declare class KiroAuthError extends Error {
+    statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}

package/dist/src/plugin/errors.js

@@ -0,0 +1,34 @@
+export class KiroTokenRefreshError extends Error {
+    code;
+    originalError;
+    constructor(message, code, originalError) {
+        super(message);
+        this.name = 'KiroTokenRefreshError';
+        this.code = code;
+        this.originalError = originalError;
+    }
+}
+export class KiroQuotaExhaustedError extends Error {
+    recoveryTime;
+    constructor(message, recoveryTime) {
+        super(message);
+        this.name = 'KiroQuotaExhaustedError';
+        this.recoveryTime = recoveryTime;
+    }
+}
+export class KiroRateLimitError extends Error {
+    retryAfter;
+    constructor(message, retryAfter) {
+        super(message);
+        this.name = 'KiroRateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+export class KiroAuthError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.name = 'KiroAuthError';
+        this.statusCode = statusCode;
+    }
+}

package/dist/src/plugin/logger.d.ts

@@ -0,0 +1,4 @@
+export declare function log(message: string, ...args: unknown[]): void;
+export declare function error(message: string, ...args: unknown[]): void;
+export declare function warn(message: string, ...args: unknown[]): void;
+export declare function debug(message: string, ...args: unknown[]): void;

package/dist/src/plugin/logger.js

@@ -0,0 +1,17 @@
+function formatTimestamp() {
+    return new Date().toISOString();
+}
+export function log(message, ...args) {
+    console.log(`[${formatTimestamp()}] ${message}`, ...args);
+}
+export function error(message, ...args) {
+    console.error(`[${formatTimestamp()}] ERROR: ${message}`, ...args);
+}
+export function warn(message, ...args) {
+    console.warn(`[${formatTimestamp()}] WARN: ${message}`, ...args);
+}
+export function debug(message, ...args) {
+    if (process.env.DEBUG) {
+        console.debug(`[${formatTimestamp()}] DEBUG: ${message}`, ...args);
+    }
+}

package/dist/src/plugin/models.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveKiroModel(model: string): string;
+export declare function getSupportedModels(): string[];
+export declare function isModelSupported(model: string): boolean;

package/dist/src/plugin/models.js

@@ -0,0 +1,14 @@
+import { MODEL_MAPPING, SUPPORTED_MODELS } from '../constants';
+export function resolveKiroModel(model) {
+    const resolved = MODEL_MAPPING[model];
+    if (!resolved) {
+        throw new Error(`Unsupported model: ${model}. Supported models: ${SUPPORTED_MODELS.join(', ')}`);
+    }
+    return resolved;
+}
+export function getSupportedModels() {
+    return SUPPORTED_MODELS;
+}
+export function isModelSupported(model) {
+    return SUPPORTED_MODELS.includes(model);
+}

package/dist/src/plugin/oauth-parser.d.ts

@@ -0,0 +1,5 @@
+export interface ParsedOAuthCallback {
+    code: string;
+    state: string;
+}
+export declare function parseOAuthCallbackInput(input: string): ParsedOAuthCallback;

package/dist/src/plugin/oauth-parser.js

@@ -0,0 +1,23 @@
+export function parseOAuthCallbackInput(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const code = url.searchParams.get('code');
+        const state = url.searchParams.get('state');
+        if (!code || !state) {
+            throw new Error('Missing code or state in URL');
+        }
+        return { code, state };
+    }
+    catch {
+        const codeMatch = trimmed.match(/code=([^&\s]+)/);
+        const stateMatch = trimmed.match(/state=([^&\s]+)/);
+        if (codeMatch?.[1] && stateMatch?.[1]) {
+            return {
+                code: decodeURIComponent(codeMatch[1]),
+                state: decodeURIComponent(stateMatch[1]),
+            };
+        }
+        throw new Error('Invalid OAuth callback format. Expected full URL or query string with code and state parameters.');
+    }
+}

package/dist/src/plugin/quota.d.ts

@@ -0,0 +1,25 @@
+import { ManagedAccount, UsageLimits } from './types';
+export type QuotaStatus = 'healthy' | 'warning' | 'exhausted';
+export interface QuotaInfo {
+    status: QuotaStatus;
+    used: number;
+    limit: number;
+    remaining: number;
+    percentage: number;
+    recoveryTime?: number;
+}
+export declare function checkQuotaStatus(account: ManagedAccount): QuotaStatus;
+export declare function updateAccountQuota(account: ManagedAccount, usage: UsageLimits): void;
+export declare function getNextAvailableAccount(accounts: ManagedAccount[]): ManagedAccount | null;
+export declare function sortAccountsByQuota(accounts: ManagedAccount[]): ManagedAccount[];
+export declare function buildQuotaInfo(account: ManagedAccount): QuotaInfo;
+export declare function filterHealthyAccounts(accounts: ManagedAccount[]): ManagedAccount[];
+export declare function filterExhaustedAccounts(accounts: ManagedAccount[]): ManagedAccount[];
+export declare function filterWarningAccounts(accounts: ManagedAccount[]): ManagedAccount[];
+export declare function hasAvailableQuota(account: ManagedAccount): boolean;
+export declare function isQuotaNearLimit(account: ManagedAccount, thresholdPercent?: number): boolean;
+export declare function getAccountWithMostQuota(accounts: ManagedAccount[]): ManagedAccount | null;
+export declare function getAccountWithLeastQuota(accounts: ManagedAccount[]): ManagedAccount | null;
+export declare function getTotalQuotaInfo(accounts: ManagedAccount[]): QuotaInfo;
+export declare function shouldRotateAccount(account: ManagedAccount, rotationThreshold?: number): boolean;
+export declare function selectAccountForRequest(accounts: ManagedAccount[], strategy?: 'least-used' | 'most-quota'): ManagedAccount | null;

package/dist/src/plugin/quota.js

@@ -0,0 +1,175 @@
+import { calculateUsagePercentage, isQuotaExhausted, getRemainingCount } from './usage';
+const WARNING_THRESHOLD_PERCENT = 80;
+export function checkQuotaStatus(account) {
+    if (!account.usedCount || !account.limitCount) {
+        return 'healthy';
+    }
+    const usage = {
+        usedCount: account.usedCount,
+        limitCount: account.limitCount,
+    };
+    if (isQuotaExhausted(usage)) {
+        return 'exhausted';
+    }
+    const percentage = calculateUsagePercentage(usage);
+    if (percentage >= WARNING_THRESHOLD_PERCENT) {
+        return 'warning';
+    }
+    return 'healthy';
+}
+export function updateAccountQuota(account, usage) {
+    account.usedCount = usage.usedCount;
+    account.limitCount = usage.limitCount;
+}
+export function getNextAvailableAccount(accounts) {
+    const availableAccounts = accounts.filter(account => {
+        if (!account.isHealthy) {
+            return false;
+        }
+        const status = checkQuotaStatus(account);
+        return status !== 'exhausted';
+    });
+    if (availableAccounts.length === 0) {
+        return null;
+    }
+    return availableAccounts[0] || null;
+}
+export function sortAccountsByQuota(accounts) {
+    return [...accounts].sort((a, b) => {
+        const aRemaining = getRemainingQuota(a);
+        const bRemaining = getRemainingQuota(b);
+        return bRemaining - aRemaining;
+    });
+}
+function getRemainingQuota(account) {
+    if (!account.usedCount || !account.limitCount) {
+        return Infinity;
+    }
+    const usage = {
+        usedCount: account.usedCount,
+        limitCount: account.limitCount,
+    };
+    return getRemainingCount(usage);
+}
+export function buildQuotaInfo(account) {
+    const used = account.usedCount || 0;
+    const limit = account.limitCount || 0;
+    const remaining = Math.max(0, limit - used);
+    const percentage = limit > 0 ? Math.round((used / limit) * 100) : 0;
+    const status = checkQuotaStatus(account);
+    const info = {
+        status,
+        used,
+        limit,
+        remaining,
+        percentage,
+    };
+    if (account.recoveryTime) {
+        info.recoveryTime = account.recoveryTime;
+    }
+    return info;
+}
+export function filterHealthyAccounts(accounts) {
+    return accounts.filter(account => {
+        if (!account.isHealthy) {
+            return false;
+        }
+        const status = checkQuotaStatus(account);
+        return status !== 'exhausted';
+    });
+}
+export function filterExhaustedAccounts(accounts) {
+    return accounts.filter(account => {
+        const status = checkQuotaStatus(account);
+        return status === 'exhausted';
+    });
+}
+export function filterWarningAccounts(accounts) {
+    return accounts.filter(account => {
+        const status = checkQuotaStatus(account);
+        return status === 'warning';
+    });
+}
+export function hasAvailableQuota(account) {
+    const status = checkQuotaStatus(account);
+    return status !== 'exhausted';
+}
+export function isQuotaNearLimit(account, thresholdPercent = WARNING_THRESHOLD_PERCENT) {
+    if (!account.usedCount || !account.limitCount) {
+        return false;
+    }
+    const usage = {
+        usedCount: account.usedCount,
+        limitCount: account.limitCount,
+    };
+    const percentage = calculateUsagePercentage(usage);
+    return percentage >= thresholdPercent;
+}
+export function getAccountWithMostQuota(accounts) {
+    const healthyAccounts = filterHealthyAccounts(accounts);
+    if (healthyAccounts.length === 0) {
+        return null;
+    }
+    const sorted = sortAccountsByQuota(healthyAccounts);
+    return sorted[0] || null;
+}
+export function getAccountWithLeastQuota(accounts) {
+    const healthyAccounts = filterHealthyAccounts(accounts);
+    if (healthyAccounts.length === 0) {
+        return null;
+    }
+    const sorted = sortAccountsByQuota(healthyAccounts);
+    return sorted[sorted.length - 1] || null;
+}
+export function getTotalQuotaInfo(accounts) {
+    let totalUsed = 0;
+    let totalLimit = 0;
+    for (const account of accounts) {
+        if (account.usedCount && account.limitCount) {
+            totalUsed += account.usedCount;
+            totalLimit += account.limitCount;
+        }
+    }
+    const remaining = Math.max(0, totalLimit - totalUsed);
+    const percentage = totalLimit > 0 ? Math.round((totalUsed / totalLimit) * 100) : 0;
+    let status = 'healthy';
+    if (totalUsed >= totalLimit) {
+        status = 'exhausted';
+    }
+    else if (percentage >= WARNING_THRESHOLD_PERCENT) {
+        status = 'warning';
+    }
+    return {
+        status,
+        used: totalUsed,
+        limit: totalLimit,
+        remaining,
+        percentage,
+    };
+}
+export function shouldRotateAccount(account, rotationThreshold = 90) {
+    if (!account.usedCount || !account.limitCount) {
+        return false;
+    }
+    const usage = {
+        usedCount: account.usedCount,
+        limitCount: account.limitCount,
+    };
+    const percentage = calculateUsagePercentage(usage);
+    return percentage >= rotationThreshold;
+}
+export function selectAccountForRequest(accounts, strategy = 'most-quota') {
+    const healthyAccounts = filterHealthyAccounts(accounts);
+    if (healthyAccounts.length === 0) {
+        return null;
+    }
+    if (strategy === 'most-quota') {
+        return getAccountWithMostQuota(healthyAccounts);
+    }
+    const sorted = healthyAccounts.sort((a, b) => {
+        const aLastUsed = a.lastUsed || 0;
+        const bLastUsed = b.lastUsed || 0;
+        return aLastUsed - bLastUsed;
+    });
+    return sorted[0] || null;
+}

package/dist/src/plugin/recovery.d.ts

@@ -0,0 +1,19 @@
+export interface RecoveryState {
+    sessionId: string;
+    conversationId: string;
+    model: string;
+    lastMessageIndex: number;
+    errorCount: number;
+    lastError?: string;
+    timestamp: number;
+}
+export interface RecoveryStorage {
+    version: 1;
+    sessions: Record<string, RecoveryState>;
+}
+export interface SessionRecoveryHook {
+    handleSessionError(error: any, sessionId: string): Promise<boolean>;
+    isRecoverableError(error: any): boolean;
+    clearSession(sessionId: string): Promise<void>;
+}
+export declare function createSessionRecoveryHook(enabled: boolean, autoResume: boolean): SessionRecoveryHook;