@zhafron/opencode-kiro-auth 1.0.0 → 1.1.1

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/config/schema.d.ts

@@ -15,6 +15,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
     rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
     usage_tracking_enabled: z.ZodDefault<z.ZodBoolean>;
+    enable_log_api_request: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     session_recovery: boolean;
     auto_resume: boolean;
@@ -26,6 +27,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms: number;
     rate_limit_max_retries: number;
     usage_tracking_enabled: boolean;
+    enable_log_api_request: boolean;
     $schema?: string | undefined;
 }, {
     $schema?: string | undefined;
@@ -39,6 +41,7 @@ export declare const KiroConfigSchema: z.ZodObject<{
     rate_limit_retry_delay_ms?: number | undefined;
     rate_limit_max_retries?: number | undefined;
     usage_tracking_enabled?: boolean | undefined;
+    enable_log_api_request?: boolean | undefined;
 }>;
 export type KiroConfig = z.infer<typeof KiroConfigSchema>;
 export declare const DEFAULT_CONFIG: KiroConfig;

package/dist/plugin/config/schema.js

@@ -12,7 +12,8 @@ export const KiroConfigSchema = z.object({
     default_region: RegionSchema.default('us-east-1'),
     rate_limit_retry_delay_ms: z.number().min(1000).max(60000).default(5000),
     rate_limit_max_retries: z.number().min(0).max(10).default(3),
-    usage_tracking_enabled: z.boolean().default(true)
+    usage_tracking_enabled: z.boolean().default(true),
+    enable_log_api_request: z.boolean().default(false)
 });
 export const DEFAULT_CONFIG = {
     session_recovery: true,
@@ -24,5 +25,6 @@ export const DEFAULT_CONFIG = {
     default_region: 'us-east-1',
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,
-    usage_tracking_enabled: true
+    usage_tracking_enabled: true,
+    enable_log_api_request: false
 };

package/dist/plugin/logger.d.ts

@@ -2,3 +2,6 @@ export declare function log(message: string, ...args: unknown[]): void;
 export declare function error(message: string, ...args: unknown[]): void;
 export declare function warn(message: string, ...args: unknown[]): void;
 export declare function debug(message: string, ...args: unknown[]): void;
+export declare function logApiRequest(data: any, timestamp: string): void;
+export declare function logApiResponse(data: any, timestamp: string): void;
+export declare function getTimestamp(): string;

package/dist/plugin/logger.js

@@ -1,9 +1,11 @@
-import { appendFileSync, mkdirSync } from 'node:fs';
+import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
 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) => {
@@ -17,21 +19,37 @@ const writeToFile = (level, message, ...args) => {
     }
     catch (e) { }
 };
+const writeApiLog = (type, data, timestamp) => {
+    try {
+        const dir = getLogDir();
+        mkdirSync(dir, { recursive: true });
+        const filename = `${timestamp}_${type}.json`;
+        const path = join(dir, filename);
+        const content = JSON.stringify(data, null, 2);
+        writeFileSync(path, content);
+    }
+    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);
     }
 }
+export function logApiRequest(data, timestamp) {
+    writeApiLog('request', data, timestamp);
+}
+export function logApiResponse(data, timestamp) {
+    writeApiLog('response', data, timestamp);
+}
+export function getTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}

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
@@ -54,10 +82,41 @@ export function transformToCodeWhisperer(url, body, model, auth, think = false,
             if (trs.length)
                 uim.userInputMessageContext = { toolResults: deduplicateToolResults(trs) };
             const prev = history[history.length - 1];
-            if (prev && prev.userInputMessage)
+            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
+                });
+            }
+            const prev = history[history.length - 1];
+            if (prev && prev.userInputMessage) {
+                history.push({ assistantResponseMessage: { content: 'Continue' } });
+            }
+            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 +131,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 +177,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 +201,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 +244,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 +314,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)