@sunerpy/opencode-kiro-auth 0.13.0 → 0.13.1

package/dist/constants.d.ts

@@ -19,6 +19,9 @@ export declare const KIRO_CONSTANTS: {
 export declare const MODEL_MAPPING: Record<string, string>;
 export declare const SUPPORTED_MODELS: string[];
 export declare function isLongContextModel(model: string): boolean;
+export declare const DEFAULT_MODEL_CONTEXT_LIMIT = 200000;
+export declare const MODEL_CONTEXT_LIMITS: Record<string, number>;
+export declare function getModelContextLimit(baseModel: string): number;
 export declare const KIRO_AUTH_SERVICE: {
     ENDPOINT: string;
     SSO_OIDC_ENDPOINT: string;

package/dist/constants.js

@@ -98,6 +98,37 @@ const LONG_CONTEXT_MODELS = new Set(Object.keys(MODEL_MAPPING).filter((k) => k.i
 export function isLongContextModel(model) {
     return LONG_CONTEXT_MODELS.has(model);
 }
+// SSOT for token accounting, keyed by BASE model id (effort/thinking suffix
+// stripped). Values MUST equal the limit.context advertised in src/plugin.ts —
+// enforced by context-window.test.ts. Drift makes OpenCode under-count usage and
+// skip auto-compaction until Kiro hard-rejects with 400 "Input is too long."
+export const DEFAULT_MODEL_CONTEXT_LIMIT = 200000;
+export const MODEL_CONTEXT_LIMITS = {
+    auto: 200000,
+    'claude-haiku-4-5': 200000,
+    'claude-sonnet-4': 200000,
+    'claude-sonnet-4-5': 200000,
+    'claude-sonnet-4-5-1m': 1000000,
+    'claude-sonnet-4-6': 1000000,
+    'claude-sonnet-4-6-1m': 1000000,
+    'claude-sonnet-5': 1000000,
+    'claude-opus-4-5': 200000,
+    'claude-opus-4-6': 1000000,
+    'claude-opus-4-6-1m': 1000000,
+    'claude-opus-4-7': 1000000,
+    'claude-opus-4-8': 1000000,
+    'deepseek-3.2': 128000,
+    'glm-5': 200000,
+    'minimax-m2.5': 200000,
+    'minimax-m2.1': 200000,
+    'qwen3-coder-next': 256000,
+    'gpt-5.6-sol': 272000,
+    'gpt-5.6-terra': 272000,
+    'gpt-5.6-luna': 272000
+};
+export function getModelContextLimit(baseModel) {
+    return MODEL_CONTEXT_LIMITS[baseModel] ?? DEFAULT_MODEL_CONTEXT_LIMIT;
+}
 export const KIRO_AUTH_SERVICE = {
     ENDPOINT: 'https://prod.{{region}}.auth.desktop.kiro.dev',
     SSO_OIDC_ENDPOINT: 'https://oidc.{{region}}.amazonaws.com',

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

@@ -3,6 +3,7 @@ import type { AccountManager } from '../../plugin/accounts.js';
 import type { ManagedAccount } from '../../plugin/types.js';
 import type { ForceRefreshResult } from '../auth/token-refresher.js';
 type ToastFunction = (message: string, variant: 'info' | 'warning' | 'success' | 'error') => void;
+export declare function isKiroContextOverflowBody(text: string): boolean;
 export interface RequestContext {
     retry: number;
     forcedRefreshAccountIds?: Set<string>;

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

@@ -1,4 +1,11 @@
 import { isAccessTokenError, toDeadReason } from '../../plugin/health.js';
+// Unambiguous Kiro size-overflow 400 signals only. The generic "Improperly
+// formed request." is deliberately excluded: it has no size discriminator in
+// the body, so matching it would wrongly reclassify unrelated 400s as overflow.
+const KIRO_CONTEXT_OVERFLOW_PATTERNS = [/input is too long/i, /CONTENT_LENGTH_EXCEEDS_THRESHOLD/i];
+export function isKiroContextOverflowBody(text) {
+    return KIRO_CONTEXT_OVERFLOW_PATTERNS.some((p) => p.test(text));
+}
 export class ErrorHandler {
     config;
     accountManager;

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

@@ -7,7 +7,7 @@ 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 { ErrorHandler, isKiroContextOverflowBody } 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/;
@@ -155,12 +155,14 @@ export class RequestHandler {
                     if (apiTimestamp) {
                         this.logSdkError(sdkPrep, e, acc, apiTimestamp);
                     }
-                    const mockResponse = new Response(JSON.stringify({ message: e.message, __type: e.name }), {
+                    const errorBody = JSON.stringify({ message: e.message, __type: e.name });
+                    const errorStatusText = e.name || 'Error';
+                    const jsonHeaders = { 'Content-Type': 'application/json' };
+                    const errorResult = await this.errorHandler.handle(e, new Response(errorBody, {
                         status: httpStatus,
-                        statusText: e.name || 'Error',
-                        headers: { 'Content-Type': 'application/json' }
-                    });
-                    const errorResult = await this.errorHandler.handle(e, mockResponse, acc, handlerContext, showToast);
+                        statusText: errorStatusText,
+                        headers: jsonHeaders
+                    }), acc, handlerContext, showToast);
                     if (errorResult.shouldRetry) {
                         if (errorResult.newContext) {
                             handlerContext = errorResult.newContext;
@@ -170,7 +172,17 @@ export class RequestHandler {
                         }
                         continue;
                     }
-                    throw new Error(`Kiro Error: ${httpStatus}`);
+                    // Terminal, non-retryable HTTP error. Return a fresh Response carrying
+                    // the real Kiro body so @ai-sdk/openai-compatible produces an
+                    // APICallError with status+body (not a bare Error that OpenCode
+                    // degrades to UnknownError). Remap size-overflow 400s to 413 so
+                    // OpenCode classifies context_overflow and auto-compacts.
+                    const terminalStatus = httpStatus === 400 && isKiroContextOverflowBody(e.message ?? '') ? 413 : httpStatus;
+                    return new Response(errorBody, {
+                        status: terminalStatus,
+                        statusText: errorStatusText,
+                        headers: jsonHeaders
+                    });
                 }
                 const networkResult = await this.errorHandler.handleNetworkError(e, handlerContext, showToast);
                 if (networkResult.shouldRetry) {

package/dist/plugin/models.d.ts

@@ -20,4 +20,5 @@ export interface ResolvedModelVariant {
  * with `effort` left undefined.
  */
 export declare function resolveModelVariant(model: string): ResolvedModelVariant;
+export declare function stripModelSuffix(model: string): string;
 export declare function getContextWindowSize(model: string): number;

package/dist/plugin/models.js

@@ -1,4 +1,4 @@
-import { MODEL_MAPPING, SUPPORTED_MODELS, isLongContextModel } from '../constants.js';
+import { MODEL_MAPPING, SUPPORTED_MODELS, getModelContextLimit } from '../constants.js';
 export function resolveKiroModel(model) {
     const resolved = MODEL_MAPPING[model];
     if (!resolved) {
@@ -43,6 +43,24 @@ export function resolveModelVariant(model) {
     }
     return { wireId: resolveKiroModel(model), effort: undefined };
 }
+export function stripModelSuffix(model) {
+    for (const suffix of EFFORT_SUFFIXES) {
+        const marker = `-${suffix}`;
+        if (model.endsWith(marker)) {
+            const base = model.slice(0, -marker.length);
+            if (VARIANT_BASE_ALLOWLIST.has(base)) {
+                return base;
+            }
+        }
+    }
+    if (model.endsWith('-thinking')) {
+        const base = model.slice(0, -'-thinking'.length);
+        if (MODEL_MAPPING[base]) {
+            return base;
+        }
+    }
+    return model;
+}
 export function getContextWindowSize(model) {
-    return isLongContextModel(model) ? 1000000 : 200000;
+    return getModelContextLimit(stripModelSuffix(model));
 }

package/package.json

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