@sunerpy/opencode-kiro-auth 0.6.2 → 0.8.0

package/dist/plugin/storage/sqlite.js

@@ -39,7 +39,15 @@ export class KiroDatabase {
         runMigrations(this.db);
     }
     getAccounts() {
-        return this.db.prepare('SELECT * FROM accounts').all();
+        return this.db
+            .prepare(`
+          SELECT accounts.*
+          FROM accounts
+          WHERE NOT EXISTS (
+            SELECT 1 FROM removed_accounts WHERE removed_accounts.id = accounts.id
+          )
+        `)
+            .all();
     }
     upsertAccountInternal(acc) {
         this.db
@@ -62,14 +70,22 @@ export class KiroDatabase {
     `)
             .run(acc.id, acc.email, acc.authMethod, acc.region, acc.oidcRegion || null, acc.clientId || null, acc.clientSecret || null, acc.profileArn || null, acc.startUrl || null, acc.refreshToken, acc.accessToken, acc.expiresAt, acc.rateLimitResetTime || 0, acc.isHealthy ? 1 : 0, acc.unhealthyReason || null, acc.recoveryTime || null, acc.failCount || 0, acc.lastUsed || 0, acc.usedCount || 0, acc.limitCount || 0, acc.lastSync || 0);
     }
+    isRemovedSync(id) {
+        return !!this.db.prepare('SELECT id FROM removed_accounts WHERE id = ?').get(id);
+    }
+    purgeRemovedAccountsSync() {
+        this.db.prepare('DELETE FROM accounts WHERE id IN (SELECT id FROM removed_accounts)').run();
+    }
     async upsertAccount(acc) {
         await withDatabaseLock(this.path, async () => {
             const existing = this.getAccounts().map(this.rowToAccount);
             const merged = mergeAccounts(existing, [acc]);
             const deduplicated = deduplicateAccounts(merged);
+            const writable = deduplicated.filter((a) => !this.isRemovedSync(a.id));
             this.db.exec('BEGIN TRANSACTION');
             try {
-                for (const account of deduplicated) {
+                this.purgeRemovedAccountsSync();
+                for (const account of writable) {
                     this.upsertAccountInternal(account);
                 }
                 this.db.exec('COMMIT');
@@ -85,9 +101,11 @@ export class KiroDatabase {
             const existing = this.getAccounts().map(this.rowToAccount);
             const merged = mergeAccounts(existing, accounts);
             const deduplicated = deduplicateAccounts(merged);
+            const writable = deduplicated.filter((a) => !this.isRemovedSync(a.id));
             this.db.exec('BEGIN TRANSACTION');
             try {
-                for (const account of deduplicated) {
+                this.purgeRemovedAccountsSync();
+                for (const account of writable) {
                     this.upsertAccountInternal(account);
                 }
                 this.db.exec('COMMIT');
@@ -103,6 +121,50 @@ export class KiroDatabase {
             this.db.prepare('DELETE FROM accounts WHERE id = ?').run(id);
         });
     }
+    async removeAccountWithTombstone(id) {
+        await withDatabaseLock(this.path, async () => {
+            this.db.exec('BEGIN TRANSACTION');
+            try {
+                this.db.prepare('DELETE FROM accounts WHERE id = ?').run(id);
+                this.db
+                    .prepare('INSERT OR REPLACE INTO removed_accounts (id, removed_at) VALUES (?, ?)')
+                    .run(id, Date.now());
+                this.db.exec('COMMIT');
+            }
+            catch (e) {
+                this.db.exec('ROLLBACK');
+                throw e;
+            }
+        });
+    }
+    async cleanupSupersededIdentities(keepId, email, authMethod, profileArn) {
+        const supersededIds = [];
+        await withDatabaseLock(this.path, async () => {
+            this.db.exec('BEGIN TRANSACTION');
+            try {
+                const rows = this.db
+                    .prepare('SELECT id FROM accounts WHERE email = ? AND auth_method = ? AND profile_arn IS ? AND id != ?')
+                    .all(email, authMethod, profileArn ?? null, keepId);
+                for (const row of rows) {
+                    if (typeof row === 'object' && row !== null && 'id' in row && typeof row.id === 'string')
+                        supersededIds.push(row.id);
+                }
+                const deleteStmt = this.db.prepare('DELETE FROM accounts WHERE id = ?');
+                const tombstoneStmt = this.db.prepare('INSERT OR REPLACE INTO removed_accounts (id, removed_at) VALUES (?, ?)');
+                const removedAt = Date.now();
+                for (const id of supersededIds) {
+                    deleteStmt.run(id);
+                    tombstoneStmt.run(id, removedAt);
+                }
+                this.db.exec('COMMIT');
+            }
+            catch (e) {
+                this.db.exec('ROLLBACK');
+                throw e;
+            }
+        });
+        return supersededIds;
+    }
     async addRemovedAccount(id) {
         await withDatabaseLock(this.path, async () => {
             this.db

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

@@ -17,7 +17,6 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
         nextBlockIndex: 0,
         stoppedBlocks: new Set()
     };
-    let totalContent = '';
     let textOnlyContent = '';
     let outputTokens = 0;
     let inputTokens = 0;
@@ -46,297 +45,287 @@ export async function* transformSdkStream(sdkResponse, model, conversationId) {
     if (!eventStream) {
         throw new Error('SDK response has no event stream');
     }
-    try {
-        for await (const event of eventStream) {
-            if (event.reasoningContentEvent?.text) {
-                const reasoningText = event.reasoningContentEvent.text;
-                if (reasoningClosed) {
-                    // Defensive, normally unreached (probe: reasoning is contiguous-before-text).
-                    // The stopped thinking index cannot be reused, so open a fresh one.
-                    streamState.thinkingBlockIndex = null;
-                    reasoningClosed = false;
-                }
-                reasoningStarted = true;
-                for (const ev of createThinkingDeltaEvents(reasoningText, streamState)) {
+    for await (const event of eventStream) {
+        if (event.reasoningContentEvent?.text) {
+            const reasoningText = event.reasoningContentEvent.text;
+            if (reasoningClosed) {
+                // Defensive, normally unreached (probe: reasoning is contiguous-before-text).
+                // The stopped thinking index cannot be reused, so open a fresh one.
+                streamState.thinkingBlockIndex = null;
+                reasoningClosed = false;
+            }
+            reasoningStarted = true;
+            for (const ev of createThinkingDeltaEvents(reasoningText, streamState)) {
+                const _c = convertToOpenAI(ev, conversationId, model);
+                if (_c !== null)
+                    yield _c;
+            }
+            continue;
+        }
+        if (event.assistantResponseEvent?.content) {
+            const text = event.assistantResponseEvent.content;
+            textOnlyContent += text;
+            if (reasoningStarted && !reasoningClosed) {
+                for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
                     const _c = convertToOpenAI(ev, conversationId, model);
                     if (_c !== null)
                         yield _c;
                 }
-                continue;
+                reasoningClosed = true;
             }
-            if (event.assistantResponseEvent?.content) {
-                const text = event.assistantResponseEvent.content;
-                totalContent += text;
-                textOnlyContent += text;
-                if (reasoningStarted && !reasoningClosed) {
-                    for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
-                        const _c = convertToOpenAI(ev, conversationId, model);
-                        if (_c !== null)
-                            yield _c;
-                    }
-                    reasoningClosed = true;
+            if (reasoningStarted) {
+                for (const ev of createTextDeltaEvents(text, streamState)) {
+                    const _c = toChunk(ev);
+                    if (_c !== null)
+                        yield _c;
                 }
-                if (reasoningStarted) {
-                    for (const ev of createTextDeltaEvents(text, streamState)) {
+                continue;
+            }
+            if (!thinkingRequested) {
+                for (const ev of createTextDeltaEvents(text, streamState)) {
+                    {
                         const _c = toChunk(ev);
                         if (_c !== null)
                             yield _c;
                     }
-                    continue;
                 }
-                if (!thinkingRequested) {
-                    for (const ev of createTextDeltaEvents(text, streamState)) {
-                        {
-                            const _c = toChunk(ev);
-                            if (_c !== null)
-                                yield _c;
+                continue;
+            }
+            streamState.buffer += text;
+            const deltaEvents = [];
+            while (streamState.buffer.length > 0) {
+                if (!streamState.inThinking && !streamState.thinkingExtracted) {
+                    const startPos = findRealTag(streamState.buffer, THINKING_START_TAG);
+                    if (startPos !== -1) {
+                        const before = streamState.buffer.slice(0, startPos);
+                        if (before) {
+                            deltaEvents.push(...createTextDeltaEvents(before, streamState));
                         }
+                        streamState.buffer = streamState.buffer.slice(startPos + THINKING_START_TAG.length);
+                        streamState.inThinking = true;
+                        continue;
                     }
-                    continue;
-                }
-                streamState.buffer += text;
-                const deltaEvents = [];
-                while (streamState.buffer.length > 0) {
-                    if (!streamState.inThinking && !streamState.thinkingExtracted) {
-                        const startPos = findRealTag(streamState.buffer, THINKING_START_TAG);
-                        if (startPos !== -1) {
-                            const before = streamState.buffer.slice(0, startPos);
-                            if (before) {
-                                deltaEvents.push(...createTextDeltaEvents(before, streamState));
-                            }
-                            streamState.buffer = streamState.buffer.slice(startPos + THINKING_START_TAG.length);
-                            streamState.inThinking = true;
-                            continue;
-                        }
-                        const safeLen = Math.max(0, streamState.buffer.length - THINKING_START_TAG.length);
-                        if (safeLen > 0) {
-                            const safeText = streamState.buffer.slice(0, safeLen);
-                            if (safeText) {
-                                deltaEvents.push(...createTextDeltaEvents(safeText, streamState));
-                            }
-                            streamState.buffer = streamState.buffer.slice(safeLen);
+                    const safeLen = Math.max(0, streamState.buffer.length - THINKING_START_TAG.length);
+                    if (safeLen > 0) {
+                        const safeText = streamState.buffer.slice(0, safeLen);
+                        if (safeText) {
+                            deltaEvents.push(...createTextDeltaEvents(safeText, streamState));
                         }
-                        break;
+                        streamState.buffer = streamState.buffer.slice(safeLen);
                     }
-                    if (streamState.inThinking) {
-                        const endPos = findRealTag(streamState.buffer, THINKING_END_TAG);
-                        if (endPos !== -1) {
-                            const thinkingPart = streamState.buffer.slice(0, endPos);
-                            if (thinkingPart) {
-                                deltaEvents.push(...createThinkingDeltaEvents(thinkingPart, streamState));
-                            }
-                            streamState.buffer = streamState.buffer.slice(endPos + THINKING_END_TAG.length);
-                            streamState.inThinking = false;
-                            streamState.thinkingExtracted = true;
-                            deltaEvents.push(...createThinkingDeltaEvents('', streamState));
-                            deltaEvents.push(...stopBlock(streamState.thinkingBlockIndex, streamState));
-                            if (streamState.buffer.startsWith('\n\n')) {
-                                streamState.buffer = streamState.buffer.slice(2);
-                            }
-                            continue;
+                    break;
+                }
+                if (streamState.inThinking) {
+                    const endPos = findRealTag(streamState.buffer, THINKING_END_TAG);
+                    if (endPos !== -1) {
+                        const thinkingPart = streamState.buffer.slice(0, endPos);
+                        if (thinkingPart) {
+                            deltaEvents.push(...createThinkingDeltaEvents(thinkingPart, streamState));
                         }
-                        const safeLen = Math.max(0, streamState.buffer.length - THINKING_END_TAG.length);
-                        if (safeLen > 0) {
-                            const safeThinking = streamState.buffer.slice(0, safeLen);
-                            if (safeThinking) {
-                                deltaEvents.push(...createThinkingDeltaEvents(safeThinking, streamState));
-                            }
-                            streamState.buffer = streamState.buffer.slice(safeLen);
+                        streamState.buffer = streamState.buffer.slice(endPos + THINKING_END_TAG.length);
+                        streamState.inThinking = false;
+                        streamState.thinkingExtracted = true;
+                        deltaEvents.push(...createThinkingDeltaEvents('', streamState));
+                        deltaEvents.push(...stopBlock(streamState.thinkingBlockIndex, streamState));
+                        if (streamState.buffer.startsWith('\n\n')) {
+                            streamState.buffer = streamState.buffer.slice(2);
                         }
-                        break;
+                        continue;
                     }
-                    if (streamState.thinkingExtracted) {
-                        const rest = streamState.buffer;
-                        streamState.buffer = '';
-                        if (rest) {
-                            deltaEvents.push(...createTextDeltaEvents(rest, streamState));
+                    const safeLen = Math.max(0, streamState.buffer.length - THINKING_END_TAG.length);
+                    if (safeLen > 0) {
+                        const safeThinking = streamState.buffer.slice(0, safeLen);
+                        if (safeThinking) {
+                            deltaEvents.push(...createThinkingDeltaEvents(safeThinking, streamState));
                         }
-                        break;
+                        streamState.buffer = streamState.buffer.slice(safeLen);
                     }
+                    break;
                 }
-                for (const ev of deltaEvents) {
-                    const chunk = toChunk(ev);
-                    if (chunk !== null)
-                        yield chunk;
+                if (streamState.thinkingExtracted) {
+                    const rest = streamState.buffer;
+                    streamState.buffer = '';
+                    if (rest) {
+                        deltaEvents.push(...createTextDeltaEvents(rest, streamState));
+                    }
+                    break;
                 }
             }
-            else if (event.toolUseEvent) {
-                const tc = event.toolUseEvent;
-                if (tc.name)
-                    totalContent += tc.name;
-                if (tc.input)
-                    totalContent += tc.input;
-                if (tc.name && tc.toolUseId) {
-                    if (currentToolCall && currentToolCall.toolUseId === tc.toolUseId) {
-                        currentToolCall.input += tc.input || '';
-                    }
-                    else {
-                        if (currentToolCall)
-                            toolCalls.push(currentToolCall);
-                        currentToolCall = {
-                            toolUseId: tc.toolUseId,
-                            name: tc.name,
-                            input: tc.input || ''
-                        };
-                    }
-                    if (tc.stop && currentToolCall) {
+            for (const ev of deltaEvents) {
+                const chunk = toChunk(ev);
+                if (chunk !== null)
+                    yield chunk;
+            }
+        }
+        else if (event.toolUseEvent) {
+            const tc = event.toolUseEvent;
+            if (tc.name && tc.toolUseId) {
+                if (currentToolCall && currentToolCall.toolUseId === tc.toolUseId) {
+                    currentToolCall.input += tc.input || '';
+                }
+                else {
+                    if (currentToolCall)
                         toolCalls.push(currentToolCall);
-                        currentToolCall = null;
-                    }
+                    currentToolCall = {
+                        toolUseId: tc.toolUseId,
+                        name: tc.name,
+                        input: tc.input || ''
+                    };
                 }
-            }
-            else if (event.metadataEvent) {
-                if (event.metadataEvent.contextUsagePercentage) {
-                    contextUsagePercentage = event.metadataEvent.contextUsagePercentage;
+                if (tc.stop && currentToolCall) {
+                    toolCalls.push(currentToolCall);
+                    currentToolCall = null;
                 }
             }
-            else if (event.contextUsageEvent) {
-                const cue = event.contextUsageEvent;
-                if (cue.contextUsagePercentage) {
-                    contextUsagePercentage = cue.contextUsagePercentage;
-                }
+        }
+        else if (event.metadataEvent) {
+            if (event.metadataEvent.contextUsagePercentage) {
+                contextUsagePercentage = event.metadataEvent.contextUsagePercentage;
             }
         }
-        if (currentToolCall) {
-            toolCalls.push(currentToolCall);
-            currentToolCall = null;
+        else if (event.contextUsageEvent) {
+            const cue = event.contextUsageEvent;
+            if (cue.contextUsagePercentage) {
+                contextUsagePercentage = cue.contextUsagePercentage;
+            }
         }
-        // Reasoning-only responses (reasoning but no reply text): close the thinking block.
-        if (reasoningStarted && !reasoningClosed) {
-            for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
+    }
+    if (currentToolCall) {
+        toolCalls.push(currentToolCall);
+        currentToolCall = null;
+    }
+    // Reasoning-only responses (reasoning but no reply text): close the thinking block.
+    if (reasoningStarted && !reasoningClosed) {
+        for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
+            const _c = convertToOpenAI(ev, conversationId, model);
+            if (_c !== null)
+                yield _c;
+        }
+        reasoningClosed = true;
+    }
+    if (thinkingRequested && streamState.buffer) {
+        if (streamState.inThinking) {
+            for (const ev of createThinkingDeltaEvents(streamState.buffer, streamState)) {
                 const _c = convertToOpenAI(ev, conversationId, model);
                 if (_c !== null)
                     yield _c;
             }
-            reasoningClosed = true;
-        }
-        if (thinkingRequested && streamState.buffer) {
-            if (streamState.inThinking) {
-                for (const ev of createThinkingDeltaEvents(streamState.buffer, streamState)) {
-                    const _c = convertToOpenAI(ev, conversationId, model);
-                    if (_c !== null)
-                        yield _c;
-                }
-                streamState.buffer = '';
-                for (const ev of createThinkingDeltaEvents('', streamState)) {
-                    const _c = convertToOpenAI(ev, conversationId, model);
-                    if (_c !== null)
-                        yield _c;
-                }
-                for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
-                    const _c = convertToOpenAI(ev, conversationId, model);
-                    if (_c !== null)
-                        yield _c;
-                }
+            streamState.buffer = '';
+            for (const ev of createThinkingDeltaEvents('', streamState)) {
+                const _c = convertToOpenAI(ev, conversationId, model);
+                if (_c !== null)
+                    yield _c;
             }
-            else {
-                for (const ev of createTextDeltaEvents(streamState.buffer, streamState)) {
-                    const _c = toChunk(ev);
-                    if (_c !== null)
-                        yield _c;
-                }
-                streamState.buffer = '';
+            for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
+                const _c = convertToOpenAI(ev, conversationId, model);
+                if (_c !== null)
+                    yield _c;
             }
         }
-        const { toolCalls: dialectToolCalls, remainderText } = dialectGate.finalize();
-        if (remainderText) {
-            for (const ev of createTextDeltaEvents(remainderText, streamState)) {
-                const _c = convertToOpenAI(ev, conversationId, model);
+        else {
+            for (const ev of createTextDeltaEvents(streamState.buffer, streamState)) {
+                const _c = toChunk(ev);
                 if (_c !== null)
                     yield _c;
             }
+            streamState.buffer = '';
         }
-        for (const ev of stopBlock(streamState.textBlockIndex, streamState)) {
+    }
+    const { toolCalls: dialectToolCalls, remainderText } = dialectGate.finalize();
+    if (remainderText) {
+        for (const ev of createTextDeltaEvents(remainderText, streamState)) {
             const _c = convertToOpenAI(ev, conversationId, model);
             if (_c !== null)
                 yield _c;
         }
-        if (dialectToolCalls.length > 0) {
-            for (const btc of dialectToolCalls) {
-                toolCalls.push({
-                    toolUseId: btc.toolUseId,
-                    name: btc.name,
-                    input: typeof btc.input === 'string' ? btc.input : JSON.stringify(btc.input)
-                });
-            }
+    }
+    for (const ev of stopBlock(streamState.textBlockIndex, streamState)) {
+        const _c = convertToOpenAI(ev, conversationId, model);
+        if (_c !== null)
+            yield _c;
+    }
+    if (dialectToolCalls.length > 0) {
+        for (const btc of dialectToolCalls) {
+            toolCalls.push({
+                toolUseId: btc.toolUseId,
+                name: btc.name,
+                input: typeof btc.input === 'string' ? btc.input : JSON.stringify(btc.input)
+            });
         }
-        if (toolCalls.length > 0) {
-            // OpenAI tool_calls[].index must be the tool call's own 0-based ordinal,
-            // NOT the Anthropic content_block global index (offset by reasoning/text
-            // blocks) — a global index misaligns the AI-SDK accumulator and drops the call.
-            for (let i = 0; i < toolCalls.length; i++) {
-                const tc = toolCalls[i];
-                if (!tc)
-                    continue;
-                const blockIndex = i;
-                {
-                    const _c = convertToOpenAI({
-                        type: 'content_block_start',
-                        index: blockIndex,
-                        content_block: {
-                            type: 'tool_use',
-                            id: tc.toolUseId,
-                            name: tc.name,
-                            input: {}
-                        }
-                    }, conversationId, model);
-                    if (_c !== null)
-                        yield _c;
-                }
-                let inputJson;
-                try {
-                    const parsed = JSON.parse(tc.input);
-                    inputJson = JSON.stringify(parsed);
-                }
-                catch (e) {
-                    inputJson = tc.input;
-                }
-                {
-                    const _c = convertToOpenAI({
-                        type: 'content_block_delta',
-                        index: blockIndex,
-                        delta: {
-                            type: 'input_json_delta',
-                            partial_json: inputJson
-                        }
-                    }, conversationId, model);
-                    if (_c !== null)
-                        yield _c;
-                }
-                {
-                    const _c = convertToOpenAI({ type: 'content_block_stop', index: blockIndex }, conversationId, model);
-                    if (_c !== null)
-                        yield _c;
-                }
+    }
+    if (toolCalls.length > 0) {
+        // OpenAI tool_calls[].index must be the tool call's own 0-based ordinal,
+        // NOT the Anthropic content_block global index (offset by reasoning/text
+        // blocks) — a global index misaligns the AI-SDK accumulator and drops the call.
+        for (let i = 0; i < toolCalls.length; i++) {
+            const tc = toolCalls[i];
+            if (!tc)
+                continue;
+            const blockIndex = i;
+            {
+                const _c = convertToOpenAI({
+                    type: 'content_block_start',
+                    index: blockIndex,
+                    content_block: {
+                        type: 'tool_use',
+                        id: tc.toolUseId,
+                        name: tc.name,
+                        input: {}
+                    }
+                }, conversationId, model);
+                if (_c !== null)
+                    yield _c;
+            }
+            let inputJson;
+            try {
+                const parsed = JSON.parse(tc.input);
+                inputJson = JSON.stringify(parsed);
+            }
+            catch {
+                inputJson = tc.input;
+            }
+            {
+                const _c = convertToOpenAI({
+                    type: 'content_block_delta',
+                    index: blockIndex,
+                    delta: {
+                        type: 'input_json_delta',
+                        partial_json: inputJson
+                    }
+                }, conversationId, model);
+                if (_c !== null)
+                    yield _c;
+            }
+            {
+                const _c = convertToOpenAI({ type: 'content_block_stop', index: blockIndex }, conversationId, model);
+                if (_c !== null)
+                    yield _c;
             }
         }
-        outputTokens = estimateTokens(textOnlyContent);
-        if (contextUsagePercentage !== null && contextUsagePercentage > 0) {
-            const contextWindow = getContextWindowSize(model);
-            const totalTokens = Math.round((contextWindow * contextUsagePercentage) / 100);
-            inputTokens = Math.max(0, totalTokens - outputTokens);
-        }
-        {
-            const _c = convertToOpenAI({
-                type: 'message_delta',
-                delta: { stop_reason: toolCalls.length > 0 ? 'tool_use' : 'end_turn' },
-                usage: {
-                    input_tokens: inputTokens,
-                    output_tokens: outputTokens,
-                    cache_creation_input_tokens: 0,
-                    cache_read_input_tokens: 0
-                }
-            }, conversationId, model);
-            if (_c !== null)
-                yield _c;
-        }
-        {
-            const _c = convertToOpenAI({ type: 'message_stop' }, conversationId, model);
-            if (_c !== null)
-                yield _c;
-        }
     }
-    catch (e) {
-        throw e;
+    outputTokens = estimateTokens(textOnlyContent);
+    if (contextUsagePercentage !== null && contextUsagePercentage > 0) {
+        const contextWindow = getContextWindowSize(model);
+        const totalTokens = Math.round((contextWindow * contextUsagePercentage) / 100);
+        inputTokens = Math.max(0, totalTokens - outputTokens);
+    }
+    {
+        const _c = convertToOpenAI({
+            type: 'message_delta',
+            delta: { stop_reason: toolCalls.length > 0 ? 'tool_use' : 'end_turn' },
+            usage: {
+                input_tokens: inputTokens,
+                output_tokens: outputTokens,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 0
+            }
+        }, conversationId, model);
+        if (_c !== null)
+            yield _c;
+    }
+    {
+        const _c = convertToOpenAI({ type: 'message_stop' }, conversationId, model);
+        if (_c !== null)
+            yield _c;
     }
 }

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

@@ -243,7 +243,7 @@ export async function* transformKiroStream(response, model, conversationId) {
                     const parsed = JSON.parse(tc.input);
                     inputJson = JSON.stringify(parsed);
                 }
-                catch (e) {
+                catch {
                     inputJson = tc.input;
                 }
                 {