@zhafron/opencode-kiro-auth 1.4.11 → 1.5.0

package/dist/infrastructure/transformers/history-builder.js

@@ -0,0 +1,171 @@
+import { KIRO_CONSTANTS } from '../../constants.js';
+import { convertImagesToKiroFormat, extractAllImages, extractTextFromParts } from '../../plugin/image-handler.js';
+import { getContentText, sanitizeHistory, truncate } from './message-transformer.js';
+import { deduplicateToolResults } from './tool-transformer.js';
+export function buildHistory(msgs, resolved, system, toolResultLimit) {
+    let history = [];
+    let firstUserIndex = -1;
+    for (let i = 0; i < msgs.length; i++) {
+        if (msgs[i].role === 'user') {
+            firstUserIndex = i;
+            break;
+        }
+    }
+    if (system) {
+        if (firstUserIndex !== -1) {
+            const m = msgs[firstUserIndex];
+            const oldContent = getContentText(m);
+            if (Array.isArray(m.content)) {
+                m.content = [
+                    { type: 'text', text: `${system}\n\n${oldContent}` },
+                    ...m.content.filter((p) => p.type !== 'text')
+                ];
+            }
+            else
+                m.content = `${system}\n\n${oldContent}`;
+        }
+        else {
+            history.push({
+                userInputMessage: {
+                    content: system,
+                    modelId: resolved,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+                }
+            });
+        }
+    }
+    for (let i = 0; i < msgs.length - 1; i++) {
+        const m = msgs[i];
+        if (!m)
+            continue;
+        if (m.role === 'user') {
+            const uim = { content: '', modelId: resolved, origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR };
+            const trs = [];
+            if (Array.isArray(m.content)) {
+                uim.content = extractTextFromParts(m.content);
+                for (const p of m.content) {
+                    if (p.type === 'tool_result') {
+                        trs.push({
+                            content: [{ text: truncate(getContentText(p.content || p), toolResultLimit) }],
+                            status: 'success',
+                            toolUseId: p.tool_use_id
+                        });
+                    }
+                }
+                const unifiedImages = extractAllImages(m.content);
+                if (unifiedImages.length > 0) {
+                    uim.images = convertImagesToKiroFormat(unifiedImages);
+                }
+            }
+            else {
+                uim.content = getContentText(m);
+            }
+            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: truncate(getContentText(tr), toolResultLimit) }],
+                        status: 'success',
+                        toolUseId: tr.tool_call_id
+                    });
+            }
+            else {
+                trs.push({
+                    content: [{ text: truncate(getContentText(m), toolResultLimit) }],
+                    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 = [];
+            let th = '';
+            if (Array.isArray(m.content)) {
+                for (const p of m.content) {
+                    if (p.type === 'text')
+                        arm.content += p.text || '';
+                    else if (p.type === 'thinking')
+                        th += p.thinking || p.text || '';
+                    else if (p.type === 'tool_use')
+                        tus.push({ input: p.input, name: p.name, toolUseId: p.id });
+                }
+            }
+            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>`;
+            if (tus.length)
+                arm.toolUses = tus;
+            if (!arm.content && !arm.toolUses) {
+                continue;
+            }
+            history.push({ assistantResponseMessage: arm });
+        }
+    }
+    return history;
+}
+export function truncateHistory(history, historyLimit) {
+    let sanitized = sanitizeHistory(history);
+    let historySize = JSON.stringify(sanitized).length;
+    while (historySize > historyLimit && sanitized.length > 2) {
+        sanitized.shift();
+        while (sanitized.length > 0) {
+            const first = sanitized[0];
+            if (first && first.userInputMessage)
+                break;
+            sanitized.shift();
+        }
+        sanitized = sanitizeHistory(sanitized);
+        historySize = JSON.stringify(sanitized).length;
+    }
+    return sanitized;
+}
+export function historyHasToolCalling(history) {
+    return history.some((h) => h.assistantResponseMessage?.toolUses ||
+        h.userInputMessage?.userInputMessageContext?.toolResults);
+}
+export function extractToolNamesFromHistory(history) {
+    const toolNames = new Set();
+    for (const h of history) {
+        if (h.assistantResponseMessage?.toolUses) {
+            for (const tu of h.assistantResponseMessage.toolUses) {
+                if (tu.name)
+                    toolNames.add(tu.name);
+            }
+        }
+    }
+    return toolNames;
+}

package/dist/infrastructure/transformers/message-transformer.d.ts

@@ -0,0 +1,6 @@
+import type { CodeWhispererMessage } from '../../plugin/types';
+export declare function sanitizeHistory(history: CodeWhispererMessage[]): CodeWhispererMessage[];
+export declare function findOriginalToolCall(msgs: any[], toolUseId: string): any | null;
+export declare function mergeAdjacentMessages(msgs: any[]): any[];
+export declare function getContentText(m: any): string;
+export declare function truncate(s: string, max: number): string;

package/dist/infrastructure/transformers/message-transformer.js

@@ -0,0 +1,102 @@
+export function sanitizeHistory(history) {
+    const result = [];
+    for (let i = 0; i < history.length; i++) {
+        const m = history[i];
+        if (!m)
+            continue;
+        if (m.assistantResponseMessage?.toolUses) {
+            const next = history[i + 1];
+            if (next?.userInputMessage?.userInputMessageContext?.toolResults) {
+                result.push(m);
+            }
+        }
+        else if (m.userInputMessage?.userInputMessageContext?.toolResults) {
+            const prev = result[result.length - 1];
+            if (prev?.assistantResponseMessage?.toolUses) {
+                result.push(m);
+            }
+        }
+        else {
+            result.push(m);
+        }
+    }
+    if (result.length > 0) {
+        const first = result[0];
+        if (!first ||
+            !first.userInputMessage ||
+            first.userInputMessage.userInputMessageContext?.toolResults) {
+            return [];
+        }
+    }
+    return result;
+}
+export function findOriginalToolCall(msgs, toolUseId) {
+    for (const m of msgs) {
+        if (m.role === 'assistant') {
+            if (m.tool_calls) {
+                for (const tc of m.tool_calls)
+                    if (tc.id === toolUseId)
+                        return tc;
+            }
+            if (Array.isArray(m.content)) {
+                for (const p of m.content)
+                    if (p.type === 'tool_use' && p.id === toolUseId)
+                        return p;
+            }
+        }
+    }
+    return null;
+}
+export function mergeAdjacentMessages(msgs) {
+    const merged = [];
+    for (const m of msgs) {
+        if (!merged.length)
+            merged.push({ ...m });
+        else {
+            const last = merged[merged.length - 1];
+            if (last && m.role === last.role) {
+                if (Array.isArray(last.content) && Array.isArray(m.content))
+                    last.content.push(...m.content);
+                else if (typeof last.content === 'string' && typeof m.content === 'string')
+                    last.content += '\n' + m.content;
+                else if (Array.isArray(last.content) && typeof m.content === 'string')
+                    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 });
+        }
+    }
+    return merged;
+}
+export function getContentText(m) {
+    if (!m)
+        return '';
+    if (typeof m === 'string')
+        return m;
+    if (typeof m.content === 'string')
+        return m.content;
+    if (Array.isArray(m.content))
+        return m.content
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text || '')
+            .join('');
+    return m.text || '';
+}
+export function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    const half = Math.floor(max / 2);
+    return s.substring(0, half) + '\n... [TRUNCATED] ...\n' + s.substring(s.length - half);
+}

package/dist/infrastructure/transformers/tool-call-parser.d.ts

@@ -0,0 +1,4 @@
+import type { ToolCall } from '../../plugin/types';
+export declare function parseBracketToolCalls(text: string): ToolCall[];
+export declare function deduplicateToolCalls(toolCalls: ToolCall[]): ToolCall[];
+export declare function cleanToolCallsFromText(text: string, toolCalls: ToolCall[]): string;

package/dist/infrastructure/transformers/tool-call-parser.js

@@ -0,0 +1,45 @@
+export function parseBracketToolCalls(text) {
+    const toolCalls = [];
+    const pattern = /\[Called\s+(\w+)\s+with\s+args:\s*(\{[^}]*(?:\{[^}]*\}[^}]*)*\})\]/gs;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        const funcName = match[1];
+        const argsStr = match[2];
+        if (!funcName || !argsStr)
+            continue;
+        try {
+            const args = JSON.parse(argsStr);
+            toolCalls.push({
+                toolUseId: `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                name: funcName,
+                input: args
+            });
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    return toolCalls;
+}
+export function deduplicateToolCalls(toolCalls) {
+    const seen = new Set();
+    const unique = [];
+    for (const tc of toolCalls) {
+        if (!seen.has(tc.toolUseId)) {
+            seen.add(tc.toolUseId);
+            unique.push(tc);
+        }
+    }
+    return unique;
+}
+export function cleanToolCallsFromText(text, toolCalls) {
+    let cleaned = text;
+    for (const tc of toolCalls) {
+        const funcName = tc.name;
+        const escapedName = funcName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const pattern = new RegExp(`\\[Called\\s+${escapedName}\\s+with\\s+args:\\s*\\{[^}]*(?:\\{[^}]*\\}[^}]*)*\\}\\]`, 'gs');
+        cleaned = cleaned.replace(pattern, '');
+    }
+    cleaned = cleaned.replace(/\s+/g, ' ').trim();
+    return cleaned;
+}

