@sunerpy/opencode-kiro-auth 0.1.0

package/dist/plugin/config/index.js

@@ -0,0 +1,2 @@
+export { configExists, getDefaultLogsDir, getProjectConfigPath, getUserConfigPath, loadConfig } from './loader.js';
+export { DEFAULT_CONFIG, KiroConfigSchema } from './schema.js';

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

@@ -0,0 +1,6 @@
+import { type KiroConfig } from './schema.js';
+export declare function getUserConfigPath(): string;
+export declare function getProjectConfigPath(directory: string): string;
+export declare function loadConfig(directory: string): KiroConfig;
+export declare function configExists(path: string): boolean;
+export declare function getDefaultLogsDir(): string;

package/dist/plugin/config/loader.js

@@ -0,0 +1,129 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import * as logger from '../logger.js';
+import { AccountSelectionStrategySchema, DEFAULT_CONFIG, KiroConfigSchema, RegionSchema } from './schema.js';
+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');
+}
+function ensureUserConfigTemplate() {
+    const path = getUserConfigPath();
+    if (!existsSync(path)) {
+        try {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
+            logger.log(`Created default config template at ${path}`);
+        }
+        catch (error) {
+            logger.warn(`Failed to create config template at ${path}: ${String(error)}`);
+        }
+    }
+}
+export function getProjectConfigPath(directory) {
+    return join(directory, '.opencode', 'kiro.json');
+}
+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,
+        account_selection_strategy: env.KIRO_ACCOUNT_SELECTION_STRATEGY
+            ? AccountSelectionStrategySchema.catch('lowest-usage').parse(env.KIRO_ACCOUNT_SELECTION_STRATEGY)
+            : config.account_selection_strategy,
+        default_region: env.KIRO_DEFAULT_REGION
+            ? RegionSchema.catch('us-east-1').parse(env.KIRO_DEFAULT_REGION)
+            : config.default_region,
+        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),
+        max_request_iterations: parseNumberEnv(env.KIRO_MAX_REQUEST_ITERATIONS, config.max_request_iterations),
+        request_timeout_ms: parseNumberEnv(env.KIRO_REQUEST_TIMEOUT_MS, config.request_timeout_ms),
+        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),
+        auth_server_port_range: parseNumberEnv(env.KIRO_AUTH_SERVER_PORT_RANGE, config.auth_server_port_range),
+        usage_tracking_enabled: parseBooleanEnv(env.KIRO_USAGE_TRACKING_ENABLED, config.usage_tracking_enabled),
+        enable_log_api_request: parseBooleanEnv(env.KIRO_ENABLE_LOG_API_REQUEST, config.enable_log_api_request)
+    };
+}
+export function loadConfig(directory) {
+    ensureUserConfigTemplate();
+    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/plugin/config/schema.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const AccountSelectionStrategySchema: z.ZodEnum<["sticky", "round-robin", "lowest-usage"]>;
+export type AccountSelectionStrategy = z.infer<typeof AccountSelectionStrategySchema>;
+/**
+ * Kiro effort levels control thinking/reasoning depth.
+ * - low: minimal reasoning
+ * - medium: balanced (default when thinking enabled)
+ * - high: deeper reasoning
+ * - xhigh: extended reasoning (opus-4.7, opus-4.8 only)
+ * - max: maximum reasoning depth (128k thinking tokens on opus-4.7/4.8)
+ */
+export declare const EffortSchema: z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>;
+export type Effort = z.infer<typeof EffortSchema>;
+export declare const RegionSchema: z.ZodEnum<["us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-5", "ap-southeast-4", "ap-south-1", "ap-southeast-6", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-east-2", "ap-southeast-7", "ap-northeast-1", "ca-central-1", "ca-west-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-south-1", "eu-west-3", "eu-south-2", "eu-north-1", "eu-central-2", "il-central-1", "mx-central-1", "me-south-1", "me-central-1", "sa-east-1"]>;
+export type Region = z.infer<typeof RegionSchema>;
+export declare const KiroConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    idc_start_url: z.ZodOptional<z.ZodString>;
+    idc_region: z.ZodOptional<z.ZodEnum<["us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-5", "ap-southeast-4", "ap-south-1", "ap-southeast-6", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-east-2", "ap-southeast-7", "ap-northeast-1", "ca-central-1", "ca-west-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-south-1", "eu-west-3", "eu-south-2", "eu-north-1", "eu-central-2", "il-central-1", "mx-central-1", "me-south-1", "me-central-1", "sa-east-1"]>>;
+    idc_profile_arn: z.ZodOptional<z.ZodString>;
+    account_selection_strategy: z.ZodDefault<z.ZodEnum<["sticky", "round-robin", "lowest-usage"]>>;
+    default_region: z.ZodDefault<z.ZodEnum<["us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-5", "ap-southeast-4", "ap-south-1", "ap-southeast-6", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-east-2", "ap-southeast-7", "ap-northeast-1", "ca-central-1", "ca-west-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-south-1", "eu-west-3", "eu-south-2", "eu-north-1", "eu-central-2", "il-central-1", "mx-central-1", "me-south-1", "me-central-1", "sa-east-1"]>>;
+    rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
+    rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
+    max_request_iterations: z.ZodDefault<z.ZodNumber>;
+    request_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    token_expiry_buffer_ms: z.ZodDefault<z.ZodNumber>;
+    usage_sync_max_retries: z.ZodDefault<z.ZodNumber>;
+    auth_server_port_start: z.ZodDefault<z.ZodNumber>;
+    auth_server_port_range: z.ZodDefault<z.ZodNumber>;
+    usage_tracking_enabled: z.ZodDefault<z.ZodBoolean>;
+    auto_sync_kiro_cli: z.ZodDefault<z.ZodBoolean>;
+    enable_log_api_request: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Default effort level for thinking models. Controls reasoning depth.
+     * When set, this overrides the automatic budget-based mapping.
+     * Values: 'low', 'medium', 'high', 'xhigh' (opus-4.7/4.8 only), 'max'
+     */
+    effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+    /**
+     * Enable automatic effort mapping from OpenCode's thinking budget.
+     * When true (default), maps budget ranges to effort levels.
+     * When false, only uses explicit effort config or falls back to 'medium'.
+     */
+    auto_effort_mapping: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    account_selection_strategy: "sticky" | "round-robin" | "lowest-usage";
+    default_region: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1";
+    rate_limit_retry_delay_ms: number;
+    rate_limit_max_retries: number;
+    max_request_iterations: number;
+    request_timeout_ms: number;
+    token_expiry_buffer_ms: number;
+    usage_sync_max_retries: number;
+    auth_server_port_start: number;
+    auth_server_port_range: number;
+    usage_tracking_enabled: boolean;
+    auto_sync_kiro_cli: boolean;
+    enable_log_api_request: boolean;
+    auto_effort_mapping: boolean;
+    $schema?: string | undefined;
+    idc_start_url?: string | undefined;
+    idc_region?: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1" | undefined;
+    idc_profile_arn?: string | undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+}, {
+    $schema?: string | undefined;
+    idc_start_url?: string | undefined;
+    idc_region?: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1" | undefined;
+    idc_profile_arn?: string | undefined;
+    account_selection_strategy?: "sticky" | "round-robin" | "lowest-usage" | undefined;
+    default_region?: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1" | undefined;
+    rate_limit_retry_delay_ms?: number | undefined;
+    rate_limit_max_retries?: number | undefined;
+    max_request_iterations?: number | undefined;
+    request_timeout_ms?: number | undefined;
+    token_expiry_buffer_ms?: number | undefined;
+    usage_sync_max_retries?: number | undefined;
+    auth_server_port_start?: number | undefined;
+    auth_server_port_range?: number | undefined;
+    usage_tracking_enabled?: boolean | undefined;
+    auto_sync_kiro_cli?: boolean | undefined;
+    enable_log_api_request?: boolean | undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    auto_effort_mapping?: boolean | undefined;
+}>;
+export type KiroConfig = z.infer<typeof KiroConfigSchema>;
+export declare const DEFAULT_CONFIG: KiroConfig;

package/dist/plugin/config/schema.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export const AccountSelectionStrategySchema = z.enum(['sticky', 'round-robin', 'lowest-usage']);
+/**
+ * Kiro effort levels control thinking/reasoning depth.
+ * - low: minimal reasoning
+ * - medium: balanced (default when thinking enabled)
+ * - high: deeper reasoning
+ * - xhigh: extended reasoning (opus-4.7, opus-4.8 only)
+ * - max: maximum reasoning depth (128k thinking tokens on opus-4.7/4.8)
+ */
+export const EffortSchema = z.enum(['low', 'medium', 'high', 'xhigh', 'max']);
+export const RegionSchema = z.enum([
+    'us-east-1',
+    'us-east-2',
+    'us-west-1',
+    'us-west-2',
+    'af-south-1',
+    'ap-east-1',
+    'ap-south-2',
+    'ap-southeast-3',
+    'ap-southeast-5',
+    'ap-southeast-4',
+    'ap-south-1',
+    'ap-southeast-6',
+    'ap-northeast-3',
+    'ap-northeast-2',
+    'ap-southeast-1',
+    'ap-southeast-2',
+    'ap-east-2',
+    'ap-southeast-7',
+    'ap-northeast-1',
+    'ca-central-1',
+    'ca-west-1',
+    'eu-central-1',
+    'eu-west-1',
+    'eu-west-2',
+    'eu-south-1',
+    'eu-west-3',
+    'eu-south-2',
+    'eu-north-1',
+    'eu-central-2',
+    'il-central-1',
+    'mx-central-1',
+    'me-south-1',
+    'me-central-1',
+    'sa-east-1'
+]);
+export const KiroConfigSchema = z.object({
+    $schema: z.string().optional(),
+    idc_start_url: z.string().url().optional(),
+    idc_region: RegionSchema.optional(),
+    idc_profile_arn: z.string().optional(),
+    account_selection_strategy: AccountSelectionStrategySchema.default('lowest-usage'),
+    default_region: RegionSchema.default('us-east-1'),
+    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),
+    max_request_iterations: z.number().min(5).max(1000).default(20),
+    request_timeout_ms: z.number().min(30000).max(600000).default(120000),
+    token_expiry_buffer_ms: z.number().min(30000).max(300000).default(300000),
+    usage_sync_max_retries: z.number().min(0).max(5).default(3),
+    auth_server_port_start: z.number().min(1024).max(65535).default(19847),
+    auth_server_port_range: z.number().min(1).max(100).default(10),
+    usage_tracking_enabled: z.boolean().default(true),
+    auto_sync_kiro_cli: z.boolean().default(true),
+    enable_log_api_request: z.boolean().default(false),
+    /**
+     * Default effort level for thinking models. Controls reasoning depth.
+     * When set, this overrides the automatic budget-based mapping.
+     * Values: 'low', 'medium', 'high', 'xhigh' (opus-4.7/4.8 only), 'max'
+     */
+    effort: EffortSchema.optional(),
+    /**
+     * Enable automatic effort mapping from OpenCode's thinking budget.
+     * When true (default), maps budget ranges to effort levels.
+     * When false, only uses explicit effort config or falls back to 'medium'.
+     */
+    auto_effort_mapping: z.boolean().default(true)
+});
+export const DEFAULT_CONFIG = {
+    account_selection_strategy: 'lowest-usage',
+    default_region: 'us-east-1',
+    rate_limit_retry_delay_ms: 5000,
+    rate_limit_max_retries: 3,
+    max_request_iterations: 20,
+    request_timeout_ms: 120000,
+    token_expiry_buffer_ms: 300000,
+    usage_sync_max_retries: 3,
+    auth_server_port_start: 19847,
+    auth_server_port_range: 10,
+    usage_tracking_enabled: true,
+    auto_sync_kiro_cli: true,
+    enable_log_api_request: false,
+    auto_effort_mapping: true
+};

package/dist/plugin/effort.d.ts

@@ -0,0 +1,46 @@
+import type { Effort } from './config/schema.js';
+/**
+ * Effort levels ordered from lowest to highest reasoning depth.
+ */
+export declare const EFFORT_LEVELS: readonly Effort[];
+/**
+ * Check if a model supports the effort parameter.
+ */
+export declare function supportsEffort(kiroModel: string): boolean;
+/**
+ * Check if a model supports xhigh effort level.
+ */
+export declare function supportsXHighEffort(kiroModel: string): boolean;
+/**
+ * Resolve effort level for a given model.
+ * - Returns undefined if model doesn't support effort
+ * - Clamps xhigh to max for models that don't support it
+ */
+export declare function resolveEffort(kiroModel: string, requested: Effort): Effort | undefined;
+/**
+ * Map OpenCode thinking budget to Kiro effort level.
+ *
+ * OpenCode sends thinkingBudget from its variant config. Standard values:
+ * - low:    8192
+ * - medium: 16384
+ * - high:   24576
+ * - max:    32768
+ *
+ * We map these ranges to Kiro effort levels:
+ * - ≤10000  → low
+ * - ≤20000  → medium
+ * - ≤28000  → high
+ * - ≤32768  → max (or xhigh on opus-4.7/4.8, max otherwise)
+ * - >32768  → max
+ */
+export declare function budgetToEffort(budget: number, kiroModel: string): Effort | undefined;
+/**
+ * Get the effective effort level based on config, budget, and model.
+ *
+ * Priority:
+ * 1. Explicit effort config (if set) - always applied regardless of thinking state
+ * 2. Budget-to-effort mapping (if auto_effort_mapping enabled and thinking)
+ * 3. 'medium' default (if thinking enabled)
+ * 4. undefined (if not thinking)
+ */
+export declare function getEffectiveEffort(kiroModel: string, thinking: boolean, budget: number, configEffort?: Effort, autoEffortMapping?: boolean): Effort | undefined;

package/dist/plugin/effort.js

@@ -0,0 +1,113 @@
+/**
+ * Effort levels ordered from lowest to highest reasoning depth.
+ */
+export const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Models that support the 5-value effort enum (including xhigh).
+ * These models support up to 128k thinking tokens with max effort.
+ */
+const XHIGH_CAPABLE_MODELS = new Set(['claude-opus-4.7', 'claude-opus-4.8']);
+/**
+ * Models that support the 4-value effort enum (no xhigh).
+ * xhigh requests on these models are clamped to max.
+ */
+const EFFORT_CAPABLE_MODELS = new Set([
+    'claude-opus-4.5',
+    'claude-opus-4.6',
+    'claude-opus-4.6-1m',
+    'claude-sonnet-4.5',
+    'claude-sonnet-4.5-1m',
+    'claude-sonnet-4.6',
+    'claude-sonnet-4.6-1m',
+    ...XHIGH_CAPABLE_MODELS
+]);
+/**
+ * Check if a model supports the effort parameter.
+ */
+export function supportsEffort(kiroModel) {
+    return EFFORT_CAPABLE_MODELS.has(kiroModel);
+}
+/**
+ * Check if a model supports xhigh effort level.
+ */
+export function supportsXHighEffort(kiroModel) {
+    return XHIGH_CAPABLE_MODELS.has(kiroModel);
+}
+/**
+ * Resolve effort level for a given model.
+ * - Returns undefined if model doesn't support effort
+ * - Clamps xhigh to max for models that don't support it
+ */
+export function resolveEffort(kiroModel, requested) {
+    if (!supportsEffort(kiroModel)) {
+        return undefined;
+    }
+    // xhigh is only supported on opus-4.7 and opus-4.8
+    if (requested === 'xhigh' && !supportsXHighEffort(kiroModel)) {
+        return 'max';
+    }
+    return requested;
+}
+/**
+ * Map OpenCode thinking budget to Kiro effort level.
+ *
+ * OpenCode sends thinkingBudget from its variant config. Standard values:
+ * - low:    8192
+ * - medium: 16384
+ * - high:   24576
+ * - max:    32768
+ *
+ * We map these ranges to Kiro effort levels:
+ * - ≤10000  → low
+ * - ≤20000  → medium
+ * - ≤28000  → high
+ * - ≤32768  → max (or xhigh on opus-4.7/4.8, max otherwise)
+ * - >32768  → max
+ */
+export function budgetToEffort(budget, kiroModel) {
+    if (!supportsEffort(kiroModel)) {
+        return undefined;
+    }
+    let effort;
+    if (budget <= 10000) {
+        effort = 'low';
+    }
+    else if (budget <= 20000) {
+        effort = 'medium';
+    }
+    else if (budget <= 28000) {
+        effort = 'high';
+    }
+    else {
+        effort = 'max';
+    }
+    return effort;
+}
+/**
+ * Get the effective effort level based on config, budget, and model.
+ *
+ * Priority:
+ * 1. Explicit effort config (if set) - always applied regardless of thinking state
+ * 2. Budget-to-effort mapping (if auto_effort_mapping enabled and thinking)
+ * 3. 'medium' default (if thinking enabled)
+ * 4. undefined (if not thinking)
+ */
+export function getEffectiveEffort(kiroModel, thinking, budget, configEffort, autoEffortMapping = true) {
+    if (!supportsEffort(kiroModel)) {
+        return undefined;
+    }
+    // Explicit config takes precedence - always applied even without thinking
+    if (configEffort) {
+        return resolveEffort(kiroModel, configEffort);
+    }
+    // If not thinking, no effort needed
+    if (!thinking) {
+        return undefined;
+    }
+    // Auto-map budget to effort
+    if (autoEffortMapping) {
+        return budgetToEffort(budget, kiroModel);
+    }
+    // Default to medium when thinking without auto-mapping
+    return 'medium';
+}

package/dist/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/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/plugin/health.d.ts

@@ -0,0 +1 @@
+export declare function isPermanentError(reason?: string): boolean;

package/dist/plugin/health.js

@@ -0,0 +1,13 @@
+export function isPermanentError(reason) {
+    if (!reason)
+        return false;
+    return (reason.includes('Invalid refresh token') ||
+        reason.includes('Invalid grant provided') ||
+        reason.includes('invalid_grant') ||
+        reason.includes('ExpiredTokenException') ||
+        reason.includes('InvalidTokenException') ||
+        reason.includes('ExpiredClientException') ||
+        reason.includes('Client is expired') ||
+        reason.includes('HTTP_401') ||
+        reason.includes('HTTP_403'));
+}

package/dist/plugin/image-handler.d.ts

@@ -0,0 +1,18 @@
+interface UnifiedImage {
+    mediaType: string;
+    data: string;
+}
+interface KiroImage {
+    format: string;
+    source: {
+        bytes: Uint8Array;
+    };
+}
+interface ImageConversionResult {
+    images: KiroImage[];
+    omitted: number;
+}
+export declare function extractAllImages(content: any): UnifiedImage[];
+export declare function convertImagesToKiroFormat(images: UnifiedImage[]): ImageConversionResult;
+export declare function extractTextFromParts(parts: any[]): string;
+export {};

package/dist/plugin/image-handler.js

@@ -0,0 +1,82 @@
+const MAX_KIRO_IMAGES = 4;
+const MAX_KIRO_IMAGE_BYTES = 3_750_000;
+/** Decode base64 to a plain Uint8Array (NOT Buffer) to avoid Buffer.toJSON() trap. */
+function base64ToUint8Array(b64) {
+    const bin = atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        arr[i] = bin.charCodeAt(i);
+    return arr;
+}
+function extractImagesFromAnthropicFormat(content) {
+    const images = [];
+    for (const item of content) {
+        if (item.type === 'image' && item.source?.type === 'base64') {
+            images.push({
+                mediaType: item.source.media_type || 'image/jpeg',
+                data: item.source.data
+            });
+        }
+    }
+    return images;
+}
+function extractImagesFromOpenAI(content) {
+    const images = [];
+    for (const item of content) {
+        if (item.type === 'image_url' && item.image_url?.url) {
+            const url = item.image_url.url;
+            if (url.startsWith('data:')) {
+                try {
+                    const [header, data] = url.split(',', 2);
+                    if (!data)
+                        continue;
+                    const mediaType = header.split(';')[0].replace('data:', '');
+                    images.push({
+                        mediaType: mediaType || 'image/jpeg',
+                        data: data
+                    });
+                }
+                catch (e) {
+                    continue;
+                }
+            }
+        }
+    }
+    return images;
+}
+export function extractAllImages(content) {
+    if (!Array.isArray(content))
+        return [];
+    return [...extractImagesFromAnthropicFormat(content), ...extractImagesFromOpenAI(content)];
+}
+export function convertImagesToKiroFormat(images) {
+    const selected = [];
+    let totalBase64Chars = 0;
+    for (const img of images) {
+        if (selected.length >= MAX_KIRO_IMAGES)
+            break;
+        if (totalBase64Chars + img.data.length > MAX_KIRO_IMAGE_BYTES)
+            break;
+        selected.push(img);
+        totalBase64Chars += img.data.length;
+    }
+    return {
+        images: selected.map((img) => {
+            const format = img.mediaType.split('/')[1] || 'png';
+            return { format, source: { bytes: base64ToUint8Array(img.data) } };
+        }),
+        omitted: images.length - selected.length
+    };
+}
+export function extractTextFromParts(parts) {
+    const textParts = [];
+    for (const part of parts) {
+        if (part.text && typeof part.text === 'string') {
+            textParts.push(part.text);
+        }
+        else if (part.type === 'text' && part.text) {
+            textParts.push(part.text);
+        }
+    }
+    return textParts.join('');
+}

package/dist/plugin/logger.d.ts

@@ -0,0 +1,8 @@
+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;
+export declare function logApiRequest(data: any, timestamp: string): void;
+export declare function logApiResponse(data: any, timestamp: string): void;
+export declare function logApiError(requestData: any, responseData: any, timestamp: string): void;
+export declare function getTimestamp(): string;