@zhafron/opencode-kiro-auth 1.0.0 → 1.1.0

package/README.md

@@ -1,4 +1,4 @@
-# @zhafron/opencode-kiro-auth
+# OpenCode Kiro Auth Plugin
 
 OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to the latest Claude 3.5/4.5 models with substantial trial quotas.
 

package/dist/constants.js

@@ -56,5 +56,11 @@ export const KIRO_AUTH_SERVICE = {
     ENDPOINT: 'https://prod.{{region}}.auth.desktop.kiro.dev',
     SSO_OIDC_ENDPOINT: 'https://oidc.{{region}}.amazonaws.com',
     BUILDER_ID_START_URL: 'https://view.awsapps.com/start',
-    SCOPES: ['codewhisperer:completions', 'codewhisperer:analysis', 'codewhisperer:conversations', 'codewhisperer:transformations', 'codewhisperer:taskassist']
+    SCOPES: [
+        'codewhisperer:completions',
+        'codewhisperer:analysis',
+        'codewhisperer:conversations',
+        'codewhisperer:transformations',
+        'codewhisperer:taskassist'
+    ]
 };

package/dist/kiro/oauth-idc.js

@@ -120,7 +120,10 @@ export async function pollKiroIDCToken(clientId, clientSecret, deviceCode, inter
             }
         }
         catch (error) {
-            if (error instanceof Error && (error.message.includes('expired') || error.message.includes('denied') || error.message.includes('failed'))) {
+            if (error instanceof Error &&
+                (error.message.includes('expired') ||
+                    error.message.includes('denied') ||
+                    error.message.includes('failed'))) {
                 throw error;
             }
             if (attempts >= maxAttempts) {

package/dist/plugin/accounts.js

@@ -28,7 +28,10 @@ export class AccountManager {
     static async loadFromDisk(strategy) {
         const s = await loadAccounts();
         const u = await loadUsage();
-        const accounts = s.accounts.map((m) => ({ ...m, region: m.region || KIRO_CONSTANTS.DEFAULT_REGION }));
+        const accounts = s.accounts.map((m) => ({
+            ...m,
+            region: m.region || KIRO_CONSTANTS.DEFAULT_REGION
+        }));
         return new AccountManager(accounts, u.usage, strategy || 'sticky');
     }
     getAccountCount() {
@@ -140,7 +143,13 @@ export class AccountManager {
         await saveUsage({ version: 1, usage: this.usage });
     }
     toAuthDetails(a) {
-        const p = { refreshToken: a.refreshToken, profileArn: a.profileArn, clientId: a.clientId, clientSecret: a.clientSecret, authMethod: a.authMethod };
+        const p = {
+            refreshToken: a.refreshToken,
+            profileArn: a.profileArn,
+            clientId: a.clientId,
+            clientSecret: a.clientSecret,
+            authMethod: a.authMethod
+        };
         return {
             refresh: encodeRefreshToken(p),
             access: a.accessToken,

package/dist/plugin/auth-page.js

@@ -1,5 +1,10 @@
 function escapeHtml(text) {
-    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#039;');
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
 }
 export function getIDCAuthHtml(verificationUrl, userCode, statusUrl) {
     const escapedUrl = escapeHtml(verificationUrl);

package/dist/plugin/config/loader.js

@@ -95,7 +95,9 @@ function applyEnvOverrides(config) {
         account_selection_strategy: env.KIRO_ACCOUNT_SELECTION_STRATEGY
             ? AccountSelectionStrategySchema.catch('lowest-usage').parse(env.KIRO_ACCOUNT_SELECTION_STRATEGY)
             : config.account_selection_strategy,
-        default_region: env.KIRO_DEFAULT_REGION ? RegionSchema.catch('us-east-1').parse(env.KIRO_DEFAULT_REGION) : config.default_region,
+        default_region: env.KIRO_DEFAULT_REGION
+            ? RegionSchema.catch('us-east-1').parse(env.KIRO_DEFAULT_REGION)
+            : config.default_region,
         rate_limit_retry_delay_ms: parseNumberEnv(env.KIRO_RATE_LIMIT_RETRY_DELAY_MS, config.rate_limit_retry_delay_ms),
         rate_limit_max_retries: parseNumberEnv(env.KIRO_RATE_LIMIT_MAX_RETRIES, config.rate_limit_max_retries),
         usage_tracking_enabled: parseBooleanEnv(env.KIRO_USAGE_TRACKING_ENABLED, config.usage_tracking_enabled)

package/dist/plugin/logger.js

@@ -3,7 +3,9 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 const getLogDir = () => {
     const platform = process.platform;
-    const base = platform === 'win32' ? join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'opencode') : join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'opencode');
+    const base = platform === 'win32'
+        ? join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'opencode')
+        : join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'opencode');
     return join(base, 'kiro-logs');
 };
 const writeToFile = (level, message, ...args) => {
@@ -18,20 +20,16 @@ const writeToFile = (level, message, ...args) => {
     catch (e) { }
 };
 export function log(message, ...args) {
-    console.log(`[${new Date().toISOString()}] ${message}`, ...args);
     writeToFile('INFO', message, ...args);
 }
 export function error(message, ...args) {
-    console.error(`[${new Date().toISOString()}] ERROR: ${message}`, ...args);
     writeToFile('ERROR', message, ...args);
 }
 export function warn(message, ...args) {
-    console.warn(`[${new Date().toISOString()}] WARN: ${message}`, ...args);
     writeToFile('WARN', message, ...args);
 }
 export function debug(message, ...args) {
     if (process.env.DEBUG) {
-        console.debug(`[${new Date().toISOString()}] DEBUG: ${message}`, ...args);
         writeToFile('DEBUG', message, ...args);
     }
 }

package/dist/plugin/request.js

@@ -1,14 +1,14 @@
 import * as crypto from 'crypto';
 import * as os from 'os';
-import { KIRO_CONSTANTS } from '../constants';
-import { resolveKiroModel } from './models';
+import { KIRO_CONSTANTS } from '../constants.js';
+import { resolveKiroModel } from './models.js';
 export function transformToCodeWhisperer(url, body, model, auth, think = false, budget = 20000) {
     const req = typeof body === 'string' ? JSON.parse(body) : body;
-    const { messages, tools, system } = req;
+    const { messages, tools, system, conversationId } = req;
+    const convId = crypto.randomUUID();
     if (!messages || messages.length === 0)
         throw new Error('No messages');
     const resolved = resolveKiroModel(model);
-    const convId = crypto.randomUUID();
     let sys = system || '';
     if (think) {
         const pfx = `<thinking_mode>enabled</thinking_mode><max_thinking_length>${budget}</max_thinking_length>`;
@@ -20,17 +20,38 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
         msgs.pop();
     const cwTools = tools ? convertToolsToCodeWhisperer(tools) : [];
     const history = [];
-    let start = 0;
+    let firstUserIndex = -1;
+    for (let i = 0; i < msgs.length; i++) {
+        if (msgs[i].role === 'user') {
+            firstUserIndex = i;
+            break;
+        }
+    }
     if (sys) {
-        const first = msgs[0];
-        if (first && first.role === 'user') {
-            history.push({ userInputMessage: { content: `${sys}\n\n${getContentText(first)}`, modelId: resolved, origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR } });
-            start = 1;
+        if (firstUserIndex !== -1) {
+            const m = msgs[firstUserIndex];
+            const oldContent = getContentText(m);
+            if (Array.isArray(m.content)) {
+                m.content = [
+                    { type: 'text', text: `${sys}\n\n${oldContent}` },
+                    ...m.content.filter((p) => p.type !== 'text')
+                ];
+            }
+            else {
+                m.content = `${sys}\n\n${oldContent}`;
+            }
+        }
+        else {
+            history.push({
+                userInputMessage: {
+                    content: sys,
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+                }
+            });
         }
-        else
-            history.push({ userInputMessage: { content: sys, modelId: resolved, origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR } });
     }
-    for (let i = start; i < msgs.length - 1; i++) {
+    for (let i = 0; i < msgs.length - 1; i++) {
         const m = msgs[i];
         if (!m)
             continue;
@@ -42,9 +63,16 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                     if (p.type === 'text')
                         uim.content += p.text || '';
                     else if (p.type === 'tool_result')
-                        trs.push({ content: [{ text: getContentText(p) }], status: 'success', toolUseId: p.tool_use_id });
+                        trs.push({
+                            content: [{ text: getContentText(p.content || p) }],
+                            status: 'success',
+                            toolUseId: p.tool_use_id
+                        });
                     else if (p.type === 'image' && p.source)
-                        imgs.push({ format: p.source.media_type?.split('/')[1] || 'png', source: { bytes: p.source.data } });
+                        imgs.push({
+                            format: p.source.media_type?.split('/')[1] || 'png',
+                            source: { bytes: p.source.data }
+                        });
                 }
             }
             else
@@ -53,11 +81,34 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                 uim.images = imgs;
             if (trs.length)
                 uim.userInputMessageContext = { toolResults: deduplicateToolResults(trs) };
-            const prev = history[history.length - 1];
-            if (prev && prev.userInputMessage)
-                history.push({ assistantResponseMessage: { content: 'Continue' } });
             history.push({ userInputMessage: uim });
         }
+        else if (m.role === 'tool') {
+            const trs = [];
+            if (m.tool_results) {
+                for (const tr of m.tool_results)
+                    trs.push({
+                        content: [{ text: getContentText(tr) }],
+                        status: 'success',
+                        toolUseId: tr.tool_call_id
+                    });
+            }
+            else {
+                trs.push({
+                    content: [{ text: getContentText(m) }],
+                    status: 'success',
+                    toolUseId: m.tool_call_id
+                });
+            }
+            history.push({
+                userInputMessage: {
+                    content: 'Tool results provided.',
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR,
+                    userInputMessageContext: { toolResults: deduplicateToolResults(trs) }
+                }
+            });
+        }
         else if (m.role === 'assistant') {
             const arm = { content: '' };
             const tus = [];
@@ -72,15 +123,26 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
                         tus.push({ input: p.input, name: p.name, toolUseId: p.id });
                 }
             }
-            else
+            else {
                 arm.content = getContentText(m);
+            }
+            if (m.tool_calls && Array.isArray(m.tool_calls)) {
+                for (const tc of m.tool_calls) {
+                    tus.push({
+                        input: typeof tc.function?.arguments === 'string'
+                            ? JSON.parse(tc.function.arguments)
+                            : tc.function?.arguments,
+                        name: tc.function?.name,
+                        toolUseId: tc.id
+                    });
+                }
+            }
             if (th)
-                arm.content = arm.content ? `<thinking>${th}</thinking>\n\n${arm.content}` : `<thinking>${th}</thinking>`;
+                arm.content = arm.content
+                    ? `<thinking>${th}</thinking>\n\n${arm.content}`
+                    : `<thinking>${th}</thinking>`;
             if (tus.length)
                 arm.toolUses = tus;
-            const prev = history[history.length - 1];
-            if (prev && prev.assistantResponseMessage)
-                history.push({ userInputMessage: { content: 'Continue', modelId: resolved, origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR } });
             history.push({ assistantResponseMessage: arm });
         }
     }
@@ -107,8 +169,23 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
         }
         else
             arm.content = getContentText(curMsg);
+        if (curMsg.tool_calls && Array.isArray(curMsg.tool_calls)) {
+            if (!arm.toolUses)
+                arm.toolUses = [];
+            for (const tc of curMsg.tool_calls) {
+                arm.toolUses.push({
+                    input: typeof tc.function?.arguments === 'string'
+                        ? JSON.parse(tc.function.arguments)
+                        : tc.function?.arguments,
+                    name: tc.function?.name,
+                    toolUseId: tc.id
+                });
+            }
+        }
         if (th)
-            arm.content = arm.content ? `<thinking>${th}</thinking>\n\n${arm.content}` : `<thinking>${th}</thinking>`;
+            arm.content = arm.content
+                ? `<thinking>${th}</thinking>\n\n${arm.content}`
+                : `<thinking>${th}</thinking>`;
         history.push({ assistantResponseMessage: arm });
         curContent = 'Continue';
     }
@@ -116,14 +193,38 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
         const prev = history[history.length - 1];
         if (prev && !prev.assistantResponseMessage)
             history.push({ assistantResponseMessage: { content: 'Continue' } });
-        if (Array.isArray(curMsg.content)) {
+        if (curMsg.role === 'tool') {
+            if (curMsg.tool_results) {
+                for (const tr of curMsg.tool_results)
+                    curTrs.push({
+                        content: [{ text: getContentText(tr) }],
+                        status: 'success',
+                        toolUseId: tr.tool_call_id
+                    });
+            }
+            else {
+                curTrs.push({
+                    content: [{ text: getContentText(curMsg) }],
+                    status: 'success',
+                    toolUseId: curMsg.tool_call_id
+                });
+            }
+        }
+        else if (Array.isArray(curMsg.content)) {
             for (const p of curMsg.content) {
                 if (p.type === 'text')
                     curContent += p.text || '';
                 else if (p.type === 'tool_result')
-                    curTrs.push({ content: [{ text: getContentText(p) }], status: 'success', toolUseId: p.tool_use_id });
+                    curTrs.push({
+                        content: [{ text: getContentText(p.content || p) }],
+                        status: 'success',
+                        toolUseId: p.tool_use_id
+                    });
                 else if (p.type === 'image' && p.source)
-                    curImgs.push({ format: p.source.media_type?.split('/')[1] || 'png', source: { bytes: p.source.data } });
+                    curImgs.push({
+                        format: p.source.media_type?.split('/')[1] || 'png',
+                        source: { bytes: p.source.data }
+                    });
             }
         }
         else
@@ -135,10 +236,19 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
         conversationState: {
             chatTriggerType: KIRO_CONSTANTS.CHAT_TRIGGER_TYPE_MANUAL,
             conversationId: convId,
-            history,
-            currentMessage: { userInputMessage: { content: curContent, modelId: resolved, origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR } }
+            currentMessage: {
+                userInputMessage: {
+                    content: curContent,
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+                }
+            }
         }
     };
+    if (history.length > 0) {
+        ;
+        request.conversationState.history = history;
+    }
     const uim = request.conversationState.currentMessage.userInputMessage;
     if (uim) {
         if (curImgs.length)
@@ -196,6 +306,16 @@ export function mergeAdjacentMessages(msgs) {
                     last.content.push({ type: 'text', text: m.content });
                 else if (typeof last.content === 'string' && Array.isArray(m.content))
                     last.content = [{ type: 'text', text: last.content }, ...m.content];
+                if (m.tool_calls) {
+                    if (!last.tool_calls)
+                        last.tool_calls = [];
+                    last.tool_calls.push(...m.tool_calls);
+                }
+                if (m.role === 'tool') {
+                    if (!last.tool_results)
+                        last.tool_results = [{ content: last.content, tool_call_id: last.tool_call_id }];
+                    last.tool_results.push({ content: m.content, tool_call_id: m.tool_call_id });
+                }
             }
             else
                 merged.push({ ...m });

package/dist/plugin/response.js

@@ -76,7 +76,7 @@ function parseEventStreamChunk(rawText) {
         };
     });
     if (contextUsagePercentage !== undefined) {
-        const totalTokens = Math.round((200000 * contextUsagePercentage) / 100);
+        const totalTokens = Math.round((172500 * contextUsagePercentage) / 100);
         outputTokens = estimateTokens(content);
         inputTokens = Math.max(0, totalTokens - outputTokens);
     }
@@ -99,7 +99,14 @@ function parseAwsEventStreamBuffer(buffer) {
         const inputStart = remaining.indexOf('{"input":', searchStart);
         const stopStart = remaining.indexOf('{"stop":', searchStart);
         const contextUsageStart = remaining.indexOf('{"contextUsagePercentage":', searchStart);
-        const candidates = [contentStart, nameStart, followupStart, inputStart, stopStart, contextUsageStart].filter((pos) => pos >= 0);
+        const candidates = [
+            contentStart,
+            nameStart,
+            followupStart,
+            inputStart,
+            stopStart,
+            contextUsageStart
+        ].filter((pos) => pos >= 0);
         if (candidates.length === 0)
             break;
         const jsonStart = Math.min(...candidates);

package/dist/plugin/server.js

@@ -25,16 +25,29 @@ export function startIDCAuthServer(authData, port = 19847) {
                     client_id: authData.clientId,
                     client_secret: authData.clientSecret
                 });
-                const res = await fetch(`https://oidc.${authData.region}.amazonaws.com/token`, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: body.toString() });
+                const res = await fetch(`https://oidc.${authData.region}.amazonaws.com/token`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: body.toString()
+                });
                 const d = await res.json();
                 if (res.ok) {
                     const acc = d.access_token, ref = d.refresh_token, exp = Date.now() + d.expires_in * 1000;
-                    const infoRes = await fetch('https://view.awsapps.com/api/user/info', { headers: { Authorization: `Bearer ${acc}` } });
+                    const infoRes = await fetch('https://view.awsapps.com/api/user/info', {
+                        headers: { Authorization: `Bearer ${acc}` }
+                    });
                     const info = await infoRes.json();
                     const email = info.email || info.userName || 'builder-id@aws.amazon.com';
                     status.status = 'success';
                     if (resolver)
-                        resolver({ email, accessToken: acc, refreshToken: ref, expiresAt: exp, clientId: authData.clientId, clientSecret: authData.clientSecret });
+                        resolver({
+                            email,
+                            accessToken: acc,
+                            refreshToken: ref,
+                            expiresAt: exp,
+                            clientId: authData.clientId,
+                            clientSecret: authData.clientSecret
+                        });
                     setTimeout(cleanup, 2000);
                 }
                 else if (d.error === 'authorization_pending')

