@pentoshi/clai 4.11.26 → 4.11.27

package/dist/llm/kiro.js

@@ -1,11 +1,18 @@
 import { createHash, randomUUID } from "node:crypto";
 import { defaultModels, } from "./provider.js";
 import { ProviderError } from "./http.js";
-import { assertValidAwsRegion, decodeKiroKey, getKiroUsageLimits, isKiroOAuthToken, listKiroModelsDetailed, maybeRefreshKiroCredential, } from "./kiro-auth.js";
+import { decodeKiroKey, discoverKiroModelsDetailed, getKiroUsageLimits, isKiroOAuthToken, KiroRefreshError, kiroCredentialNeedsRefresh, maybeRefreshKiroCredential, resolveKiroRuntimeRegion, } from "./kiro-auth.js";
 import { currentSessionAffinity } from "./session-affinity.js";
-import { generationFetch } from "./operation-usage.js";
+import { nearestAcceptedEffort } from "./reasoning-controls.js";
+import { completeGenerationAttempt, generationFetch, } from "./operation-usage.js";
 import { learnModelVisionCapability } from "./capability/vision-registry.js";
 import { emitStreamReasoningDelta } from "./stream-events.js";
+import { createReasoningArtifactProvenance, createReasoningArtifactReplayTarget, reasoningArtifactSignature, reasoningArtifactText, reasoningArtifactsForMessage, selectReasoningArtifactsForReplay, } from "./reasoning-artifacts.js";
+import { createKiroReasoningAccumulator, kiroPrivateReasoningNote, kiroCatalogEfforts, kiroReasoningResult, sentKiroReasoningEffort, } from "./kiro-reasoning.js";
+import { registerModelCatalogLimits, registerModelReasoningEfforts, } from "./capabilities.js";
+import { modelContextWindow } from "./context-windows.js";
+import { providerRatioPromptTokens, providerRatioUsage, } from "./provider-context-usage.js";
+import { inBandBadRequestStatus } from "./reasoning-errors.js";
 import { replaceProviderKey } from "../store/keys.js";
 const KIRO_FALLBACK_BASE_MODELS = [
     "auto",
@@ -39,6 +46,8 @@ for (let i = 0; i < 256; i++) {
     }
     CRC32_TABLE[i] = c >>> 0;
 }
