@sunerpy/opencode-kiro-auth 0.6.2 → 0.7.0

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;
                 }
                 {

package/dist/plugin/sync/kiro-cli.js

@@ -65,7 +65,6 @@ export async function syncFromKiroCli() {
                 let usedCount = 0;
                 let limitCount = 0;
                 let email;
-                let usageOk = false;
                 try {
                     const authForUsage = {
                         refresh: '',
@@ -83,7 +82,6 @@ export async function syncFromKiroCli() {
                     limitCount = u.limitCount || 0;
                     if (typeof u.email === 'string' && u.email) {
                         email = u.email;
-                        usageOk = true;
                     }
                 }
                 catch (e) {

package/dist/plugin.d.ts

@@ -1,3 +1,5 @@
+import { KeepAliveController } from './core/auth/token-keepalive.js';
+export declare function __getActiveKeepAliveControllerForTest(): KeepAliveController | null;
 export declare const createKiroPlugin: (id: string) => ({ client, directory }: any) => Promise<{
     config: (input: any) => Promise<void>;
     auth: {

package/dist/plugin.js

@@ -1,5 +1,6 @@
 import { KIRO_CONSTANTS } from './constants.js';
 import { AuthHandler } from './core/auth/auth-handler.js';
+import { KeepAliveController } from './core/auth/token-keepalive.js';
 import { RequestHandler } from './core/request/request-handler.js';
 import { AccountCache } from './infrastructure/database/account-cache.js';
 import { AccountRepository } from './infrastructure/database/account-repository.js';
@@ -7,6 +8,31 @@ import { AccountManager } from './plugin/accounts.js';
 import { bootstrapAuthIfNeeded } from './plugin/auth-bootstrap.js';
 import { loadConfig } from './plugin/config/index.js';
 const KIRO_PROVIDER_ID = 'kiro-auth';
+let activeKeepAliveController = null;
+let keepAliveTeardownRegistered = false;
+function disposeActiveKeepAliveController() {
+    activeKeepAliveController?.dispose();
+    activeKeepAliveController = null;
+}
+function registerKeepAliveTeardown() {
+    if (keepAliveTeardownRegistered) {
+        return;
+    }
+    keepAliveTeardownRegistered = true;
+    process.once('beforeExit', disposeActiveKeepAliveController);
+    process.once('SIGTERM', disposeActiveKeepAliveController);
+}
+function installKeepAliveController(controller, enabled) {
+    disposeActiveKeepAliveController();
+    activeKeepAliveController = controller;
+    if (enabled) {
+        registerKeepAliveTeardown();
+    }
+    controller.start();
+}
+export function __getActiveKeepAliveControllerForTest() {
+    return activeKeepAliveController;
+}
 export const createKiroPlugin = (id) => async ({ client, directory }) => {
     const config = loadConfig(directory);
     const showToast = (message, variant) => {
@@ -21,6 +47,7 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
     });
     authHandler.setAccountManager(accountManager);
     const requestHandler = new RequestHandler(accountManager, config, repository, client);
+    installKeepAliveController(new KeepAliveController(config, accountManager, requestHandler.sharedTokenRefresher, repository), config.token_keepalive_enabled);
     // Compute the base URL once so both the config hook and auth loader use the same value
     const baseURL = KIRO_CONSTANTS.BASE_URL.replace('/generateAssistantResponse', '').replace('{{region}}', config.default_region || 'us-east-1');
     return {
@@ -251,7 +278,7 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                     normalized[modelID] = {
                         ...modelInfo,
                         api: {
-                            ...(modelInfo.api || {}),
+                            ...modelInfo.api,
                             npm: '@ai-sdk/openai-compatible',
                             // Ensure url is always set. modelInfo.api.url should already be
                             // populated from the config hook's provider.api field, but we

package/package.json

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