package/dist/infrastructure/transformers/tool-transformer.d.ts

@@ -0,0 +1,2 @@
+export declare function convertToolsToCodeWhisperer(tools: any[]): any[];
+export declare function deduplicateToolResults(trs: any[]): any[];

package/dist/infrastructure/transformers/tool-transformer.js

@@ -0,0 +1,19 @@
+export function convertToolsToCodeWhisperer(tools) {
+    return tools.map((t) => ({
+        toolSpecification: {
+            name: t.name || t.function?.name,
+            description: (t.description || t.function?.description || '').substring(0, 9216),
+            inputSchema: { json: t.input_schema || t.function?.parameters || {} }
+        }
+    }));
+}
+export function deduplicateToolResults(trs) {
+    const u = [], s = new Set();
+    for (const t of trs) {
+        if (!s.has(t.toolUseId)) {
+            s.add(t.toolUseId);
+            u.push(t);
+        }
+    }
+    return u;
+}

package/dist/kiro/auth.d.ts

@@ -1,5 +1,4 @@
 import type { KiroAuthDetails, RefreshParts } from '../plugin/types';
 export declare function decodeRefreshToken(refresh: string): RefreshParts;
 export declare function accessTokenExpired(auth: KiroAuthDetails, bufferMs?: number): boolean;
