@sunerpy/opencode-kiro-auth 0.4.2 → 0.5.0

package/README.md

@@ -192,6 +192,19 @@ Details and the full JSON example: [docs/MODELS.md](docs/MODELS.md).
 > `kiro.json` instead. See
 > [Reasoning effort](docs/CONFIGURATION.md#reasoning-effort) for details.
 
+> **Note:** Reasoning-capable Kiro models (Claude Opus 4.x and other
+> reasoning-capable models) stream their chain-of-thought as a separate
+> event, which the plugin surfaces as OpenCode's own reasoning block — shown
+> as "Thought: `<duration>`" above the final reply. No config needed. See
+> [Reasoning display](docs/CONFIGURATION.md#reasoning-display) for details.
+
+> **Note:** Per-request thinking level via model variants — pick
+> `kiro-auth/claude-opus-4-8-xhigh` (or similar) straight from the model
+> list to pin an explicit Kiro effort level for that model, no `kiro.json`
+> edit needed. Base models like `claude-opus-4-8` remain available and keep
+> using the global `effort` setting. See [docs/VARIANTS.md](docs/VARIANTS.md)
+> for the full variant list and why they exist.
+
 ## Troubleshooting
 
 Common issues — 403/AccessDeniedException with IAM Identity Center, "No

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

@@ -84,12 +84,16 @@ export class ResponseHandler {
     async handleSdkNonStreaming(sdkResponse, model, conversationId) {
         // For non-streaming SDK responses, collect all events
         let content = '';
+        let reasoningContent = '';
         const toolCalls = [];
         let inputTokens = 0;
         let outputTokens = 0;
         const eventStream = sdkResponse.generateAssistantResponseResponse;
         if (eventStream) {
             for await (const event of eventStream) {
+                if (event.reasoningContentEvent?.text) {
+                    reasoningContent += event.reasoningContentEvent.text;
+                }
                 if (event.assistantResponseEvent?.content) {
                     content += event.assistantResponseEvent.content;
                 }
@@ -102,6 +106,10 @@ export class ResponseHandler {
                 }
             }
         }
+        const message = { role: 'assistant', content };
+        if (reasoningContent) {
+            message.reasoning_content = reasoningContent;
+        }
         const oai = {
             id: conversationId,
             object: 'chat.completion',
@@ -110,7 +118,7 @@ export class ResponseHandler {
             choices: [
                 {
                     index: 0,
-                    message: { role: 'assistant', content },
+                    message,
                     finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop'
                 }
             ],

package/dist/plugin/effort.js

@@ -6,7 +6,7 @@ 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']);
+const XHIGH_CAPABLE_MODELS = new Set(['claude-opus-4.7', 'claude-opus-4.8', 'claude-sonnet-5']);
 /**
  * Models that support the 4-value effort enum (no xhigh).
  * xhigh requests on these models are clamped to max.

package/dist/plugin/models.d.ts

@@ -1,2 +1,23 @@
+import type { Effort } from './types.js';
 export declare function resolveKiroModel(model: string): string;
+export interface ResolvedModelVariant {
+    wireId: string;
+    effort?: Effort;
+}
+/**
+ * Resolve a (possibly effort-variant) model id into its Kiro wire id plus an
+ * optional parsed effort level.
+ *
+ * Parse rule (unambiguous, single source of truth):
+ * An id is an effort variant ONLY IF it ends with `-<suffix>` for some suffix
+ * in EFFORT_SUFFIXES AND the id with that `-<suffix>` removed is in
+ * VARIANT_BASE_ALLOWLIST. In that case the wire id is derived SOLELY from the
+ * base via MODEL_MAPPING and the effort SOLELY from the parsed suffix.
+ *
+ * This guarantees ids like `claude-opus-4-8-thinking`, `claude-sonnet-4-5-1m`,
+ * and the plain bases (`claude-opus-4-8`) are NEVER parsed as effort variants.
+ * Non-variant ids fall through to `resolveKiroModel` (existing behavior/throw)
+ * with `effort` left undefined.
+ */
+export declare function resolveModelVariant(model: string): ResolvedModelVariant;
 export declare function getContextWindowSize(model: string): number;

package/dist/plugin/models.js

@@ -6,6 +6,40 @@ export function resolveKiroModel(model) {
     }
     return resolved;
 }
+const VARIANT_BASE_ALLOWLIST = new Set([
+    'claude-opus-4-8',
+    'claude-opus-4-7',
+    'claude-sonnet-5',
+    'claude-sonnet-4-6'
+]);
+const EFFORT_SUFFIXES = ['low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Resolve a (possibly effort-variant) model id into its Kiro wire id plus an
+ * optional parsed effort level.
+ *
+ * Parse rule (unambiguous, single source of truth):
+ * An id is an effort variant ONLY IF it ends with `-<suffix>` for some suffix
+ * in EFFORT_SUFFIXES AND the id with that `-<suffix>` removed is in
+ * VARIANT_BASE_ALLOWLIST. In that case the wire id is derived SOLELY from the
+ * base via MODEL_MAPPING and the effort SOLELY from the parsed suffix.
+ *
+ * This guarantees ids like `claude-opus-4-8-thinking`, `claude-sonnet-4-5-1m`,
+ * and the plain bases (`claude-opus-4-8`) are NEVER parsed as effort variants.
+ * Non-variant ids fall through to `resolveKiroModel` (existing behavior/throw)
+ * with `effort` left undefined.
+ */
+export function resolveModelVariant(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 { wireId: resolveKiroModel(base), effort: suffix };
+            }
+        }
+    }
+    return { wireId: resolveKiroModel(model), effort: undefined };
+}
 export function getContextWindowSize(model) {
     return isLongContextModel(model) ? 1000000 : 200000;
 }

package/dist/plugin/request.js

@@ -4,16 +4,16 @@ import { KIRO_CONSTANTS, buildUrl, extractRegionFromArn } from '../constants.js'
 import { buildHistory, extractToolNamesFromHistory, historyHasToolCalling, injectSystemPrompt } from '../infrastructure/transformers/history-builder.js';
 import { findOriginalToolCall, getContentText, mergeAdjacentMessages } from '../infrastructure/transformers/message-transformer.js';
 import { convertToolsToCodeWhisperer, deduplicateToolResults } from '../infrastructure/transformers/tool-transformer.js';
-import { getEffectiveEffort } from './effort.js';
+import { getEffectiveEffort, resolveEffort } from './effort.js';
 import { convertImagesToKiroFormat, extractAllImages, extractTextFromParts } from './image-handler.js';
-import { resolveKiroModel } from './models.js';
+import { resolveModelVariant } from './models.js';
 function buildCodeWhispererRequest(body, model, auth, think = false, budget = 20000, showToast) {
     const req = typeof body === 'string' ? JSON.parse(body) : body;
     const { messages, tools, system } = req;
     const convId = crypto.randomUUID();
     if (!messages || messages.length === 0)
         throw new Error('No messages');
-    const resolved = resolveKiroModel(model);
+    const { wireId: resolved, effort: variantEffort } = resolveModelVariant(model);
     const systemMsgs = messages.filter((m) => m.role === 'system');
     const otherMsgs = messages.filter((m) => m.role !== 'system');
     let sys = system || '';
@@ -242,7 +242,7 @@ function buildCodeWhispererRequest(body, model, auth, think = false, budget = 20
             }
         }
     }
-    return { request, resolved, convId };
+    return { request, resolved, convId, variantEffort };
 }
 export function transformToCodeWhisperer(url, body, model, auth, think = false, budget = 20000) {
     const { request, resolved, convId } = buildCodeWhispererRequest(body, model, auth, think, budget);
@@ -272,9 +272,10 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
     };
 }
 export function transformToSdkRequest(body, model, auth, think = false, budget = 20000, showToast, effortConfig) {
-    const { request, resolved, convId } = buildCodeWhispererRequest(body, model, auth, think, budget, showToast);
-    // Resolve effort level based on config and model capabilities
-    const effort = getEffectiveEffort(resolved, think, budget, effortConfig?.effort, effortConfig?.autoEffortMapping ?? true);
+    const { request, resolved, convId, variantEffort } = buildCodeWhispererRequest(body, model, auth, think, budget, showToast);
+    const effort = variantEffort
+        ? resolveEffort(resolved, variantEffort)
+        : getEffectiveEffort(resolved, think, budget, effortConfig?.effort, effortConfig?.autoEffortMapping ?? true);
     return {
         conversationState: request.conversationState,
         profileArn: request.profileArn,

package/dist/plugin/streaming/sdk-stream-transformer.js

@@ -24,16 +24,53 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
     let contextUsagePercentage = null;
     const toolCalls = [];
     let currentToolCall = null;
+    // Probe (opus-4.8): reasoning streams via `reasoningContentEvent{text,signature}` as a
+    // contiguous run BEFORE `assistantResponseEvent.content`; no `<thinking>` tags emitted.
+    // signature is metadata and ignored for rendering.
+    let reasoningStarted = false;
+    let reasoningClosed = false;
     const eventStream = sdkResponse.generateAssistantResponseResponse;
     if (!eventStream) {
         throw new Error('SDK response has no event stream');
     }
     try {
         for await (const event of eventStream) {
+            if (event.reasoningContentEvent?.text) {
+                const reasoningText = event.reasoningContentEvent.text;
+                if (reasoningClosed) {
+                    // Defensive, normally unreached (probe: reasoning is contiguous-before-text).
+                    // The stopped thinking index cannot be reused, so open a fresh one.
+                    streamState.thinkingBlockIndex = null;
+                    reasoningClosed = false;
+                }
+                reasoningStarted = true;
+                for (const ev of createThinkingDeltaEvents(reasoningText, streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                continue;
+            }
             if (event.assistantResponseEvent?.content) {
                 const text = event.assistantResponseEvent.content;
                 totalContent += text;
                 textOnlyContent += text;
+                if (reasoningStarted && !reasoningClosed) {
+                    for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
+                        const _c = convertToOpenAI(ev, conversationId, model);
+                        if (_c !== null)
+                            yield _c;
+                    }
+                    reasoningClosed = true;
+                }
+                if (reasoningStarted) {
+                    for (const ev of createTextDeltaEvents(text, streamState)) {
+                        const _c = convertToOpenAI(ev, conversationId, model);
+                        if (_c !== null)
+                            yield _c;
+                    }
+                    continue;
+                }
                 if (!thinkingRequested) {
                     for (const ev of createTextDeltaEvents(text, streamState)) {
                         {
@@ -151,6 +188,15 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
             toolCalls.push(currentToolCall);
             currentToolCall = null;
         }
+        // Reasoning-only responses (reasoning but no reply text): close the thinking block.
+        if (reasoningStarted && !reasoningClosed) {
+            for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
+                const _c = convertToOpenAI(ev, conversationId, model);
+                if (_c !== null)
+                    yield _c;
+            }
+            reasoningClosed = true;
+        }
         if (thinkingRequested && streamState.buffer) {
             if (streamState.inThinking) {
                 for (const ev of createThinkingDeltaEvents(streamState.buffer, streamState)) {

package/dist/plugin.js

@@ -61,11 +61,56 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                         limit: { context: 1000000, output: 64000 },
                         modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
                     },
+                    'claude-sonnet-4-6-low': {
+                        name: 'Claude Sonnet 4.6 (low) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-sonnet-4-6-medium': {
+                        name: 'Claude Sonnet 4.6 (medium) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-sonnet-4-6-high': {
+                        name: 'Claude Sonnet 4.6 (high) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-sonnet-4-6-max': {
+                        name: 'Claude Sonnet 4.6 (max) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
                     'claude-sonnet-5': {
                         name: 'Claude Sonnet 5 (1.3x)',
                         limit: { context: 1000000, output: 64000 },
                         modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
                     },
+                    'claude-sonnet-5-low': {
+                        name: 'Claude Sonnet 5 (low) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-sonnet-5-medium': {
+                        name: 'Claude Sonnet 5 (medium) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-sonnet-5-high': {
+                        name: 'Claude Sonnet 5 (high) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-sonnet-5-xhigh': {
+                        name: 'Claude Sonnet 5 (xhigh) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-sonnet-5-max': {
+                        name: 'Claude Sonnet 5 (max) (1.3x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
                     // Claude Haiku
                     'claude-haiku-4-5': {
                         name: 'Claude Haiku 4.5 (0.4x)',
@@ -88,11 +133,61 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                         limit: { context: 1000000, output: 64000 },
                         modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
                     },
+                    'claude-opus-4-7-low': {
+                        name: 'Claude Opus 4.7 (low) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-7-medium': {
+                        name: 'Claude Opus 4.7 (medium) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-7-high': {
+                        name: 'Claude Opus 4.7 (high) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-7-xhigh': {
+                        name: 'Claude Opus 4.7 (xhigh) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-7-max': {
+                        name: 'Claude Opus 4.7 (max) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
                     'claude-opus-4-8': {
                         name: 'Claude Opus 4.8 (2.2x)',
                         limit: { context: 1000000, output: 64000 },
                         modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
                     },
+                    'claude-opus-4-8-low': {
+                        name: 'Claude Opus 4.8 (low) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-8-medium': {
+                        name: 'Claude Opus 4.8 (medium) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-8-high': {
+                        name: 'Claude Opus 4.8 (high) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-8-xhigh': {
+                        name: 'Claude Opus 4.8 (xhigh) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
+                    'claude-opus-4-8-max': {
+                        name: 'Claude Opus 4.8 (max) (2.2x)',
+                        limit: { context: 1000000, output: 64000 },
+                        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] }
+                    },
                     'claude-opus-4-8-thinking': {
                         name: 'Claude Opus 4.8 Thinking (2.2x)',
                         limit: { context: 1000000, output: 64000 },

package/package.json

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