package/dist/plugin/streaming.js

@@ -224,7 +224,7 @@ export async function* transformKiroStream(response, model, conversationId) {
         }
         outputTokens = estimateTokens(totalContent);
         if (contextUsagePercentage !== null && contextUsagePercentage > 0) {
-            const totalTokens = Math.round((200000 * contextUsagePercentage) / 100);
+            const totalTokens = Math.round((172500 * contextUsagePercentage) / 100);
             inputTokens = Math.max(0, totalTokens - outputTokens);
         }
         yield convertToOpenAI({
@@ -322,7 +322,14 @@ function parseStreamBuffer(buffer) {
         const inputStart = remaining.indexOf('{"input":', searchStart);
         const stopStart = remaining.indexOf('{"stop":', searchStart);
         const contextUsageStart = remaining.indexOf('{"contextUsagePercentage":', searchStart);
-        const candidates = [contentStart, nameStart, followupStart, inputStart, stopStart, contextUsageStart].filter((pos) => pos >= 0);
+        const candidates = [
+            contentStart,
+            nameStart,
+            followupStart,
+            inputStart,
+            stopStart,
+            contextUsageStart
+        ].filter((pos) => pos >= 0);
         if (candidates.length === 0)
             break;
         const jsonStart = Math.min(...candidates);

package/dist/plugin/types.d.ts

@@ -113,7 +113,7 @@ export interface CodeWhispererRequest {
     conversationState: {
         chatTriggerType: string;
         conversationId: string;
-        history: CodeWhispererMessage[];
+        history?: CodeWhispererMessage[];
         currentMessage: CodeWhispererMessage;
     };
     profileArn?: string;

package/dist/plugin/usage.js

@@ -3,7 +3,12 @@ export async function fetchUsageLimits(auth) {
     try {
         const res = await fetch(url, {
             method: 'GET',
-            headers: { Authorization: `Bearer ${auth.access}`, 'Content-Type': 'application/json', 'x-amzn-kiro-agent-mode': 'vibe', 'amz-sdk-request': 'attempt=1; max=1' }
+            headers: {
+                Authorization: `Bearer ${auth.access}`,
+                'Content-Type': 'application/json',
+                'x-amzn-kiro-agent-mode': 'vibe',
+                'amz-sdk-request': 'attempt=1; max=1'
+            }
         });
         if (!res.ok)
             throw new Error(`Status: ${res.status}`);
@@ -26,7 +31,11 @@ export async function fetchUsageLimits(auth) {
     }
 }
 export function updateAccountQuota(account, usage, accountManager) {
-    const meta = { usedCount: usage.usedCount || 0, limitCount: usage.limitCount || 0, realEmail: usage.email };
+    const meta = {
+        usedCount: usage.usedCount || 0,
+        limitCount: usage.limitCount || 0,
+        realEmail: usage.email
+    };
     account.usedCount = meta.usedCount;
     account.limitCount = meta.limitCount;
     if (meta.realEmail)

package/dist/plugin.js

@@ -104,16 +104,31 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                                         object: 'chat.completion',
                                         created: Math.floor(Date.now() / 1000),
                                         model,
-                                        choices: [{ index: 0, message: { role: 'assistant', content: p.content }, finish_reason: p.stopReason === 'tool_use' ? 'tool_calls' : 'stop' }],
-                                        usage: { prompt_tokens: p.inputTokens || 0, completion_tokens: p.outputTokens || 0, total_tokens: (p.inputTokens || 0) + (p.outputTokens || 0) }
+                                        choices: [
+                                            {
+                                                index: 0,
+                                                message: { role: 'assistant', content: p.content },
+                                                finish_reason: p.stopReason === 'tool_use' ? 'tool_calls' : 'stop'
+                                            }
+                                        ],
+                                        usage: {
+                                            prompt_tokens: p.inputTokens || 0,
+                                            completion_tokens: p.outputTokens || 0,
+                                            total_tokens: (p.inputTokens || 0) + (p.outputTokens || 0)
+                                        }
                                     };
                                     if (p.toolCalls.length > 0)
                                         oai.choices[0].message.tool_calls = p.toolCalls.map((tc) => ({
                                             id: tc.toolUseId,
                                             type: 'function',
-                                            function: { name: tc.name, arguments: typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input) }
+                                            function: {
+                                                name: tc.name,
+                                                arguments: typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input)
+                                            }
                                         }));
-                                    return new Response(JSON.stringify(oai), { headers: { 'Content-Type': 'application/json' } });
+                                    return new Response(JSON.stringify(oai), {
+                                        headers: { 'Content-Type': 'application/json' }
+                                    });
                                 }
                                 if (res.status === 401 && retry < config.rate_limit_max_retries) {
                                     logger.warn(`Unauthorized (401) on ${acc.email}, retrying...`);
@@ -188,7 +203,12 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                                     };
                                     try {
                                         const u = await fetchUsageLimits({
-                                            refresh: encodeRefreshToken({ refreshToken: res.refreshToken, clientId: res.clientId, clientSecret: res.clientSecret, authMethod: 'idc' }),
+                                            refresh: encodeRefreshToken({
+                                                refreshToken: res.refreshToken,
+                                                clientId: res.clientId,
+                                                clientSecret: res.clientSecret,
+                                                authMethod: 'idc'
+                                            }),
                                             access: res.accessToken,
                                             expires: res.expiresAt,
                                             authMethod: 'idc',
@@ -197,7 +217,11 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
                                             clientSecret: res.clientSecret,
                                             email: res.email
                                         });
-                                        am.updateUsage(acc.id, { usedCount: u.usedCount, limitCount: u.limitCount, realEmail: u.email });
+                                        am.updateUsage(acc.id, {
+                                            usedCount: u.usedCount,
+                                            limitCount: u.limitCount,
+                                            realEmail: u.email
+                                        });
                                     }
                                     catch (e) {
                                         logger.warn(`Initial usage fetch failed: ${e.message}`);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@zhafron/opencode-kiro-auth",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "format": "prettier --write --no-config --no-semi --single-quote --trailing-comma none --print-width 200 'src/**/*.ts'",
+    "format": "prettier --write --no-config --no-semi --single-quote --trailing-comma none --print-width 100 'src/**/*.ts'",
     "typecheck": "tsc --noEmit"
   },
   "keywords": [

package/dist/kiro/oauth-social.d.ts

@@ -1,17 +0,0 @@
-import type { KiroRegion } from '../plugin/types';
-export interface KiroSocialAuthorization {
-    url: string;
-    verifier: string;
-    region: KiroRegion;
-}
-export interface KiroSocialTokenResult {
-    refreshToken: string;
-    accessToken: string;
-    expiresAt: number;
-    email: string;
-    profileArn: string;
-    region: KiroRegion;
-    authMethod: 'social';
-}
-export declare function authorizeKiroSocial(port: number, state: string, challenge: string, region?: KiroRegion): Promise<string>;
-export declare function exchangeKiroSocial(code: string, verifier: string, region: KiroRegion, port: number): Promise<KiroSocialTokenResult>;

package/dist/kiro/oauth-social.js

@@ -1,51 +0,0 @@
-import { KIRO_AUTH_SERVICE, KIRO_CONSTANTS } from '../constants';
-export async function authorizeKiroSocial(port, state, challenge, region) {
-    const effectiveRegion = region || KIRO_CONSTANTS.DEFAULT_REGION;
-    const authServiceEndpoint = KIRO_AUTH_SERVICE.ENDPOINT.replace('{{region}}', effectiveRegion);
-    const redirectUri = `http://127.0.0.1:${port}/oauth/callback`;
-    const params = new URLSearchParams({
-        idp: 'Google',
-        redirect_uri: redirectUri,
-        code_challenge: challenge,
-        code_challenge_method: 'S256',
-        state: state,
-        prompt: 'select_account',
-    });
-    return `${authServiceEndpoint}/login?${params.toString()}`;
-}
-export async function exchangeKiroSocial(code, verifier, region, port) {
-    const authServiceEndpoint = KIRO_AUTH_SERVICE.ENDPOINT.replace('{{region}}', region);
-    const redirectUri = `http://127.0.0.1:${port}/oauth/callback`;
-    const tokenResponse = await fetch(`${authServiceEndpoint}/oauth/token`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': KIRO_CONSTANTS.USER_AGENT,
-        },
-        body: JSON.stringify({
-            code,
-            code_verifier: verifier,
-            redirect_uri: redirectUri,
-        }),
-    });
-    if (!tokenResponse.ok) {
-        const errorText = await tokenResponse.text();
-        throw new Error(`Token exchange failed: ${tokenResponse.status} ${errorText}`);
-    }
-    const tokenData = await tokenResponse.json();
-    if (!tokenData.accessToken || !tokenData.refreshToken || !tokenData.profileArn) {
-        throw new Error('Invalid token response: missing required fields');
-    }
-    const expiresIn = tokenData.expiresIn || 3600;
-    const expiresAt = Date.now() + expiresIn * 1000;
-    const email = tokenData.email || 'unknown@kiro.dev';
-    return {
-        refreshToken: tokenData.refreshToken,
-        accessToken: tokenData.accessToken,
-        expiresAt,
-        email,
-        profileArn: tokenData.profileArn,
-        region,
-        authMethod: 'social',
-    };
-}