-export declare function validateAuthDetails(auth: KiroAuthDetails): boolean;
 export declare function encodeRefreshToken(parts: RefreshParts): string;

package/dist/kiro/auth.js

@@ -15,13 +15,6 @@ export function accessTokenExpired(auth, bufferMs = 120000) {
         return true;
     return Date.now() >= auth.expires - bufferMs;
 }
-export function validateAuthDetails(auth) {
-    if (!auth.refresh)
-        return false;
-    if (auth.authMethod === 'idc')
-        return !!auth.clientId && !!auth.clientSecret;
-    return true;
-}
 export function encodeRefreshToken(parts) {
     if (parts.authMethod === 'idc') {
         if (!parts.clientId || !parts.clientSecret)

package/dist/plugin/accounts.d.ts

@@ -1,5 +1,4 @@
 import type { AccountSelectionStrategy, KiroAuthDetails, ManagedAccount } from './types';
-export declare function generateAccountId(): string;
 export declare function createDeterministicAccountId(email: string, method: string, clientId?: string, profileArn?: string): string;
 export declare class AccountManager {
     private accounts;

package/dist/plugin/accounts.js

@@ -1,12 +1,9 @@
-import { createHash, randomBytes } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import { decodeRefreshToken, encodeRefreshToken } from '../kiro/auth';
 import { isPermanentError } from './health';
 import * as logger from './logger';
 import { kiroDb } from './storage/sqlite';
 import { writeToKiroCli } from './sync/kiro-cli';
-export function generateAccountId() {
-    return randomBytes(16).toString('hex');
-}
 export function createDeterministicAccountId(email, method, clientId, profileArn) {
     return createHash('sha256')
         .update(`${email}:${method}:${clientId || ''}:${profileArn || ''}`)
@@ -128,6 +125,9 @@ export class AccountManager {
                 a.email = meta.email;
             if (!isPermanentError(a.unhealthyReason)) {
                 a.failCount = 0;
+                a.isHealthy = true;
+                delete a.unhealthyReason;
+                delete a.recoveryTime;
             }
             kiroDb.upsertAccount(a).catch(() => { });
         }

package/dist/plugin/cli.d.ts

@@ -1,5 +1,6 @@
 export declare function promptAddAnotherAccount(currentCount: number): Promise<boolean>;
-export type LoginMode = 'add' | 'fresh';
+export declare function promptDeleteAccount(accounts: ExistingAccountInfo[]): Promise<number | null>;
+export type LoginMode = 'add' | 'fresh' | 'delete';
 export interface ExistingAccountInfo {
     email?: string;
     index: number;

package/dist/plugin/cli.js

@@ -11,6 +11,39 @@ export async function promptAddAnotherAccount(currentCount) {
         rl.close();
     }
 }
+export async function promptDeleteAccount(accounts) {
+    const rl = createInterface({ input, output });
+    try {
+        console.log(`\nSelect account to delete:`);
+        for (const acc of accounts) {
+            const label = acc.email || `Account ${acc.index + 1}`;
+            console.log(`  ${acc.index + 1}. ${label}`);
+        }
+        console.log(`  0. Cancel`);
+        console.log('');
+        while (true) {
+            const answer = await rl.question('Enter account number: ');
+            const num = parseInt(answer.trim(), 10);
+            if (num === 0) {
+                return null;
+            }
+            if (num >= 1 && num <= accounts.length) {
+                const selected = accounts[num - 1];
+                const label = selected?.email || `Account ${num}`;
+                const confirm = await rl.question(`Delete "${label}"? (y/n): `);
+                const normalized = confirm.trim().toLowerCase();
+                if (normalized === 'y' || normalized === 'yes') {
+                    return selected?.index ?? null;
+                }
+                return null;
+            }
+            console.log(`Please enter a number between 0 and ${accounts.length}`);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
 export async function promptLoginMode(existingAccounts) {
     const rl = createInterface({ input, output });
     try {
@@ -21,7 +54,7 @@ export async function promptLoginMode(existingAccounts) {
         }
         console.log('');
         while (true) {
-            const answer = await rl.question('(a)dd new account(s) or (f)resh start? [a/f]: ');
+            const answer = await rl.question('(a)dd new account(s), (f)resh start, or (d)elete account? [a/f/d]: ');
             const normalized = answer.trim().toLowerCase();
             if (normalized === 'a' || normalized === 'add') {
                 return 'add';
@@ -29,7 +62,10 @@ export async function promptLoginMode(existingAccounts) {
             if (normalized === 'f' || normalized === 'fresh') {
                 return 'fresh';
             }
-            console.log("Please enter 'a' to add accounts or 'f' to start fresh.");
+            if (normalized === 'd' || normalized === 'delete') {
+                return 'delete';
+            }
+            console.log("Please enter 'a' to add accounts, 'f' to start fresh, or 'd' to delete account.");
         }
     }
     finally {

package/dist/plugin/models.d.ts

@@ -1,3 +1 @@
 export declare function resolveKiroModel(model: string): string;
-export declare function getSupportedModels(): string[];
-export declare function isModelSupported(model: string): boolean;

package/dist/plugin/models.js

@@ -6,9 +6,3 @@ export function resolveKiroModel(model) {
     }
     return resolved;
 }
-export function getSupportedModels() {
-    return SUPPORTED_MODELS;
-}
-export function isModelSupported(model) {
-    return SUPPORTED_MODELS.includes(model);
-}

package/dist/plugin/request.d.ts

@@ -1,4 +1,2 @@
 import type { KiroAuthDetails, PreparedRequest } from './types';
 export declare function transformToCodeWhisperer(url: string, body: any, model: string, auth: KiroAuthDetails, think?: boolean, budget?: number, reductionFactor?: number): PreparedRequest;
-export declare function mergeAdjacentMessages(msgs: any[]): any[];
-export declare function convertToolsToCodeWhisperer(tools: any[]): any[];