+const KIRO_EVENTSTREAM_MAX_MESSAGE_BYTES = 24 * 1024 * 1024;
+const KIRO_EVENTSTREAM_MAX_HEADERS_BYTES = 128 * 1024;
 function crc32(buf, start = 0, end = buf.length) {
     let crc = 0xffffffff;
     for (let i = start; i < end; i++) {
@@ -48,59 +57,73 @@ function crc32(buf, start = 0, end = buf.length) {
 }
 function parseHeaders(buf) {
     const headers = {};
+    const names = new Set();
     let offset = 0;
+    const requireBytes = (count) => {
+        if (offset + count > buf.length) {
+            throw new ProviderError("Kiro event-stream header exceeds its declared bounds", 502);
+        }
+    };
     while (offset < buf.length) {
+        requireBytes(1);
         const nameLen = buf.readUInt8(offset);
         offset += 1;
+        requireBytes(nameLen + 1);
         const name = buf.toString("utf8", offset, offset + nameLen);
         offset += nameLen;
+        if (names.has(name)) {
+            throw new ProviderError(`Duplicate Kiro event-stream header: ${name}`, 502);
+        }
+        names.add(name);
         const type = buf.readUInt8(offset);
         offset += 1;
-        if (type === 0) {
-            headers[name] = true;
-        }
-        else if (type === 1) {
-            headers[name] = false;
+        if (type === 0 || type === 1) {
+            headers[name] = type === 0;
+            continue;
         }
-        else if (type === 2) {
+        if (type === 2) {
+            requireBytes(1);
             headers[name] = buf.readInt8(offset);
             offset += 1;
+            continue;
         }
-        else if (type === 3) {
+        if (type === 3) {
+            requireBytes(2);
             headers[name] = buf.readInt16BE(offset);
             offset += 2;
+            continue;
         }
-        else if (type === 4) {
+        if (type === 4) {
+            requireBytes(4);
             headers[name] = buf.readInt32BE(offset);
             offset += 4;
+            continue;
         }
-        else if (type === 5) {
-            headers[name] = buf.readBigInt64BE(offset);
+        if (type === 5 || type === 8) {
+            requireBytes(8);
+            const value = buf.readBigInt64BE(offset);
+            headers[name] = type === 5 ? value : new Date(Number(value));
             offset += 8;
+            continue;
         }
-        else if (type === 6) {
-            const len = buf.readUInt16BE(offset);
-            offset += 2;
-            headers[name] = buf.subarray(offset, offset + len);
-            offset += len;
-        }
-        else if (type === 7) {
+        if (type === 6 || type === 7) {
+            requireBytes(2);
             const len = buf.readUInt16BE(offset);
             offset += 2;
-            headers[name] = buf.toString("utf8", offset, offset + len);
+            requireBytes(len);
+            headers[name] = type === 7
+                ? buf.toString("utf8", offset, offset + len)
+                : buf.subarray(offset, offset + len);
             offset += len;
+            continue;
         }
-        else if (type === 8) {
-            headers[name] = new Date(Number(buf.readBigInt64BE(offset)));
-            offset += 8;
-        }
-        else if (type === 9) {
+        if (type === 9) {
+            requireBytes(16);
             headers[name] = buf.subarray(offset, offset + 16).toString("hex");
             offset += 16;
+            continue;
         }
-        else {
-            break;
-        }
+        throw new ProviderError(`Unknown Kiro event-stream header type ${type}`, 502);
     }
     return headers;
 }
@@ -118,15 +141,20 @@ async function* parseEventStream(stream) {
             while (buffer.length >= 12) {
                 const totalLength = buffer.readUInt32BE(0);
                 if (totalLength < 16) {
-                    buffer = buffer.subarray(1);
-                    continue;
+                    throw new ProviderError("Invalid Kiro event-stream frame length", 502);
+                }
+                if (totalLength > KIRO_EVENTSTREAM_MAX_MESSAGE_BYTES) {
+                    throw new ProviderError(`Kiro event-stream frame length exceeds the ${KIRO_EVENTSTREAM_MAX_MESSAGE_BYTES}-byte protocol bound`, 502);
                 }
                 const headersLength = buffer.readUInt32BE(4);
+                if (headersLength > KIRO_EVENTSTREAM_MAX_HEADERS_BYTES ||
+                    headersLength > totalLength - 16) {
+                    throw new ProviderError("Invalid Kiro event-stream header length", 502);
+                }
                 const preludeCrc = buffer.readUInt32BE(8);
                 const expectedPreludeCrc = crc32(buffer, 0, 8);
                 if (preludeCrc !== expectedPreludeCrc) {
-                    buffer = buffer.subarray(1);
-                    continue;
+                    throw new ProviderError("Kiro event-stream prelude checksum failed", 502);
                 }
                 if (buffer.length < totalLength) {
                     break;
@@ -134,8 +162,7 @@ async function* parseEventStream(stream) {
                 const messageCrc = buffer.readUInt32BE(totalLength - 4);
                 const expectedMessageCrc = crc32(buffer, 0, totalLength - 4);
                 if (messageCrc !== expectedMessageCrc) {
-                    buffer = buffer.subarray(totalLength);
-                    continue;
+                    throw new ProviderError("Kiro event-stream message checksum failed", 502);
                 }
                 const headersBuffer = buffer.subarray(12, 12 + headersLength);
                 const payloadBuffer = buffer.subarray(12 + headersLength, totalLength - 4);
@@ -144,16 +171,27 @@ async function* parseEventStream(stream) {
                 let payload = {};
                 if (payloadBuffer.length > 0) {
                     try {
-                        const raw = payloadBuffer.toString("utf8");
-                        payload = JSON.parse(raw);
+                        const decoded = JSON.parse(payloadBuffer.toString("utf8"));
+                        if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+                            throw new Error("payload is not an object");
+                        }
+                        payload = decoded;
                     }
-                    catch {
-                        payload = { raw: payloadBuffer.toString("utf8") };
+                    catch (error) {
+                        const detail = error instanceof Error ? `: ${error.message}` : "";
+                        throw new ProviderError(`Invalid Kiro event-stream JSON payload${detail}`, 502);
                     }
                 }
                 yield { headers, payload };
             }
         }
+        if (buffer.length > 0) {
+            throw new ProviderError("Kiro event stream ended with a partial frame", 502);
+        }
+    }
+    catch (error) {
+        await reader.cancel(error).catch(() => { });
+        throw error;
     }
     finally {
         reader.releaseLock();
@@ -183,8 +221,8 @@ export function resolveKiroModel(model) {
     }
     return { upstream, agentic, thinking };
 }
-function isAdaptiveThinkingModel(model) {
-    return /^claude/i.test(model);
+function isLegacyThinkingDirectiveModel(model) {
+    return /^claude-(?:opus-4\.5|sonnet-4(?:\.5)?|haiku-4\.5)$/i.test(model);
 }
 function kiroEffortString(effort) {
     if (!effort || effort === "none")
@@ -201,6 +239,145 @@ function kiroEffortString(effort) {
         return "xhigh";
     return "max";
 }
+function asKiroRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function normalizeKiroStopReason(value) {
+    const reason = typeof value === "string" ? value.trim() : "";
+    const normalized = reason
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .replace(/[\s-]+/g, "_");
+    if (["endturn", "end_turn", "stop", "stop_sequence", "completed"].includes(normalized)) {
+        return "end_turn";
+    }
+    if (["tooluse", "tool_use", "tool_calls"].includes(normalized))
+        return "tool_use";
+    if (["maxtokens", "max_tokens", "max_output_tokens", "length"].includes(normalized)) {
+        return "max_tokens";
+    }
+    return normalized;
+}
+function kiroStopDisposition(reason, hasToolCalls) {
+    if (["malformed_model_output", "invalid_model_output"].includes(reason))
+        return "retryable";
+    if (reason === "refusal" || /(?:content.*filter|guardrail|safety|policy|blocked)/u.test(reason)) {
+        return "blocked";
+    }
+    if (["cancelled", "pause_turn"].includes(reason))
+        return "incomplete";
+    if (["max_tokens", "model_context_window_exceeded"].includes(reason)) {
+        return hasToolCalls ? "incomplete" : "length";
+    }
+    if (hasToolCalls || reason === "tool_use")
+        return "tool_calls";
+    if (!reason || reason === "end_turn")
+        return "complete";
+    return "unknown";
+}
+function mergeKiroStopReason(current, incoming) {
+    if (!incoming)
+        return current;
+    if (!current)
+        return incoming;
+    const severity = (reason) => {
+        const disposition = kiroStopDisposition(reason, false);
+        if (disposition === "blocked")
+            return 6;
+        if (disposition === "incomplete" || disposition === "unknown")
+            return 5;
+        if (disposition === "retryable")
+            return 4;
+        if (disposition === "length")
+            return 3;
+        if (disposition === "tool_calls")
+            return 2;
+        return 1;
+    };
+    return severity(incoming) > severity(current) ? incoming : current;
+}
+function firstKiroMetric(sources, names) {
+    for (const source of sources) {
+        for (const name of names) {
+            const value = source[name];
+            if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+function schemaEnum(schema) {
+    return Array.isArray(schema?.enum)
+        ? schema.enum.filter((value) => typeof value === "string")
+        : [];
+}
+function schemaProperty(schema, name) {
+    return asKiroRecord(asKiroRecord(schema?.properties)?.[name]);
+}
+function supportedEffort(requested, schema) {
+    const efforts = schemaEnum(schema);
+    if (efforts.length === 0)
+        return undefined;
+    const normalized = requested === "minimal" ? "low" : requested;
+    return nearestAcceptedEffort(normalized, efforts);
+}
+function schemaEffortFields(schema) {
+    const output = schemaProperty(schema, "output_config");
+    const outputEffort = schemaProperty(output, "effort");
+    if (outputEffort)
+        return { key: "output_config", schema: outputEffort };
+    const reasoning = schemaProperty(schema, "reasoning");
+    const reasoningEffort = schemaProperty(reasoning, "effort");
+    return reasoningEffort
+        ? { key: "reasoning", schema: reasoningEffort }
+        : undefined;
+}
+function kiroAdditionalModelFields(request, info, wantsThinking) {
+    const schema = info?.additionalModelRequestFieldsSchema;
+    const thinkingSchema = schemaProperty(schema, "thinking");
+    const effortFields = schemaEffortFields(schema);
+    if (!wantsThinking && !request.thinking)
+        return undefined;
+    const requestedEffort = wantsThinking
+        ? request.thinking?.effort ?? "high"
+        : "none";
+    if (!thinkingSchema && !effortFields)
+        return undefined;
+    const fields = {};
+    if (thinkingSchema) {
+        const types = schemaEnum(schemaProperty(thinkingSchema, "type"));
+        if (!wantsThinking && types.includes("disabled")) {
+            return { thinking: { type: "disabled" } };
+        }
+        if (types.includes("adaptive")) {
+            fields.thinking = { type: "adaptive", display: "summarized" };
+        }
+        else if (wantsThinking) {
+            return undefined;
+        }
+    }
+    if (effortFields) {
+        const effort = supportedEffort(requestedEffort, effortFields.schema);
+        if (effort)
+            fields[effortFields.key] = { effort };
+    }
+    const maxTokensSchema = schemaProperty(schema, "max_tokens");
+    if (wantsThinking && request.maxTokens && maxTokensSchema) {
+        const minimum = typeof maxTokensSchema.minimum === "number" ? maxTokensSchema.minimum : 1;
+        const maximum = typeof maxTokensSchema.maximum === "number"
+            ? maxTokensSchema.maximum
+            : info?.maxOutputTokens ?? request.maxTokens;
+        fields.max_tokens = Math.min(maximum, Math.max(minimum, request.maxTokens));
+    }
+    return Object.keys(fields).length > 0 ? fields : undefined;
+}
+function legacyThinkingDirective(effort) {
+    const budget = KIRO_THINKING_BUDGET[kiroEffortString(effort) || "high"] ?? 16000;
+    return `<thinking_mode>enabled</thinking_mode><max_thinking_length>${budget}</max_thinking_length>`;
+}
 const KIRO_THINKING_BUDGET = {
     low: 4000,
     medium: 8000,
@@ -239,7 +416,12 @@ function resolveKiroCredential(auth) {
     };
 }
 async function withKiroCredential(auth, run, onStatus) {
-    const credential = resolveKiroCredential(auth);
+    let credential = resolveKiroCredential(auth);
+    if (credential.refreshToken && kiroCredentialNeedsRefresh(credential)) {
+        const refreshed = await refreshStoredKiroKey(auth).catch(() => undefined);
+        if (refreshed)
+            credential = refreshed;
+    }
     try {
         return await run(credential);
     }
@@ -248,27 +430,51 @@ async function withKiroCredential(auth, run, onStatus) {
         if (status !== 401 && status !== 403)
             throw error;
         onStatus?.("ℹ Kiro authentication expired — attempting token refresh");
-        const oldKey = auth.apiKey ?? "";
-        const refreshedKey = await maybeRefreshKiroCredential(oldKey, auth.refreshToken);
-        if (!refreshedKey || refreshedKey === oldKey) {
+        let newCredential;
+        try {
+            newCredential = await refreshStoredKiroKey(auth);
+        }
+        catch (refreshError) {
+            if (refreshError instanceof KiroRefreshError) {
+                throw new ProviderError(refreshError.message, status);
+            }
             throw error;
         }
-        await replaceProviderKey("kiro", oldKey, refreshedKey).catch(() => { });
-        auth.apiKey = refreshedKey;
-        const newCredential = resolveKiroCredential({ ...auth, apiKey: refreshedKey });
+        if (!newCredential)
+            throw error;
         onStatus?.("ℹ Kiro token refreshed — retrying request");
         return run(newCredential);
     }
 }
-function getCandidateEndpoints(credential) {
-    const region = assertValidAwsRegion(credential.region);
-    const qUrl = `https://q.${region}.amazonaws.com/generateAssistantResponse`;
-    const cwUrl = `https://codewhisperer.${region}.amazonaws.com/generateAssistantResponse`;
-    const rtUrl = `https://runtime.${region}.kiro.dev/generateAssistantResponse`;
-    if (credential.authMethod === "api_key") {
-        return [qUrl, cwUrl, rtUrl];
+async function refreshStoredKiroKey(auth) {
+    const oldKey = auth.apiKey ?? "";
+    const refreshedKey = await maybeRefreshKiroCredential(oldKey, auth.refreshToken);
+    if (!refreshedKey || refreshedKey === oldKey)
+        return undefined;
+    await replaceProviderKey("kiro", oldKey, refreshedKey).catch(() => { });
+    auth.apiKey = refreshedKey;
+    return resolveKiroCredential({ ...auth, apiKey: refreshedKey });
+}
+function getCandidateEndpoints(credential, generation) {
+    const region = resolveKiroRuntimeRegion(credential);
+    const apiRegion = region;
+    const modern = { url: `https://runtime.${apiRegion}.kiro.dev/`, awsTarget: true };
+    const q = {
+        url: `https://q.${region}.amazonaws.com/generateAssistantResponse`,
+        awsTarget: false,
+    };
+    const codewhisperer = {
+        url: `https://codewhisperer.${region}.amazonaws.com/generateAssistantResponse`,
+        awsTarget: true,
+    };
+    if (generation === "modern") {
+        return credential.authMethod === "api_key"
+            ? [modern, q, codewhisperer]
+            : [modern, codewhisperer, q];
     }
-    return [cwUrl, rtUrl, qUrl];
+    return credential.authMethod === "api_key"
+        ? [q, modern, codewhisperer]
+        : [codewhisperer, modern, q];
 }
 function uuidFromHex(hex) {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
@@ -290,12 +496,12 @@ function sanitizeToolName(name) {
 function formatKiroTools(tools) {
     if (!tools || tools.length === 0)
         return [];
-    return tools.map((t) => ({
+    return tools.map((tool) => ({
         toolSpecification: {
-            name: sanitizeToolName(t.wireName || t.name),
-            description: (t.description || "").slice(0, 10237),
+            name: sanitizeToolName(tool.wireName || tool.name),
+            description: (tool.description || `Tool: ${tool.name}`).slice(0, 10237),
             inputSchema: {
-                json: t.parameters,
+                json: tool.parameters,
             },
         },
     }));
@@ -312,21 +518,34 @@ function imageFormatFromMediaType(mediaType) {
         return "webp";
     return "png";
 }
-function buildKiroRequestBody(request, credential, upstreamModel, agentic, thinking) {
+export function buildKiroRequestBody(request, credential, upstreamModel, agentic, thinking) {
     const agenticInstruction = agentic
         ? "When modifying or creating files, keep writes concise:\n- Maximum 350 lines per file write/tool call (recommended 300 lines or fewer).\n- Prefer targeted, incremental edits instead of rewriting entire files.\n- For large files, write or append in chunks across multiple tool calls."
         : "";
     const systemParts = [];
     if (agenticInstruction)
         systemParts.push(agenticInstruction);
+    let sawLeadingSystem = false;
     const nonSystemMessages = [];
     for (const msg of request.messages) {
-        if (msg.role === "system") {
+        if (msg.role !== "system") {
+            nonSystemMessages.push(msg);
+            continue;
+        }
+        if (!sawLeadingSystem) {
+            sawLeadingSystem = true;
             if (msg.content.trim())
                 systemParts.push(msg.content.trim());
+            continue;
         }
-        else {
-            nonSystemMessages.push(msg);
+        if (msg.content.trim()) {
+            nonSystemMessages.push({
+                ...msg,
+                role: "user",
+                content: msg.content.startsWith("[SYSTEM]")
+                    ? msg.content
+                    : `[SYSTEM]\n${msg.content}`,
+            });
         }
     }
     const systemPrompt = systemParts.join("\n\n").trim();
@@ -357,6 +576,40 @@ function buildKiroRequestBody(request, credential, upstreamModel, agentic, think
             }
         }
         else if (msg.role === "assistant") {
+            const replayTarget = createReasoningArtifactReplayTarget({
+                provider: "kiro",
+                model: upstreamModel,
+                dialect: "kiro-eventstream",
+            });
+            const replayedReasoning = request.forceReasoningReplay === false
+                ? []
+                : selectReasoningArtifactsForReplay({
+                    artifacts: reasoningArtifactsForMessage(msg),
+                    target: replayTarget,
+                    context: {
+                        hasToolCalls: Boolean(msg.toolCalls?.length),
+                        forceScope: request.forceReasoningReplay === true,
+                    },
+                    observe: request.onReasoningArtifactReplayDecision,
+                });
+            const signedReasoning = replayedReasoning.find((artifact) => reasoningArtifactText(artifact) && reasoningArtifactSignature(artifact));
+            const redactedReasoning = replayedReasoning.find((artifact) => {
+                const raw = asKiroRecord(artifact.raw);
+                return artifact.kind === "encrypted" && typeof raw?.redactedContent === "string";
+            });
+            const redactedRaw = redactedReasoning
+                ? asKiroRecord(redactedReasoning.raw)
+                : undefined;
+            const reasoningContent = signedReasoning
+                ? {
+                    reasoningText: {
+                        text: reasoningArtifactText(signedReasoning),
+                        signature: reasoningArtifactSignature(signedReasoning),
+                    },
+                }
+                : typeof redactedRaw?.redactedContent === "string"
+                    ? { redactedContent: redactedRaw.redactedContent }
+                    : undefined;
             const toolUses = (msg.toolCalls ?? [])
                 .filter((tc) => tc.id)
                 .map((tc) => ({
@@ -371,6 +624,9 @@ function buildKiroRequestBody(request, credential, upstreamModel, agentic, think
                         ? `${last.content}\n\n${msg.content}`
                         : msg.content;
                 }
+                if (reasoningContent && !last.reasoningContent) {
+                    last.reasoningContent = reasoningContent;
+                }
                 if (toolUses.length > 0) {
                     last.toolUses = [...(last.toolUses ?? []), ...toolUses];
                 }
@@ -379,6 +635,7 @@ function buildKiroRequestBody(request, credential, upstreamModel, agentic, think
                 turns.push({
                     role: "assistant",
                     content: msg.content || "",
+                    reasoningContent,
                     toolUses: toolUses.length > 0 ? toolUses : undefined,
                 });
             }
@@ -421,7 +678,24 @@ function buildKiroRequestBody(request, credential, upstreamModel, agentic, think
                     : "continue";
         }
     }
+    const modelInfo = kiroModelCatalog().find((info) => info.modelId === upstreamModel);
     const kiroTools = formatKiroTools(request.tools);
+    const wantsThinking = (request.thinking?.enabled ?? thinking) &&
+        request.thinking?.effort !== "none";
+    const additionalFields = kiroAdditionalModelFields(request, modelInfo, wantsThinking);
+    const thinkingDirective = !additionalFields &&
+        wantsThinking &&
+        isLegacyThinkingDirectiveModel(upstreamModel) &&
+        !modelInfo?.additionalModelRequestFieldsSchema
+        ? legacyThinkingDirective(request.thinking?.effort)
+        : "";
+    if (thinkingDirective) {
+        for (const turn of turns) {
+            if (turn.role === "user") {
+                turn.content = `${thinkingDirective}\n\n${turn.content}`;
+            }
+        }
+    }
     const history = [];
     for (let i = 0; i < turns.length - 1; i++) {
         const turn = turns[i];
@@ -446,6 +720,9 @@ function buildKiroRequestBody(request, credential, upstreamModel, agentic, think
             history.push({
                 assistantResponseMessage: {
                     content: turn.content,
+                    ...(turn.reasoningContent
+                        ? { reasoningContent: turn.reasoningContent }
+                        : {}),
                     ...(turn.toolUses && turn.toolUses.length > 0
                         ? { toolUses: turn.toolUses }
                         : {}),
@@ -485,28 +762,68 @@ function buildKiroRequestBody(request, credential, upstreamModel, agentic, think
     if (credential.profileArn) {
         payload.profileArn = credential.profileArn;
     }
-    const wantsThinking = thinking || request.thinking?.enabled === true;
-    const effort = kiroEffortString(request.thinking?.effort) || "high";
-    if (wantsThinking && isAdaptiveThinkingModel(upstreamModel)) {
-        const budget = KIRO_THINKING_BUDGET[effort] ?? 16000;
-        const directive = `<thinking_mode>enabled</thinking_mode><max_thinking_length>${budget}</max_thinking_length>`;
-        const uim = payload.conversationState
-            .currentMessage;
-        const msg = uim.userInputMessage;
-        msg.content = `${directive}\n\n${String(msg.content ?? "")}`;
+    if (additionalFields) {
+        payload.additionalModelRequestFields = additionalFields;
     }
     return payload;
 }
 let cachedKiroModels = null;
 let cachedKiroModelInfo = [];
+let cachedKiroApiGeneration;
+let cachedKiroCredentialId = "";
 let lastKiroModelFetch = 0;
 const MODEL_CACHE_TTL_MS = 30 * 60 * 1000;
+function kiroCredentialId(credential) {
+    return createHash("sha256")
+        .update(credential.apiKey || credential.accessToken || credential.refreshToken || "")
+        .digest("hex");
+}
+function hasFreshKiroCatalog(credentialId) {
+    return (cachedKiroCredentialId === credentialId &&
+        cachedKiroModels !== null &&
+        Date.now() - lastKiroModelFetch < MODEL_CACHE_TTL_MS);
+}
+function kiroCatalogLimits(modelId, info) {
+    if (info.maxInputTokens === undefined && info.maxOutputTokens === undefined)
+        return [];
+    return [{
+            id: modelId,
+            ...(info.maxInputTokens !== undefined ? { contextTokens: info.maxInputTokens } : {}),
+            ...(info.maxOutputTokens !== undefined ? { maxOutputTokens: info.maxOutputTokens } : {}),
+            ...(info.supportsImages !== undefined ? { vision: info.supportsImages } : {}),
+        }];
+}
+async function ensureKiroModelCatalog(credential) {
+    const credentialId = kiroCredentialId(credential);
+    if (hasFreshKiroCatalog(credentialId))
+        return;
+    const catalog = await discoverKiroModelsDetailed(credential);
+    cachedKiroCredentialId = credentialId;
+    cachedKiroModelInfo = catalog.models;
+    cachedKiroApiGeneration = catalog.generation;
+    cachedKiroModels = withKiroVariants(catalog.models.map((info) => info.modelId));
+    lastKiroModelFetch = Date.now();
+    const limits = [];
+    for (const info of catalog.models) {
+        if (info.supportsImages !== undefined) {
+            learnModelVisionCapability("kiro", info.modelId, info.supportsImages);
+        }
+        const efforts = kiroCatalogEfforts(info.additionalModelRequestFieldsSchema);
+        for (const variant of withKiroVariants([info.modelId])) {
+            registerModelReasoningEfforts("kiro", variant, efforts);
+            limits.push(...kiroCatalogLimits(variant, info));
+        }
+    }
+    registerModelCatalogLimits("kiro", limits);
+}
 export function kiroModelCatalog() {
     return cachedKiroModelInfo;
 }
 export function resetKiroModelCacheForTesting() {
     cachedKiroModels = null;
     cachedKiroModelInfo = [];
+    cachedKiroApiGeneration = undefined;
+    cachedKiroCredentialId = "";
     lastKiroModelFetch = 0;
 }
 export async function fetchKiroUsageLimits(auth, onStatus) {
@@ -541,56 +858,35 @@ export const kiroProvider = {
         return trimmed.length >= 8;
     },
     async listModels(auth) {
-        const now = Date.now();
-        if (cachedKiroModels && now - lastKiroModelFetch < MODEL_CACHE_TTL_MS) {
+        const credential = resolveKiroCredential(auth);
+        const credentialId = kiroCredentialId(credential);
+        const cacheIsFresh = cachedKiroCredentialId === credentialId &&
+            cachedKiroModels !== null &&
+            Date.now() - lastKiroModelFetch < MODEL_CACHE_TTL_MS;
+        if (cacheIsFresh)
             return cachedKiroModels;
-        }
         try {
-            const credential = resolveKiroCredential(auth);
-            const infos = await listKiroModelsDetailed(credential);
-            if (infos.length > 0) {
-                cachedKiroModelInfo = infos;
-                for (const info of infos) {
-                    if (info.supportsImages !== undefined) {
-                        learnModelVisionCapability("kiro", info.modelId, info.supportsImages);
-                    }
-                }
-                const variants = withKiroVariants(infos.map((info) => info.modelId));
-                cachedKiroModels = variants;
-                lastKiroModelFetch = now;
-                return variants;
+            const refreshedId = await withKiroCredential(auth, async (current) => {
+                await ensureKiroModelCatalog(current);
+                return kiroCredentialId(current);
+            });
+            if ((cachedKiroCredentialId === credentialId ||
+                cachedKiroCredentialId === refreshedId) &&
+                cachedKiroModels) {
+                return cachedKiroModels;
             }
         }
         catch { }
-        return cachedKiroModels ?? [...kiroFallbackModels];
+        return [...kiroFallbackModels];
     },
     async ping(auth) {
         const credential = resolveKiroCredential(auth);
-        const region = assertValidAwsRegion(credential.region);
-        const params = new URLSearchParams({ origin: "AI_EDITOR" });
-        const endpoint = `https://q.${region}.amazonaws.com/ListAvailableModels?${params.toString()}`;
-        const headers = {
-            Accept: "application/json",
-            "User-Agent": "AWS-SDK-JS/3.0.0 kiro-ide/1.0.0",
-            "X-Amz-User-Agent": "aws-sdk-js/3.0.0 kiro-ide/1.0.0",
-        };
-        if (credential.authMethod === "api_key" && credential.apiKey) {
-            headers["Authorization"] = `Bearer ${credential.apiKey}`;
-            headers["TokenType"] = "API_KEY";
-        }
-        else if (credential.accessToken) {
-            headers["Authorization"] = `Bearer ${credential.accessToken}`;
-            if (credential.authMethod === "external_idp") {
-                headers["TokenType"] = "EXTERNAL_IDP";
-            }
+        try {
+            await discoverKiroModelsDetailed(credential);
         }
-        const response = await fetch(endpoint, {
-            method: "GET",
-            headers,
-            signal: AbortSignal.timeout(15_000),
-        });
-        if (!response.ok) {
-            throw new ProviderError(`Kiro AI ping failed (HTTP ${response.status}). Run \`clai auth kiro\` to sign in.`, response.status);
+        catch (error) {
+            const detail = error instanceof Error ? `: ${error.message}` : "";
+            throw new ProviderError(`Kiro AI ping failed${detail}. Run \`clai auth kiro\` to sign in.`);
         }
     },
     async complete(request, auth, onStatus) {
@@ -600,13 +896,17 @@ export const kiroProvider = {
         const requestedModel = request.model ?? defaultModels.kiro;
         const { upstream, agentic, thinking } = resolveKiroModel(requestedModel);
         return withKiroCredential(auth, async (credential) => {
+            await ensureKiroModelCatalog(credential).catch(() => { });
             const body = buildKiroRequestBody(request, credential, upstream, agentic, thinking);
-            const endpoints = getCandidateEndpoints(credential);
+            const catalogIsFresh = hasFreshKiroCatalog(kiroCredentialId(credential));
+            const endpoints = getCandidateEndpoints(credential, catalogIsFresh ? cachedKiroApiGeneration : undefined);
             let lastError;
             for (const endpoint of endpoints) {
                 try {
                     const headers = {
-                        "Content-Type": "application/json",
+                        "Content-Type": endpoint.awsTarget
+                            ? "application/x-amz-json-1.0"
+                            : "application/json",
                         Accept: "application/vnd.amazon.eventstream",
                         "Amz-Sdk-Request": "attempt=1; max=3",
                         "Amz-Sdk-Invocation-Id": randomUUID(),
@@ -616,7 +916,7 @@ export const kiroProvider = {
                         "x-amzn-codewhisperer-optout": "true",
                         "x-amzn-codewhisperer-machine-id": "kiro-desktop",
                     };
-                    if (endpoint.includes("codewhisperer")) {
+                    if (endpoint.awsTarget) {
                         headers["X-Amz-Target"] =
                             "AmazonCodeWhispererStreamingService.GenerateAssistantResponse";
                     }
@@ -634,7 +934,7 @@ export const kiroProvider = {
                             headers["x-amzn-codewhisperer-profile-arn"] = credential.profileArn;
                         }
                     }
-                    const response = await generationFetch(endpoint, {
+                    const response = await generationFetch(endpoint.url, {
                         method: "POST",
                         headers,
                         body: JSON.stringify(body),
@@ -643,7 +943,12 @@ export const kiroProvider = {
                     if (!response.ok) {
                         const errorText = await response.text().catch(() => "");
                         if (response.status === 401 || response.status === 403) {
-                            throw new ProviderError(`Kiro authentication failed (${response.status}): ${errorText}`, response.status);
+                            const authError = new ProviderError(`Kiro authentication failed (${response.status}): ${errorText}`, response.status);
+                            if (response.status === 401 && credential.refreshToken) {
+                                throw authError;
+                            }
+                            lastError = authError;
+                            continue;
                         }
                         if (response.status === 400) {
                             throw new ProviderError(`Kiro request invalid (${response.status}): ${errorText}`, response.status, errorText);
@@ -655,9 +960,11 @@ export const kiroProvider = {
                         throw new ProviderError("Empty response body from Kiro endpoint", 500);
                     }
                     let fullText = "";
-                    let reasoningText = "";
+                    const pendingStreamEvents = [];
+                    const reasoning = createKiroReasoningAccumulator((text) => pendingStreamEvents.push({ kind: "reasoning", text }));
                     let insideThinkingTag = false;
                     let finishReason = "stop";
+                    let stopReason = "";
                     const accumulatedTools = [];
                     let currentToolIndex = -1;
                     let promptTokens = 0;
@@ -667,13 +974,35 @@ export const kiroProvider = {
                     const usageCharges = [];
                     let contextUsagePercentage;
                     for await (const frame of parseEventStream(response.body)) {
+                        const messageType = typeof frame.headers[":message-type"] === "string"
+                            ? frame.headers[":message-type"]
+                            : "event";
+                        const headerExceptionType = typeof frame.headers[":exception-type"] === "string"
+                            ? frame.headers[":exception-type"]
+                            : "";
                         const eventType = (typeof frame.headers[":event-type"] === "string"
                             ? frame.headers[":event-type"]
                             : undefined) ||
-                            Object.keys(frame.payload).find((k) => k.endsWith("Event")) ||
+                            headerExceptionType ||
+                            Object.keys(frame.payload).find((key) => key.endsWith("Event") || key.endsWith("Exception")) ||
                             "";
-                        const eventPayload = frame.payload[eventType] ||
-                            frame.payload;
+                        const nestedPayload = asKiroRecord(frame.payload[eventType]);
+                        const eventPayload = nestedPayload ?? frame.payload;
+                        if (messageType === "exception" || headerExceptionType || eventType.endsWith("Exception")) {
+                            const message = typeof eventPayload.message === "string"
+                                ? eventPayload.message
+                                : typeof eventPayload.reason === "string"
+                                    ? eventPayload.reason
+                                    : "Kiro stream exception";
+                            throw new ProviderError(`${headerExceptionType || eventType || "Kiro stream exception"}: ${message}`, inBandBadRequestStatus({
+                                type: headerExceptionType || eventType,
+                                code: eventPayload.code,
+                                message,
+                            }) ??
+                                (/THINKING_SIGNATURE_INVALID|THINKING_SIGNATURE_MISMATCH/i.test(`${headerExceptionType} ${eventType} ${message}`)
+                                    ? 400
+                                    : 502), JSON.stringify(eventPayload));
+                        }
                         if (typeof eventPayload.usage === "number" &&
                             Number.isFinite(eventPayload.usage) &&
                             eventPayload.usage >= 0 &&
@@ -728,25 +1057,41 @@ export const kiroProvider = {
                                         }
                                     }
                                 }
-                                if (reasoningChunk) {
-                                    reasoningText += reasoningChunk;
-                                    emitStreamReasoningDelta(request.onStreamEvent, reasoningChunk);
-                                }
+                                reasoning.push(reasoningChunk);
                                 if (visibleChunk) {
                                     fullText += visibleChunk;
-                                    onToken(visibleChunk);
+                                    pendingStreamEvents.push({ kind: "token", text: visibleChunk });
                                 }
                             }
                         }
                         else if (eventType === "reasoningContentEvent" ||
-                            eventType.includes("Reasoning")) {
-                            const chunk = typeof eventPayload.content === "string"
-                                ? eventPayload.content
-                                : "";
-                            if (chunk) {
-                                reasoningText += chunk;
-                                emitStreamReasoningDelta(request.onStreamEvent, chunk);
-                            }
+                            /reasoning/i.test(eventType) ||
+                            eventPayload.reasoningText !== undefined) {
+                            const reasoningPayload = asKiroRecord(eventPayload.reasoningText);
+                            const chunk = typeof eventPayload.text === "string"
+                                ? eventPayload.text
+                                : typeof eventPayload.content === "string"
+                                    ? eventPayload.content
+                                    : typeof eventPayload.reasoningText === "string"
+                                        ? eventPayload.reasoningText
+                                        : typeof reasoningPayload?.text === "string"
+                                            ? reasoningPayload.text
+                                            : typeof reasoningPayload?.Text === "string"
+                                                ? reasoningPayload.Text
+                                                : "";
+                            reasoning.sign(typeof eventPayload.signature === "string"
+                                ? eventPayload.signature
+                                : typeof eventPayload.Signature === "string"
+                                    ? eventPayload.Signature
+                                    : typeof reasoningPayload?.signature === "string"
+                                        ? reasoningPayload.signature
+                                        : typeof reasoningPayload?.Signature === "string"
+                                            ? reasoningPayload.Signature
+                                            : "");
+                            reasoning.redact(typeof eventPayload.redactedContent === "string"
+                                ? eventPayload.redactedContent
+                                : "");
+                            reasoning.push(chunk);
                         }
                         else if (eventType === "codeEvent") {
                             const chunk = typeof eventPayload.content === "string"
@@ -754,54 +1099,67 @@ export const kiroProvider = {
                                 : "";
                             if (chunk) {
                                 fullText += chunk;
-                                onToken(chunk);
+                                pendingStreamEvents.push({ kind: "token", text: chunk });
                             }
                         }
                         else if (eventType === "toolUseEvent") {
-                            const toolId = typeof eventPayload.toolUseId === "string"
+                            const explicitToolId = typeof eventPayload.toolUseId === "string"
                                 ? eventPayload.toolUseId
-                                : `tool_${accumulatedTools.length + 1}`;
+                                : typeof eventPayload.tool_use_id === "string"
+                                    ? eventPayload.tool_use_id
+                                    : undefined;
                             const name = typeof eventPayload.name === "string" ? eventPayload.name : "";
                             const input = eventPayload.input;
-                            let existing = accumulatedTools.find((t) => t.id === toolId);
-                            if (!existing) {
-                                existing = { id: toolId, name, rawArgs: "" };
+                            const stopped = eventPayload.stop === true;
+                            let existing = explicitToolId
+                                ? accumulatedTools.find((tool) => tool.id === explicitToolId)
+                                : accumulatedTools[currentToolIndex];
+                            if (explicitToolId &&
+                                !existing &&
+                                currentToolIndex >= 0 &&
+                                accumulatedTools[currentToolIndex]?.syntheticId) {
+                                const activeTool = accumulatedTools[currentToolIndex];
+                                activeTool.id = explicitToolId;
+                                activeTool.syntheticId = false;
+                                existing = activeTool;
+                            }
+                            if (!existing && (explicitToolId || name || input !== undefined)) {
+                                existing = {
+                                    id: explicitToolId ?? `tool_${accumulatedTools.length + 1}`,
+                                    name,
+                                    rawArgs: "",
+                                    syntheticId: explicitToolId === undefined,
+                                };
                                 accumulatedTools.push(existing);
-                                currentToolIndex = accumulatedTools.length - 1;
                             }
-                            let chunkBytes = 0;
+                            if (!existing) {
+                                if (stopped)
+                                    currentToolIndex = -1;
+                                continue;
+                            }
                             if (typeof input === "string") {
                                 existing.rawArgs += input;
-                                chunkBytes = Buffer.byteLength(input, "utf8");
                             }
                             else if (input && typeof input === "object") {
                                 existing.rawArgs = JSON.stringify(input);
-                                chunkBytes = Buffer.byteLength(existing.rawArgs, "utf8");
                             }
-                            if (name && !existing.name) {
+                            if (name && !existing.name)
                                 existing.name = name;
-                            }
+                            currentToolIndex = accumulatedTools.indexOf(existing);
+                            const argumentsBytes = Buffer.byteLength(existing.rawArgs, "utf8");
                             const delta = {
                                 index: currentToolIndex,
                                 id: existing.id,
                                 name: existing.name,
-                                argumentsBytes: chunkBytes,
+                                argumentsBytes,
                             };
-                            request.onToolCallDelta?.(delta);
+                            pendingStreamEvents.push({ kind: "tool", delta });
                             finishReason = "tool_calls";
+                            if (stopped)
+                                currentToolIndex = -1;
                         }
                         else if (eventType === "messageStopEvent") {
-                            const stop = typeof eventPayload.stopReason === "string"
-                                ? eventPayload.stopReason
-                                : "";
-                            if (stop) {
-                                finishReason =
-                                    stop === "tool_use" || stop === "tool_calls"
-                                        ? "tool_calls"
-                                        : stop === "max_tokens" || stop === "length"
-                                            ? "length"
-                                            : "stop";
-                            }
+                            stopReason = mergeKiroStopReason(stopReason, normalizeKiroStopReason(eventPayload.stopReason ?? eventPayload.stop_reason));
                         }
                         else if (eventType === "contextUsageEvent") {
                             if (typeof eventPayload.contextUsagePercentage === "number") {
@@ -809,21 +1167,56 @@ export const kiroProvider = {
                             }
                         }
                         else if (eventType === "metricsEvent" ||
-                            eventType === "meteringEvent") {
-                            if (typeof eventPayload.inputTokens === "number") {
-                                promptTokens = eventPayload.inputTokens;
-                            }
-                            if (typeof eventPayload.outputTokens === "number") {
-                                completionTokens = eventPayload.outputTokens;
+                            eventType === "meteringEvent" ||
+                            eventType === "metadataEvent" ||
+                            eventType === "MetadataEvent") {
+                            const usagePayload = asKiroRecord(eventPayload.usage);
+                            const tokenUsagePayload = asKiroRecord(eventPayload.tokenUsage);
+                            const usageSources = [
+                                eventPayload,
+                                ...(usagePayload ? [usagePayload] : []),
+                                ...(tokenUsagePayload ? [tokenUsagePayload] : []),
+                            ];
+                            const inputTokens = firstKiroMetric(usageSources, [
+                                "inputTokens",
+                                "input_tokens",
+                                "promptTokens",
+                                "prompt_tokens",
+                            ]);
+                            const outputTokens = firstKiroMetric(usageSources, [
+                                "outputTokens",
+                                "output_tokens",
+                                "completionTokens",
+                                "completion_tokens",
+                            ]);
+                            const cacheReadTokens = firstKiroMetric(usageSources, [
+                                "cacheReadTokens",
+                                "cache_read_tokens",
+                                "cacheReadInputTokens",
+                                "cache_read_input_tokens",
+                                "cachedTokens",
+                            ]);
+                            const cacheWriteTokens = firstKiroMetric(usageSources, [
+                                "cacheCreationTokens",
+                                "cache_creation_tokens",
+                                "cacheWriteTokens",
+                                "cache_write_tokens",
+                                "cacheWriteInputTokens",
+                                "cacheCreationInputTokens",
+                                "cache_creation_input_tokens",
+                            ]);
+                            if (inputTokens !== undefined)
+                                promptTokens = inputTokens;
+                            if (outputTokens !== undefined)
+                                completionTokens = outputTokens;
+                            if (cacheReadTokens !== undefined) {
+                                cachedTokens = Math.max(cachedTokens, cacheReadTokens);
                             }
-                            if (typeof eventPayload.cachedTokens === "number") {
-                                cachedTokens = eventPayload.cachedTokens;
+                            if (cacheWriteTokens !== undefined) {
+                                cacheCreationTokens = Math.max(cacheCreationTokens, cacheWriteTokens);
                             }
-                            if (typeof eventPayload.cacheReadInputTokens === "number") {
-                                cachedTokens = Math.max(cachedTokens, eventPayload.cacheReadInputTokens);
-                            }
-                            if (typeof eventPayload.cacheWriteInputTokens === "number") {
-                                cacheCreationTokens = eventPayload.cacheWriteInputTokens;
+                            if (/^metadataevent$/i.test(eventType)) {
+                                stopReason = mergeKiroStopReason(stopReason, normalizeKiroStopReason(eventPayload.stopReason ?? eventPayload.stop_reason));
                             }
                         }
                     }
@@ -842,11 +1235,49 @@ export const kiroProvider = {
                             rawArguments: t.rawArgs,
                         };
                     });
-                    if (toolCalls.length > 0) {
+                    reasoning.finish();
+                    const hasReasoningEvidence = Boolean(reasoning.text.trim() || reasoning.signature || reasoning.redactedContent);
+                    const stopDisposition = kiroStopDisposition(stopReason, toolCalls.length > 0);
+                    if (stopDisposition === "blocked") {
+                        throw new ProviderError(`Kiro blocked the response under its content safety policy (${stopReason})`, 400);
+                    }
+                    if (stopDisposition === "retryable" ||
+                        stopDisposition === "incomplete" ||
+                        stopDisposition === "unknown") {
+                        throw new ProviderError(`Kiro ended with non-success stop reason: ${stopReason}`, 502);
+                    }
+                    if (!fullText.trim() &&
+                        !hasReasoningEvidence &&
+                        toolCalls.length === 0) {
+                        throw new ProviderError("Kiro completed without a visible answer.");
+                    }
+                    if (toolCalls.length === 0 && ["...", "…"].includes(fullText.trim())) {
+                        throw new ProviderError("Kiro completed without a visible answer.");
+                    }
+                    if (reasoning.opaque && (fullText.trim() || toolCalls.length > 0)) {
+                        pendingStreamEvents.push({
+                            kind: "reasoning",
+                            text: kiroPrivateReasoningNote({
+                                model: upstream,
+                                effort: sentKiroReasoningEffort(asKiroRecord(body.additionalModelRequestFields)),
+                                signatureChars: reasoning.signature.length,
+                            }),
+                        });
+                    }
+                    if (stopDisposition === "length") {
+                        finishReason = "length";
+                    }
+                    else if (toolCalls.length > 0) {
                         finishReason = "tool_calls";
                     }
-                    const catalogWindow = kiroModelCatalog().find((info) => info.modelId === upstream)
-                        ?.maxInputTokens ?? 200_000;
+                    const advertisedWindow = kiroModelCatalog().find((info) => info.modelId === upstream)
+                        ?.maxInputTokens;
+                    const catalogWindow = advertisedWindow !== undefined &&
+                        Number.isFinite(advertisedWindow) &&
+                        advertisedWindow > 0
+                        ? Math.floor(advertisedWindow)
+                        : undefined;
+                    const estimatedPromptTokens = providerRatioPromptTokens(contextUsagePercentage, catalogWindow ?? modelContextWindow(upstream, "kiro"));
                     const tokenUsage = promptTokens > 0 || completionTokens > 0
                         ? {
                             promptTokens,
@@ -859,14 +1290,19 @@ export const kiroProvider = {
                                 ? Math.max(0, promptTokens - cachedTokens)
                                 : promptTokens,
                         }
-                        : contextUsagePercentage !== undefined
-                            ? {
-                                promptTokens: Math.round((contextUsagePercentage / 100) * catalogWindow),
-                                completionTokens: 0,
-                                totalTokens: Math.round((contextUsagePercentage / 100) * catalogWindow),
-                                exact: false,
-                            }
-                            : undefined;
+                        : catalogWindow !== undefined
+                            ? providerRatioUsage({
+                                percentUsed: contextUsagePercentage,
+                                windowTokens: catalogWindow,
+                            })
+                            : estimatedPromptTokens !== undefined
+                                ? {
+                                    promptTokens: estimatedPromptTokens,
+                                    completionTokens: 0,
+                                    totalTokens: estimatedPromptTokens,
+                                    exact: false,
+                                }
+                                : undefined;
                     const usage = tokenUsage
                         ? {
                             ...tokenUsage,
@@ -882,6 +1318,26 @@ export const kiroProvider = {
                                 charges: usageCharges,
                             }
                             : undefined;
+                    const reasoningResult = kiroReasoningResult({
+                        reasoning,
+                        provenance: createReasoningArtifactProvenance({
+                            provider: "kiro",
+                            model: upstream,
+                            dialect: "kiro-eventstream",
+                        }),
+                        hasToolCalls: toolCalls.length > 0,
+                    });
+                    for (const event of pendingStreamEvents) {
+                        if (event.kind === "token") {
+                            onToken(event.text);
+                        }
+                        else if (event.kind === "reasoning") {
+                            emitStreamReasoningDelta(request.onStreamEvent, event.text);
+                        }
+                        else {
+                            request.onToolCallDelta?.(event.delta);
+                        }
+                    }
                     return {
                         text: fullText,
                         provider: "kiro",
@@ -890,13 +1346,23 @@ export const kiroProvider = {
                         finishReason,
                         toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
                         usage,
-                        reasoningBlock: reasoningText.trim()
-                            ? { text: reasoningText.trim() }
+                        reasoningArtifacts: reasoningResult.artifacts.length > 0
+                            ? reasoningResult.artifacts
                             : undefined,
+                        reasoningBlock: reasoningResult.block,
                     };
                 }
                 catch (err) {
-                    if (err instanceof ProviderError && (err.status === 401 || err.status === 403 || err.status === 400)) {
+                    if (request.signal?.aborted) {
+                        completeGenerationAttempt("cancelled");
+                        throw err;
+                    }
+                    const status = err instanceof ProviderError ? err.status : undefined;
+                    completeGenerationAttempt("failure", undefined, status);
+                    if (err instanceof ProviderError &&
+                        (status === 400 ||
+                            status === undefined ||
+                            (status === 401 && Boolean(credential.refreshToken)))) {
                         throw err;
                     }
                     lastError = err instanceof Error ? err : new Error(String(err));