ns-kiro-core 0.1.2 → 0.2.0

package/dist/stream.js

@@ -1,94 +1,18 @@
 // ABOUTME: Core streaming integration for Kiro API requests and responses.
 // ABOUTME: Handles request building, retry logic, event parsing, and token counting.
-import { appendFile, mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { UniversalEventStreamMarshaller } from "@smithy/core/event-streams";
-import { KiroBlockBuffer } from "./blocks.js";
-import { parseBracketToolCalls } from "./bracket-tool-parser.js";
-import { calculateKiroCost } from "./cost.js";
-import { debugEnabled, debugLog, formatSafeError, redactSensitiveText } from "./debug.js";
-import { buildKiroAdditionalModelRequestFields, clampKiroEffort, getKiroEffortConfig, } from "./effort.js";
+import { debugLog, formatSafeError, redactSensitiveText } from "./debug.js";
+import { buildKiroAdditionalModelRequestFields, clampKiroEffort, getKiroEffortConfig } from "./effort.js";
 import { getKiroEndpoints } from "./endpoints.js";
-import { parseKiroEvent } from "./event-parser.js";
-import { addPlaceholderTools, assertHistoryWithinLimit, HISTORY_LIMIT, HISTORY_LIMIT_CONTEXT_WINDOW, prepareHistory, } from "./history.js";
-import { isKiroToolStructureRule, kiroConversationEntries, repairKiroConversation } from "./history-validator.js";
-import { parseInvokeToolCalls } from "./invoke-tool-parser.js";
 import { getKiroCliCredentials, getKiroCliCredentialsAllowExpired, refreshViaKiroCli } from "./kiro-cli.js";
 import { invalidateKiroProfileArn, KiroManagementHttpError, resetKiroProfileArnCache, resolveKiroProfileArn, } from "./management.js";
 import { isCacheStale, resolveKiroModel, updateKiroModelsCache } from "./models.js";
 import { kiroAuthHeaders } from "./oauth.js";
+import { buildKiroRequest } from "./request-builder.js";
+import { KiroResponseAssembler } from "./response-assembler.js";
+import { readKiroEventStream } from "./response-stream.js";
 import { capacityRetryConfig, exponentialBackoff, extractKiroReason, firstTokenTimeoutForModel, isCapacityError, isNonRetryableBodyError, isTooBigError, KIRO_REASON_CODES, MAX_RETRY_DELAY, resolveRequestRateRetryDelay, retryConfig, } from "./retry.js";
-import { ThinkingTagParser } from "./thinking-parser.js";
 import { kiroTokenTypeHeaders } from "./token-type.js";
-import { countTokens } from "./tokenizer.js";
-import { buildHistory, convertImagesToKiro, convertToolsToKiro, EMPTY_CONTENT_PLACEHOLDER, extractImages, getContentText, normalizeMessages, relocateDisplacedToolResults, sanitizeSurrogates, TOOL_RESULT_LIMIT, toKiroToolUseId, truncate, } from "./transform.js";
-import { TRUNCATION_NOTICE, wasPreviousResponseTruncated } from "./truncation.js";
-const CAPACITY_LOG_DIR = join(homedir(), ".ns-kiro-provider", "logs");
-const CAPACITY_LOG_FILE = join(CAPACITY_LOG_DIR, "capacity-retries.log");
-const eventStreamMarshaller = new UniversalEventStreamMarshaller({
-    utf8Encoder: (input) => new TextDecoder().decode(input),
-    utf8Decoder: (input) => new TextEncoder().encode(input),
-});
-let capacityLogDirCreated = false;
-function logCapacityEvent(message) {
-    // Fire-and-forget async logging to avoid blocking the event loop
-    (async () => {
-        try {
-            if (!capacityLogDirCreated) {
-                await mkdir(CAPACITY_LOG_DIR, { recursive: true });
-                capacityLogDirCreated = true;
-            }
-            await appendFile(CAPACITY_LOG_FILE, `${new Date().toISOString()} ${message}\n`);
-        }
-        catch {
-            // best-effort logging, don't break the provider
-        }
-    })();
-}
-/** Delay that rejects early if the abort signal fires. */
-function abortableDelay(ms, signal) {
-    if (signal?.aborted)
-        return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-        const onAbort = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", onAbort);
-            reject(signal?.reason);
-        };
-        const timer = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function createResponseHeaderDeadline(callerSignal, timeoutMs) {
-    const controller = new AbortController();
-    let timedOut = false;
-    const onCallerAbort = () => {
-        clearTimeout(timer);
-        callerSignal?.removeEventListener("abort", onCallerAbort);
-        controller.abort(callerSignal?.reason);
-    };
-    const timer = setTimeout(() => {
-        timedOut = true;
-        callerSignal?.removeEventListener("abort", onCallerAbort);
-        controller.abort(new DOMException("Kiro response headers timeout", "TimeoutError"));
-    }, timeoutMs);
-    if (callerSignal?.aborted)
-        onCallerAbort();
-    else
-        callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
-    return {
-        signal: controller.signal,
-        didTimeout: () => timedOut,
-        cleanup: () => {
-            clearTimeout(timer);
-            callerSignal?.removeEventListener("abort", onCallerAbort);
-        },
-    };
-}
+import { abortableDelay, createResponseHeaderDeadline, logCapacityEvent } from "./transport.js";
 let skipProfileResolutionForTests = false;
 const TEST_PROFILE_ARN = "arn:aws:codewhisperer:us-east-1:000000000000:profile/test";
 /** Reset profile resolution state — exported for stream tests. */
@@ -107,14 +31,6 @@ export function resetProfileArnCache(resolved = false) {
  */
 export async function* streamKiro(request) {
     const { model, signal } = request;
-    const pending = [];
-    const blocks = new KiroBlockBuffer((event) => pending.push(event));
-    const usage = {
-        input: 0,
-        output: 0,
-        totalTokens: 0,
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    };
     const initialAccessToken = request.accessToken;
     if (!initialAccessToken) {
         throw new Error("Kiro credentials not set. Run `kiro-cli login`, or set KIRO_API_KEY.");
@@ -174,225 +90,50 @@ export async function* streamKiro(request) {
         sessionId: request.sessionId,
     });
     let systemPrompt = request.systemPrompt ?? "";
-    // Kiro's runtime endpoint honors structured effort but only exposes Claude's
-    // user-visible thinking stream when the legacy thinking markers are also
-    // present. Keep both controls: structured fields select effort, while these
-    // markers preserve the <thinking> content consumed by ThinkingTagParser.
-    if (thinkingEnabled && effortConfig?.field !== "reasoning") {
+    // Legacy fallback for turning the thinking stream on, kept only where nothing
+    // better exists. When the request already carries the catalog's own `thinking`
+    // field, the markers are pure duplication: they restate in prose what the
+    // structured field states, and prepend an effort-dependent budget to the front
+    // of the system prompt for no gain.
+    //
+    // Verified 2026-09-06 against claude-sonnet-5 at effort `high`: dropping the
+    // markers left the thinking stream intact — one block, comparable length —
+    // in both arrangements.
+    //
+    // This does NOT buy back Kiro's server-side prompt cache. Measured the same
+    // day: a repeated prefix bills ~0.035 credits against ~0.066 for a fresh one,
+    // but changing effort misses even when the system prompt is byte-identical,
+    // and each effort then warms its own entry. The effort travels in
+    // `additionalModelRequestFields`, so it is part of the cache key no matter
+    // what the prompt says.
+    //
+    // Still emitted when Kiro offers no structured control: a model whose catalog
+    // entry carries no effort schema, or a Claude turn with no effort selected,
+    // has nothing else to switch thinking on with. Models keyed off `reasoning`
+    // (the GPT family) never wanted the markers at all.
+    const sendsThinkingField = !!additionalModelRequestFields && "thinking" in additionalModelRequestFields;
+    if (thinkingEnabled && effortConfig?.field !== "reasoning" && !sendsThinkingField) {
         const budget = effort === "xhigh" || effort === "max" ? 50000 : effort === "high" ? 30000 : effort === "medium" ? 20000 : 10000;
         systemPrompt = `<thinking_mode>enabled</thinking_mode><max_thinking_length>${budget}</max_thinking_length>${systemPrompt ? `\n${systemPrompt}` : ""}`;
     }
+    const assembler = new KiroResponseAssembler(model, thinkingEnabled);
     let retryCount = 0;
     const maxRetries = 3;
     const conversationId = request.sessionId ?? crypto.randomUUID();
     requestLoop: while (retryCount <= maxRetries) {
         if (signal?.aborted)
             throw signal.reason;
-        // Relocate a tool result that arrived behind a later assistant turn than
-        // the one that called it, before anything positional runs. Interleaved
-        // concurrent tool executions produce that shape, and `sanitizeHistory`
-        // pairs POSITIONALLY, so without this pass the displaced result's issuing
-        // assistant is dropped and the real tool output is discarded.
-        const normalized = relocateDisplacedToolResults(normalizeMessages(request.messages));
-        const { history: rawHistory, systemPrepended, currentMsgStartIdx, } = buildHistory(normalized, kiroModelId, systemPrompt);
-        // Preserve semantic context locally; the host owns lossy compaction.
-        const history = prepareHistory(rawHistory, model.input.includes("image"));
-        const dynamicHistoryLimit = Math.floor((model.contextWindow / HISTORY_LIMIT_CONTEXT_WINDOW) * HISTORY_LIMIT);
-        const currentMessages = normalized.slice(currentMsgStartIdx);
-        const firstMsg = currentMessages[0];
-        let currentContent = "";
-        const currentToolResults = [];
-        let currentImages;
-        if (firstMsg?.role === "assistant") {
-            let armContent = "";
-            const armToolUses = [];
-            for (const block of firstMsg.content) {
-                if (block.type === "text")
-                    armContent += block.text;
-                // Reasoning is deliberately NOT serialized into the assistant text
-                // channel, matching `buildHistory`. Flattening it to
-                // `<thinking>...</thinking>` writes literal markup into the string the
-                // model reads back as its own prior speech.
-                else if (block.type === "toolCall") {
-                    armToolUses.push({ name: block.name, toolUseId: toKiroToolUseId(block.id), input: block.arguments });
-                }
-            }
-            if (armContent || armToolUses.length > 0) {
-                const prevArm = history[history.length - 1]?.assistantResponseMessage;
-                if (history.length > 0 && !history[history.length - 1]?.userInputMessage && prevArm) {
-                    // Merge into previous assistant message to maintain alternation
-                    // without synthetic padding. Join only non-empty sides: a turn that
-                    // carried only reasoning or only a tool call leaves `armContent`
-                    // empty, and an unconditional separator would append a bare `\n\n`
-                    // onto text the model actually produced.
-                    prevArm.content =
-                        prevArm.content && armContent ? `${prevArm.content}\n\n${armContent}` : prevArm.content || armContent;
-                    if (armToolUses.length > 0)
-                        prevArm.toolUses = [...(prevArm.toolUses || []), ...armToolUses];
-                }
-                else {
-                    history.push({
-                        assistantResponseMessage: {
-                            content: armContent,
-                            ...(armToolUses.length > 0 ? { toolUses: armToolUses } : {}),
-                        },
-                    });
-                }
-            }
-            const toolResultImages = [];
-            for (let i = 1; i < currentMessages.length; i++) {
-                const m = currentMessages[i];
-                if (m?.role !== "toolResult")
-                    continue;
-                currentToolResults.push({
-                    content: [{ text: truncate(getContentText(m), TOOL_RESULT_LIMIT) }],
-                    status: m.isError ? "error" : "success",
-                    toolUseId: toKiroToolUseId(m.toolCallId),
-                });
-                toolResultImages.push(...extractImages(m));
-            }
-            if (toolResultImages.length > 0)
-                currentImages = convertImagesToKiro(toolResultImages);
-            // A tool turn carries its payload in `userInputMessageContext.toolResults`,
-            // so it needs no text. Leaving this empty also leaves the fallback below
-            // free to fill in only genuinely payload-less turns.
-            currentContent = "";
-        }
-        else if (firstMsg?.role === "toolResult") {
-            const toolResultImages = [];
-            for (const m of currentMessages) {
-                if (m.role !== "toolResult")
-                    continue;
-                currentToolResults.push({
-                    content: [{ text: truncate(getContentText(m), TOOL_RESULT_LIMIT) }],
-                    status: m.isError ? "error" : "success",
-                    toolUseId: toKiroToolUseId(m.toolCallId),
-                });
-                toolResultImages.push(...extractImages(m));
-            }
-            if (toolResultImages.length > 0)
-                currentImages = convertImagesToKiro(toolResultImages);
-            // Empty by design — `toolResults` is this turn's payload.
-            currentContent = "";
-        }
-        else if (firstMsg?.role === "user") {
-            currentContent = getContentText(firstMsg);
-            if (systemPrompt && !systemPrepended)
-                currentContent = `${systemPrompt}\n\n${currentContent}`;
-        }
-        // Current assistant tool calls are outbound history too, so enforce the
-        // budget only after they have been appended.
-        assertHistoryWithinLimit(history, dynamicHistoryLimit);
-        if (wasPreviousResponseTruncated(request.messages)) {
-            currentContent = currentContent === "" ? TRUNCATION_NOTICE : `${TRUNCATION_NOTICE}\n\n${currentContent}`;
-        }
-        // Always synthesize placeholder specs for tool names referenced in history,
-        // even when the caller declares none. Without this, a call that inherits a
-        // tool-rich conversation but declares no current tools is rejected by Kiro
-        // as "Improperly formed request", because history references toolUses with
-        // no tool catalog.
-        let uimc;
-        const baseTools = request.tools?.length ? convertToolsToKiro(request.tools) : [];
-        const finalTools = history.length > 0 ? addPlaceholderTools(baseTools, history) : baseTools;
-        if (currentToolResults.length > 0 || finalTools.length > 0) {
-            uimc = {};
-            if (currentToolResults.length > 0)
-                uimc.toolResults = currentToolResults;
-            if (finalTools.length > 0)
-                uimc.tools = finalTools;
-        }
-        if (firstMsg?.role === "user") {
-            const imgs = extractImages(firstMsg);
-            if (imgs.length > 0)
-                currentImages = convertImagesToKiro(imgs);
-        }
-        // A turn with neither text nor tool results has no payload at all: an
-        // image-only user message, or an empty-text one. Send a neutral prompt so
-        // its attachments still reach the model.
-        //
-        // The `currentToolResults` guard is load-bearing. Without it this line
-        // refills every tool turn that deliberately left `currentContent` empty.
-        // Kiro's rule is content **or** tool results — see EMPTY_CONTENT_PLACEHOLDER.
-        if (currentContent === "" && currentToolResults.length === 0)
-            currentContent = EMPTY_CONTENT_PLACEHOLDER;
-        // Pre-send REPAIR against the rules first-party Kiro Agent enforces.
-        // `prepareHistory` covers the shapes this provider itself produces, but not
-        // every shape a caller can hand us: `sanitizeHistory` tests tool pairing by
-        // POSITION, so an assistant entry with `toolUses` survives whenever the next
-        // entry carries any `toolResults` at all, matching ids or not, and
-        // `injectSyntheticToolCalls` only rescues orphaned RESULTS. A mismatched
-        // pair — both partners present, paired with each other's counterpart —
-        // passes both passes untouched and is rejected on the wire with
-        // `400 TOOL_USE_RESULT_MISMATCH`.
-        //
-        // Repair runs on the WHOLE conversation and is split back afterwards.
-        // Repairing `history` alone would be wrong in the ordinary case: its last
-        // entry is normally the assistant whose `toolUses` this very request
-        // answers, so rule 4 would synthesize a FAILED result for a call whose real
-        // output is sitting in the current message.
-        const conversationEntries = kiroConversationEntries(history, {
-            content: currentContent,
-            modelId: kiroModelId,
-            origin: "KIRO_CLI",
-            ...(uimc ? { userInputMessageContext: uimc } : {}),
-        });
-        const repair = repairKiroConversation(conversationEntries);
-        if (repair.diagnostics.length > 0) {
-            debugLog("request.invariants", { errors: repair.diagnostics, remaining: repair.remaining });
-        }
-        // Split back. Repair keeps the current message last in every case but total
-        // collapse, where a conversation that is *only* a bare tool-result carrier
-        // has no valid opening entry and step 1 consumes it.
-        const repairedCurrent = repair.entries[repair.entries.length - 1]?.userInputMessage;
-        // Read the repaired context EXACTLY, including when repair removed it. A
-        // `?? uimc` fallback would undo the repair in the one case that matters
-        // most: stripping every orphaned tool result leaves a turn with no context
-        // at all, and falling back would put the orphans — the shape the backend
-        // rejects — straight back onto the wire.
-        let wireHistory;
-        let wireContent;
-        let wireUimc;
-        if (repairedCurrent) {
-            wireHistory = repair.entries.slice(0, -1);
-            wireContent = repairedCurrent.content;
-            wireUimc = repairedCurrent.userInputMessageContext;
-        }
-        else {
-            // Collapsed. Apply what repair would have applied to a lone carrier: drop
-            // the results that answer nothing, keep any tool catalog, and give the
-            // empty turn the neutral prompt.
-            wireHistory = [];
-            wireContent = currentContent || EMPTY_CONTENT_PLACEHOLDER;
-            wireUimc = uimc?.tools?.length ? { tools: uimc.tools } : undefined;
-        }
-        if (repair.remaining.length > 0) {
-            const structural = repair.remaining.filter((e) => isKiroToolStructureRule(e.rule));
-            if (structural.length > 0) {
-                console.warn(`[kiro-core] outbound history still violates ${structural
-                    .map((e) => `${e.rule}@${e.index}`)
-                    .join(", ")} after repair — Kiro may reject this request`);
-            }
-        }
-        const kiroRequest = {
-            conversationState: {
-                chatTriggerType: "MANUAL",
-                agentTaskType: "vibe",
-                conversationId,
-                currentMessage: {
-                    userInputMessage: {
-                        content: sanitizeSurrogates(wireContent),
-                        modelId: kiroModelId,
-                        origin: "KIRO_CLI",
-                        ...(currentImages ? { images: currentImages } : {}),
-                        ...(wireUimc ? { userInputMessageContext: wireUimc } : {}),
-                    },
-                },
-                ...(wireHistory.length > 0 ? { history: wireHistory } : {}),
-            },
-            ...(additionalModelRequestFields ? { additionalModelRequestFields } : {}),
+        const built = buildKiroRequest({
+            messages: request.messages,
+            model,
+            kiroModelId,
+            systemPrompt,
+            tools: request.tools,
+            conversationId,
             profileArn,
-            agentMode: "vibe",
-        };
+            ...(additionalModelRequestFields ? { additionalModelRequestFields } : {}),
+        });
+        const kiroRequest = built.request;
         let response;
         // Reset per outer iteration — each 403 retry gets a fresh capacity budget.
         let capacityRetryCount = 0;
@@ -405,10 +146,10 @@ export async function* streamKiro(request) {
                 capacityAttempt: capacityRetryCount,
                 // Wire values, not pre-repair ones: this line is what a reader
                 // correlates against a 400, so it must describe the bytes actually sent.
-                historyLen: wireHistory.length,
-                currentContentLen: wireContent.length,
-                hasImages: !!currentImages,
-                toolResultCount: wireUimc?.toolResults?.length ?? 0,
+                historyLen: built.wireHistoryLength,
+                currentContentLen: built.wireContentLength,
+                hasImages: built.hasImages,
+                toolResultCount: built.toolResultCount,
                 request: kiroRequest,
             });
             const responseHeaderDeadline = createResponseHeaderDeadline(signal, retryConfig.requestHeaderTimeoutMs);
@@ -547,288 +288,28 @@ export async function* streamKiro(request) {
         yield { type: "start" };
         if (!response.body)
             throw new Error("No response body");
-        const bodyReader = response.body.getReader();
-        let totalContent = "";
-        let lastContentData = "";
-        let usageEvent = null;
-        let receivedContextUsage = false;
-        const thinkingParser = thinkingEnabled ? new ThinkingTagParser(blocks) : null;
-        let nativeThinkingBlockIndex = null;
-        let nativeThinkingEnded = false;
-        const ensureNativeThinkingBlock = () => {
-            if (nativeThinkingBlockIndex === null)
-                nativeThinkingBlockIndex = blocks.openThinking();
-            return nativeThinkingBlockIndex;
-        };
-        const endNativeThinking = (signature) => {
-            if (nativeThinkingBlockIndex === null || nativeThinkingEnded)
-                return;
-            nativeThinkingEnded = true;
-            blocks.endThinking(nativeThinkingBlockIndex, signature);
-        };
-        let textBlockIndex = null;
-        let emittedToolCalls = 0;
-        let sawAnyToolCalls = false;
-        let currentToolCall = null;
-        const emitToolCall = (state) => {
-            if (!state.input.trim()) {
-                // Kiro omits the input payload when the model calls a tool with no
-                // arguments (e.g. `mcp({})`). Treat empty input as an empty object
-                // rather than skipping — these are valid zero-arg calls, not truncations.
-                state.input = "{}";
-            }
-            let args;
-            try {
-                args = JSON.parse(state.input);
-            }
-            catch (e) {
-                console.warn(`[kiro-core] Failed to parse tool input for "${state.name}" (toolUseId: ${state.toolUseId}): ${formatSafeError(e)}. Raw input (${state.input.length} chars): ${redactSensitiveText(state.input.substring(0, 200))}`);
-                return false;
-            }
-            const index = blocks.reserve();
-            pending.push({ type: "tool_call_start", index, id: state.toolUseId, name: state.name });
-            pending.push({ type: "tool_call_delta", index, id: state.toolUseId, argumentsDelta: state.input });
-            pending.push({ type: "tool_call_end", index, id: state.toolUseId, name: state.name, arguments: args });
-            return true;
-        };
-        const flushToolCall = () => {
-            if (!currentToolCall)
-                return;
-            if (emitToolCall(currentToolCall))
-                emittedToolCalls++;
-            currentToolCall = null;
-        };
-        const IDLE_TIMEOUT = 300_000;
-        let idleTimer = null;
-        let idleCancelled = false;
-        const resetIdle = () => {
-            if (idleTimer)
-                clearTimeout(idleTimer);
-            idleTimer = setTimeout(() => {
-                idleCancelled = true;
-                void bodyReader.cancel().catch(() => { });
-            }, IDLE_TIMEOUT);
-        };
-        let gotFirstToken = false;
-        let firstTokenTimedOut = false;
-        let streamError = null;
-        const FIRST_TOKEN_SENTINEL = Symbol("firstTokenTimeout");
-        // Smithy's marshaller handles chunk reassembly, CRC validation, protocol
-        // error/exception detection, and payload deserialization.
-        const bodyIterable = {
-            async *[Symbol.asyncIterator]() {
-                try {
-                    while (true) {
-                        const { done, value } = await bodyReader.read();
-                        if (done)
-                            return;
-                        yield value;
-                    }
-                }
-                finally {
-                    bodyReader.releaseLock();
-                }
-            },
-        };
-        const utf8Decoder = new TextDecoder();
-        const eventStream = eventStreamMarshaller.deserialize(bodyIterable, async (event) => {
-            const entry = Object.entries(event)[0];
-            if (!entry)
-                throw new Error("Received an empty event stream message");
-            const [key, msg] = entry;
-            const parsed = JSON.parse(utf8Decoder.decode(msg.body));
-            return { [key]: parsed };
+        assembler.beginAttempt();
+        const { frames, outcome } = readKiroEventStream(response.body, {
+            firstTokenTimeoutMs: model.firstTokenTimeout ?? firstTokenTimeoutForModel(model.id),
         });
-        const iterator = eventStream[Symbol.asyncIterator]();
-        while (true) {
-            let iterResult;
-            try {
-                if (!gotFirstToken) {
-                    const readPromise = iterator.next();
-                    const result = await Promise.race([
-                        readPromise,
-                        new Promise((resolve) => setTimeout(() => resolve(FIRST_TOKEN_SENTINEL), model.firstTokenTimeout ?? firstTokenTimeoutForModel(model.id))),
-                    ]);
-                    if (result === FIRST_TOKEN_SENTINEL) {
-                        readPromise.catch(() => { }); // suppress dangling rejection
-                        void bodyReader.cancel().catch(() => { });
-                        firstTokenTimedOut = true;
-                        break;
-                    }
-                    iterResult = result;
-                    gotFirstToken = true;
-                    resetIdle();
-                }
-                else {
-                    iterResult = await iterator.next();
-                }
-            }
-            catch (e) {
-                // Smithy throws on `:message-type` error/exception headers.
-                streamError =
-                    e instanceof Error
-                        ? e.message
-                        : (typeof e === "object" && e !== null ? JSON.stringify(e) : String(e)) || "Unknown stream error";
-                break;
-            }
-            const { done, value } = iterResult;
-            if (done)
-                break;
-            resetIdle();
-            const eventPayload = Object.values(value)[0];
-            const event = parseKiroEvent(eventPayload);
-            if (!event)
-                continue;
-            if (debugEnabled())
-                debugLog("stream.events", [event]);
-            switch (event.type) {
-                case "contextUsage": {
-                    const pct = event.data.contextUsagePercentage;
-                    usage.input = Math.round((pct / 100) * model.contextWindow);
-                    usage.contextPercent = pct;
-                    receivedContextUsage = true;
-                    break;
-                }
-                case "thinkingText": {
-                    if (!thinkingEnabled)
-                        break;
-                    blocks.appendThinking(ensureNativeThinkingBlock(), event.data);
-                    totalContent += event.data;
-                    break;
-                }
-                case "thinkingSignature": {
-                    if (!thinkingEnabled)
-                        break;
-                    ensureNativeThinkingBlock();
-                    endNativeThinking(event.data);
-                    break;
-                }
-                case "content": {
-                    endNativeThinking();
-                    if (event.data === lastContentData)
-                        continue;
-                    lastContentData = event.data;
-                    totalContent += event.data;
-                    if (thinkingParser) {
-                        thinkingParser.processChunk(event.data);
-                    }
-                    else {
-                        if (textBlockIndex === null)
-                            textBlockIndex = blocks.openText();
-                        blocks.appendText(textBlockIndex, event.data);
-                    }
-                    break;
-                }
-                case "toolUse": {
-                    const tc = event.data;
-                    sawAnyToolCalls = true;
-                    if (!currentToolCall || currentToolCall.toolUseId !== tc.toolUseId) {
-                        flushToolCall();
-                        currentToolCall = { toolUseId: tc.toolUseId, name: tc.name, input: "" };
-                    }
-                    currentToolCall.input += tc.input || "";
-                    if (tc.input)
-                        totalContent += tc.input;
-                    if (tc.stop)
-                        flushToolCall();
-                    break;
-                }
-                case "toolUseInput": {
-                    if (currentToolCall)
-                        currentToolCall.input += event.data.input || "";
-                    if (event.data.input)
-                        totalContent += event.data.input;
-                    break;
-                }
-                case "toolUseStop": {
-                    if (event.data.stop)
-                        flushToolCall();
-                    break;
-                }
-                case "usage": {
-                    usageEvent = event.data;
-                    break;
-                }
-                case "error": {
-                    streamError = event.data.message ? `${event.data.error}: ${event.data.message}` : event.data.error;
-                    void bodyReader.cancel().catch(() => { });
-                    break;
-                }
-                // followupPrompt events are intentionally ignored
-            }
-            yield* drain(pending);
-            if (streamError)
-                break;
+        for await (const frame of frames) {
+            assembler.handle(frame);
+            yield* assembler.takeEvents();
         }
-        yield* drain(pending);
-        if (idleTimer)
-            clearTimeout(idleTimer);
-        if (firstTokenTimedOut || idleCancelled || streamError) {
+        yield* assembler.takeEvents();
+        if (outcome.firstTokenTimedOut || outcome.idleTimedOut || outcome.error) {
             // Timed out or received an error mid-stream: retry with backoff.
             if (retryCount < maxRetries) {
                 retryCount++;
                 await abortableDelay(exponentialBackoff(retryCount - 1, 1000, MAX_RETRY_DELAY), signal);
                 continue;
             }
-            if (streamError)
-                throw new Error(`Kiro API stream error after max retries: ${streamError}`);
-            throw new Error(`Kiro API error: ${firstTokenTimedOut ? "first token" : "idle"} timeout after max retries`);
-        }
-        if (currentToolCall && emitToolCall(currentToolCall))
-            emittedToolCalls++;
-        currentToolCall = null;
-        endNativeThinking();
-        if (thinkingParser) {
-            thinkingParser.finalize();
-            textBlockIndex = thinkingParser.getTextBlockIndex();
-        }
-        yield* drain(pending);
-        // Fallback: extract text-dialect tool calls from content if no native tool
-        // calls arrived. Two dialects are recovered at this seam:
-        //   1. Kiro's own `[Called name with args: {...}]` bracket form.
-        //   2. Anthropic's `<invoke name="..."><parameter .../></invoke>` XML form,
-        //      which opus-class models emit as plain text at high context.
-        // Without this, the turn ends `stop` with zero tool calls — the agent loop
-        // sees a finished answer and an unattended session stalls with no error
-        // recorded anywhere.
-        //
-        // Models that emit native tool-use events opt out via
-        // `recoverTextToolCalls: false`. For them this pass has nothing to rescue
-        // and everything to break: prose that merely *quotes* the syntax — a model
-        // explaining how a tool is called — would be lifted into a real call the
-        // model never made. Absent means recover, so a model the catalog says
-        // nothing about keeps the fallback.
-        if (model.recoverTextToolCalls !== false && !sawAnyToolCalls && textBlockIndex !== null) {
-            let text = blocks.getText(textBlockIndex);
-            const recovered = [];
-            const bracketResult = parseBracketToolCalls(text);
-            if (bracketResult.toolCalls.length > 0) {
-                text = bracketResult.cleanedText;
-                recovered.push(...bracketResult.toolCalls);
-            }
-            const invokeResult = parseInvokeToolCalls(text);
-            if (invokeResult.toolCalls.length > 0) {
-                text = invokeResult.cleanedText;
-                recovered.push(...invokeResult.toolCalls);
-            }
-            if (recovered.length > 0) {
-                blocks.setText(textBlockIndex, text);
-                sawAnyToolCalls = true;
-                for (const call of recovered) {
-                    if (emitToolCall({ toolUseId: call.toolUseId, name: call.name, input: JSON.stringify(call.arguments) })) {
-                        emittedToolCalls++;
-                    }
-                }
-            }
-        }
-        // Strip echo noise: when tool calls are present and the text content is just
-        // "." or a similar short echo from history padding, remove it. This prevents
-        // the echo from accumulating in conversation history and reinforcing the
-        // pattern in future turns.
-        if (emittedToolCalls > 0 && textBlockIndex !== null) {
-            if (/^\s*(\.+|continue)\s*$/i.test(blocks.getText(textBlockIndex)))
-                blocks.setText(textBlockIndex, "");
+            if (outcome.error)
+                throw new Error(`Kiro API stream error after max retries: ${outcome.error}`);
+            throw new Error(`Kiro API error: ${outcome.firstTokenTimedOut ? "first token" : "idle"} timeout after max retries`);
         }
+        const summary = assembler.endTurn();
+        yield* assembler.takeEvents();
         // Detect degenerate responses: the API returned 200 but produced no usable
         // content at all — no text and no tool calls. This happens when the stream
         // is truncated early or only a contextUsage event arrives.
@@ -839,67 +320,37 @@ export async function* streamKiro(request) {
         // When tool calls *were* present but all got dropped (empty/unparseable
         // input), don't retry — the API did respond, it just sent malformed tool
         // calls. Retrying would likely produce the same result.
-        const responseText = textBlockIndex === null ? "" : blocks.getText(textBlockIndex);
-        const hasText = responseText.length > 0;
-        const isEchoLoop = hasText && !sawAnyToolCalls && /^\s*(continue|\.+)\s*$/i.test(responseText);
-        if ((!hasText && !sawAnyToolCalls) || isEchoLoop) {
+        if (summary.isEmpty || summary.isEchoLoop) {
             // Retrying an echo loop means unsaying text already delivered, which only
             // a host that can discard emitted blocks may do. Elsewhere, go straight to
             // the terminal behaviour: strip the echo so the agent loop does not read
             // "Continue" as a continuation signal.
-            const mayRetry = retryCount < maxRetries && (!isEchoLoop || request.canDiscardEmittedBlocks === true);
+            const mayRetry = retryCount < maxRetries && (!summary.isEchoLoop || request.canDiscardEmittedBlocks === true);
             if (mayRetry) {
                 retryCount++;
-                console.warn(`[kiro-core] ${isEchoLoop ? 'Echo loop detected (model responded with just "Continue")' : "Empty response (no text, no tool calls)"} — retrying (${retryCount}/${maxRetries})`);
-                blocks.reset();
-                textBlockIndex = null;
-                yield* drain(pending);
+                console.warn(`[kiro-core] ${summary.isEchoLoop ? 'Echo loop detected (model responded with just "Continue")' : "Empty response (no text, no tool calls)"} — retrying (${retryCount}/${maxRetries})`);
+                assembler.discard();
+                yield* assembler.takeEvents();
                 await abortableDelay(exponentialBackoff(retryCount - 1, 1000, MAX_RETRY_DELAY), signal);
                 continue;
             }
-            if (isEchoLoop && textBlockIndex !== null) {
-                blocks.setText(textBlockIndex, "");
+            if (summary.isEchoLoop) {
+                assembler.stripEcho();
                 console.warn(`[kiro-core] Echo loop — stripping "Continue" response`);
             }
-            else if (!hasText && !sawAnyToolCalls) {
-                console.warn(`[kiro-core] Empty response after ${maxRetries} retries — reporting a normal stop`);
+            else {
+                // The stop reason is still decided below, and an empty turn that never
+                // carried a contextUsage frame is reported as `length` rather than
+                // `stop` — say so, instead of promising a normal stop this branch does
+                // not actually guarantee.
+                console.warn(`[kiro-core] Empty response after ${maxRetries} retries — giving up on this turn`);
             }
         }
-        if (textBlockIndex !== null)
-            blocks.endText(textBlockIndex);
-        // Kiro does not reliably emit per-response output token counts. When the
-        // `usage` event is missing or reports only `inputTokens`, fall back to a
-        // tiktoken estimate over everything the assistant emitted — text plus
-        // tool-call input JSON. Otherwise tool-call-only turns report 0 output
-        // tokens and break consumers that watch it.
-        if (usageEvent?.inputTokens !== undefined)
-            usage.input = usageEvent.inputTokens;
-        usage.output = usageEvent?.outputTokens ?? countTokens(totalContent);
-        usage.totalTokens = usage.input + usage.output;
-        usage.cost = calculateKiroCost(model.cost, usage);
-        // Use `emittedToolCalls`, not the count seen on the wire: a turn whose calls
-        // were all dropped for unparseable input must not report `toolUse`, because
-        // an empty turn with a tool-use stop stalls an agent loop waiting for
-        // results that will never arrive.
-        const stopReason = !receivedContextUsage && emittedToolCalls === 0 ? "length" : emittedToolCalls > 0 ? "toolUse" : "stop";
-        yield* drain(pending);
+        const { stopReason, usage } = assembler.complete();
+        yield* assembler.takeEvents();
         yield { type: "usage", usage };
         yield { type: "done", stopReason };
-        debugLog("response.done", {
-            stopReason,
-            emittedToolCalls,
-            sawAnyToolCalls,
-            textLen: responseText.length,
-            usage,
-        });
         return;
     }
 }
-function* drain(pending) {
-    while (pending.length > 0) {
-        const event = pending.shift();
-        if (event)
-            yield event;
-    }
-}
 //# sourceMappingURL=stream.js.map