@zhafron/opencode-kiro-auth 1.0.0

package/dist/src/plugin/request.js

@@ -0,0 +1,411 @@
+import * as crypto from 'crypto';
+import * as os from 'os';
+import { KIRO_CONSTANTS } from '../constants';
+import { resolveKiroModel } from './models';
+export function transformToCodeWhisperer(url, body, model, auth, thinkingEnabled = false, thinkingBudget = 20000) {
+    const openAIRequest = JSON.parse(body);
+    const { messages, tools, system: systemPrompt } = openAIRequest;
+    if (!messages || messages.length === 0) {
+        throw new Error('No messages found in request');
+    }
+    const resolvedModel = resolveKiroModel(model);
+    const conversationId = crypto.randomUUID();
+    let processedSystemPrompt = systemPrompt || '';
+    if (thinkingEnabled) {
+        const thinkingPrefix = `<thinking_mode>enabled</thinking_mode><max_thinking_length>${thinkingBudget}</max_thinking_length>`;
+        if (!processedSystemPrompt) {
+            processedSystemPrompt = thinkingPrefix;
+        }
+        else if (!processedSystemPrompt.includes('<thinking_mode>')) {
+            processedSystemPrompt = `${thinkingPrefix}\n${processedSystemPrompt}`;
+        }
+    }
+    let processedMessages = [...messages];
+    const lastMessage = processedMessages[processedMessages.length - 1];
+    if (lastMessage?.role === 'assistant') {
+        const content = getContentText(lastMessage);
+        if (content === '{') {
+            processedMessages.pop();
+        }
+    }
+    processedMessages = mergeAdjacentMessages(processedMessages);
+    const codewhispererTools = tools ? convertToolsToCodeWhisperer(tools) : [];
+    const history = [];
+    let startIndex = 0;
+    if (processedSystemPrompt) {
+        if (processedMessages[0]?.role === 'user') {
+            const firstUserContent = getContentText(processedMessages[0]);
+            history.push({
+                userInputMessage: {
+                    content: `${processedSystemPrompt}\n\n${firstUserContent}`,
+                    modelId: resolvedModel,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR,
+                }
+            });
+            startIndex = 1;
+        }
+        else {
+            history.push({
+                userInputMessage: {
+                    content: processedSystemPrompt,
+                    modelId: resolvedModel,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR,
+                }
+            });
+        }
+    }
+    const keepImageThreshold = 5;
+    for (let i = startIndex; i < processedMessages.length - 1; i++) {
+        const message = processedMessages[i];
+        if (!message)
+            continue;
+        const distanceFromEnd = (processedMessages.length - 1) - i;
+        const shouldKeepImages = distanceFromEnd <= keepImageThreshold;
+        if (message.role === 'user') {
+            const userInputMessage = {
+                content: '',
+                modelId: resolvedModel,
+                origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+            };
+            let imageCount = 0;
+            const toolResults = [];
+            const images = [];
+            if (Array.isArray(message.content)) {
+                for (const part of message.content) {
+                    if (part.type === 'text') {
+                        userInputMessage.content += part.text || '';
+                    }
+                    else if (part.type === 'tool_result') {
+                        toolResults.push({
+                            content: [{ text: getContentText(part) }],
+                            status: 'success',
+                            toolUseId: part.tool_use_id
+                        });
+                    }
+                    else if (part.type === 'image') {
+                        if (shouldKeepImages && part.source) {
+                            images.push({
+                                format: part.source.media_type?.split('/')[1] || 'png',
+                                source: {
+                                    bytes: part.source.data
+                                }
+                            });
+                        }
+                        else {
+                            imageCount++;
+                        }
+                    }
+                }
+            }
+            else {
+                userInputMessage.content = getContentText(message);
+            }
+            if (images.length > 0) {
+                userInputMessage.images = images;
+            }
+            if (imageCount > 0) {
+                const imagePlaceholder = `[此消息包含 ${imageCount} 张图片，已在历史记录中省略]`;
+                userInputMessage.content = userInputMessage.content
+                    ? `${userInputMessage.content}\n${imagePlaceholder}`
+                    : imagePlaceholder;
+            }
+            if (toolResults.length > 0) {
+                const uniqueToolResults = deduplicateToolResults(toolResults);
+                userInputMessage.userInputMessageContext = { toolResults: uniqueToolResults };
+            }
+            history.push({ userInputMessage });
+        }
+        else if (message.role === 'assistant') {
+            const assistantResponseMessage = {
+                content: ''
+            };
+            const toolUses = [];
+            let thinkingText = '';
+            if (Array.isArray(message.content)) {
+                for (const part of message.content) {
+                    if (part.type === 'text') {
+                        assistantResponseMessage.content += part.text || '';
+                    }
+                    else if (part.type === 'thinking') {
+                        thinkingText += (part.thinking || part.text || '');
+                    }
+                    else if (part.type === 'tool_use') {
+                        toolUses.push({
+                            input: part.input,
+                            name: part.name,
+                            toolUseId: part.id
+                        });
+                    }
+                }
+            }
+            else {
+                assistantResponseMessage.content = getContentText(message);
+            }
+            if (thinkingText) {
+                assistantResponseMessage.content = assistantResponseMessage.content
+                    ? `<thinking>${thinkingText}</thinking>\n\n${assistantResponseMessage.content}`
+                    : `<thinking>${thinkingText}</thinking>`;
+            }
+            if (toolUses.length > 0) {
+                assistantResponseMessage.toolUses = toolUses;
+            }
+            history.push({ assistantResponseMessage });
+        }
+    }
+    const currentMessage = processedMessages[processedMessages.length - 1];
+    if (!currentMessage) {
+        throw new Error('No current message found');
+    }
+    let currentContent = '';
+    const currentToolResults = [];
+    const currentImages = [];
+    if (currentMessage.role === 'assistant') {
+        const assistantResponseMessage = {
+            content: ''
+        };
+        const toolUses = [];
+        let thinkingText = '';
+        if (Array.isArray(currentMessage.content)) {
+            for (const part of currentMessage.content) {
+                if (part.type === 'text') {
+                    assistantResponseMessage.content += part.text || '';
+                }
+                else if (part.type === 'thinking') {
+                    thinkingText += (part.thinking || part.text || '');
+                }
+                else if (part.type === 'tool_use') {
+                    toolUses.push({
+                        input: part.input,
+                        name: part.name,
+                        toolUseId: part.id
+                    });
+                }
+            }
+        }
+        else {
+            assistantResponseMessage.content = getContentText(currentMessage);
+        }
+        if (thinkingText) {
+            assistantResponseMessage.content = assistantResponseMessage.content
+                ? `<thinking>${thinkingText}</thinking>\n\n${assistantResponseMessage.content}`
+                : `<thinking>${thinkingText}</thinking>`;
+        }
+        if (toolUses.length > 0) {
+            assistantResponseMessage.toolUses = toolUses;
+        }
+        history.push({ assistantResponseMessage });
+        currentContent = 'Continue';
+    }
+    else {
+        if (history.length > 0) {
+            const lastHistoryItem = history[history.length - 1];
+            if (lastHistoryItem && !lastHistoryItem.assistantResponseMessage) {
+                history.push({
+                    assistantResponseMessage: {
+                        content: 'Continue'
+                    }
+                });
+            }
+        }
+        if (Array.isArray(currentMessage.content)) {
+            for (const part of currentMessage.content) {
+                if (part.type === 'text') {
+                    currentContent += part.text || '';
+                }
+                else if (part.type === 'tool_result') {
+                    currentToolResults.push({
+                        content: [{ text: getContentText(part) }],
+                        status: 'success',
+                        toolUseId: part.tool_use_id
+                    });
+                }
+                else if (part.type === 'image') {
+                    if (part.source) {
+                        currentImages.push({
+                            format: part.source.media_type?.split('/')[1] || 'png',
+                            source: {
+                                bytes: part.source.data
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            currentContent = getContentText(currentMessage);
+        }
+        if (!currentContent) {
+            currentContent = currentToolResults.length > 0 ? 'Tool results provided.' : 'Continue';
+        }
+    }
+    const request = {
+        conversationState: {
+            chatTriggerType: KIRO_CONSTANTS.CHAT_TRIGGER_TYPE_MANUAL,
+            conversationId: conversationId,
+            history: history.length > 0 ? history : [],
+            currentMessage: {
+                userInputMessage: {
+                    content: currentContent,
+                    modelId: resolvedModel,
+                    origin: KIRO_CONSTANTS.ORIGIN_AI_EDITOR
+                }
+            }
+        }
+    };
+    if (history.length === 0) {
+        delete request.conversationState.history;
+    }
+    const userInputMessage = request.conversationState.currentMessage.userInputMessage;
+    if (currentImages.length > 0) {
+        userInputMessage.images = currentImages;
+    }
+    const userInputMessageContext = {};
+    if (currentToolResults.length > 0) {
+        const uniqueToolResults = deduplicateToolResults(currentToolResults);
+        userInputMessageContext.toolResults = uniqueToolResults;
+    }
+    if (codewhispererTools.length > 0) {
+        userInputMessageContext.tools = codewhispererTools;
+    }
+    if (Object.keys(userInputMessageContext).length > 0) {
+        userInputMessage.userInputMessageContext = userInputMessageContext;
+    }
+    if (auth.authMethod === 'social' && auth.profileArn) {
+        request.profileArn = auth.profileArn;
+    }
+    const finalUrl = KIRO_CONSTANTS.BASE_URL.replace('{{region}}', auth.region);
+    const machineId = generateMachineId(auth);
+    const userAgent = buildUserAgent(machineId);
+    return {
+        url: finalUrl,
+        init: {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${auth.access}`,
+                'x-amzn-kiro-agent-mode': 'vibe',
+                'x-amz-user-agent': `aws-sdk-js/1.0.0 ${userAgent}`,
+                'user-agent': userAgent
+            },
+            body: JSON.stringify(request)
+        },
+        streaming: true,
+        effectiveModel: resolvedModel,
+        conversationId: conversationId
+    };
+}
+export function mergeAdjacentMessages(messages) {
+    const merged = [];
+    for (const currentMsg of messages) {
+        if (merged.length === 0) {
+            merged.push({ ...currentMsg });
+        }
+        else {
+            const lastMsg = merged[merged.length - 1];
+            if (!lastMsg)
+                continue;
+            if (currentMsg.role === lastMsg.role) {
+                if (Array.isArray(lastMsg.content) && Array.isArray(currentMsg.content)) {
+                    lastMsg.content.push(...currentMsg.content);
+                }
+                else if (typeof lastMsg.content === 'string' && typeof currentMsg.content === 'string') {
+                    lastMsg.content += '\n' + currentMsg.content;
+                }
+                else if (Array.isArray(lastMsg.content) && typeof currentMsg.content === 'string') {
+                    lastMsg.content.push({ type: 'text', text: currentMsg.content });
+                }
+                else if (typeof lastMsg.content === 'string' && Array.isArray(currentMsg.content)) {
+                    lastMsg.content = [{ type: 'text', text: lastMsg.content }, ...currentMsg.content];
+                }
+            }
+            else {
+                merged.push({ ...currentMsg });
+            }
+        }
+    }
+    return merged;
+}
+export function convertToolsToCodeWhisperer(tools) {
+    const MAX_DESCRIPTION_LENGTH = 9216;
+    const filteredTools = tools.filter(tool => {
+        const name = (tool.name || '').toLowerCase();
+        return name !== 'web_search' && name !== 'websearch';
+    });
+    return filteredTools.map(tool => {
+        let desc = tool.description || '';
+        if (desc.length > MAX_DESCRIPTION_LENGTH) {
+            desc = desc.substring(0, MAX_DESCRIPTION_LENGTH) + '...';
+        }
+        return {
+            toolSpecification: {
+                name: tool.name,
+                description: desc,
+                inputSchema: {
+                    json: tool.input_schema || {}
+                }
+            }
+        };
+    });
+}
+export function extractImagesFromContent(content) {
+    const images = [];
+    let text = '';
+    if (Array.isArray(content)) {
+        for (const part of content) {
+            if (part.type === 'text') {
+                text += part.text || '';
+            }
+            else if (part.type === 'image' && part.source) {
+                images.push({
+                    format: part.source.media_type?.split('/')[1] || 'png',
+                    source: {
+                        bytes: part.source.data
+                    }
+                });
+            }
+        }
+    }
+    else if (typeof content === 'string') {
+        text = content;
+    }
+    return { text, images };
+}
+export function buildUserAgent(machineId) {
+    const platform = os.platform();
+    const nodeVersion = process.version.replace('v', '');
+    const arch = os.arch();
+    return `KiroIDE-${KIRO_CONSTANTS.KIRO_VERSION}-${machineId} ua/2.1 os/${platform} lang/js md/nodejs#${nodeVersion} api/codewhisperer#1.0.0 exec-env/${arch}`;
+}
+export function generateMachineId(auth) {
+    const source = auth.profileArn || auth.clientId || 'default';
+    return crypto.createHash('sha256').update(source).digest('hex').substring(0, 16);
+}
+function getContentText(message) {
+    if (typeof message === 'string') {
+        return message;
+    }
+    if (typeof message.content === 'string') {
+        return message.content;
+    }
+    if (Array.isArray(message.content)) {
+        return message.content
+            .filter((part) => part.type === 'text')
+            .map((part) => part.text || '')
+            .join('');
+    }
+    if (message.text) {
+        return message.text;
+    }
+    return '';
+}
+function deduplicateToolResults(toolResults) {
+    const unique = [];
+    const seenIds = new Set();
+    for (const tr of toolResults) {
+        if (!seenIds.has(tr.toolUseId)) {
+            seenIds.add(tr.toolUseId);
+            unique.push(tr);
+        }
+    }
+    return unique;
+}

package/dist/src/plugin/response.d.ts

@@ -0,0 +1,6 @@
+import { ToolCall, ParsedResponse } from './types';
+export declare function parseEventStream(rawResponse: string): ParsedResponse;
+export declare function parseEventLine(line: string): any | null;
+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/src/plugin/response.js

@@ -0,0 +1,246 @@
+export function parseEventStream(rawResponse) {
+    const parsedFromEvents = parseEventStreamChunk(rawResponse);
+    let fullResponseText = parsedFromEvents.content;
+    let allToolCalls = [...parsedFromEvents.toolCalls];
+    const rawBracketToolCalls = parseBracketToolCalls(rawResponse);
+    if (rawBracketToolCalls.length > 0) {
+        allToolCalls.push(...rawBracketToolCalls);
+    }
+    const uniqueToolCalls = deduplicateToolCalls(allToolCalls);
+    if (uniqueToolCalls.length > 0) {
+        fullResponseText = cleanToolCallsFromText(fullResponseText, uniqueToolCalls);
+    }
+    return {
+        content: fullResponseText,
+        toolCalls: uniqueToolCalls,
+        stopReason: parsedFromEvents.stopReason,
+        inputTokens: parsedFromEvents.inputTokens,
+        outputTokens: parsedFromEvents.outputTokens
+    };
+}
+function parseEventStreamChunk(rawText) {
+    const events = parseAwsEventStreamBuffer(rawText);
+    let content = '';
+    const toolCallsMap = new Map();
+    let stopReason;
+    let inputTokens;
+    let outputTokens;
+    let contextUsagePercentage;
+    for (const event of events) {
+        if (event.type === 'content' && event.data) {
+            content += event.data;
+        }
+        else if (event.type === 'toolUse') {
+            const { name, toolUseId, input } = event.data;
+            if (name && toolUseId) {
+                if (toolCallsMap.has(toolUseId)) {
+                    const existing = toolCallsMap.get(toolUseId);
+                    existing.input = existing.input + (input || '');
+                }
+                else {
+                    toolCallsMap.set(toolUseId, {
+                        toolUseId,
+                        name,
+                        input: input || ''
+                    });
+                }
+            }
+        }
+        else if (event.type === 'toolUseInput') {
+            const lastToolCall = Array.from(toolCallsMap.values()).pop();
+            if (lastToolCall) {
+                lastToolCall.input = lastToolCall.input + (event.data.input || '');
+            }
+        }
+        else if (event.type === 'toolUseStop') {
+            stopReason = 'tool_use';
+        }
+        else if (event.type === 'contextUsage') {
+            contextUsagePercentage = event.data.contextUsagePercentage;
+        }
+    }
+    const toolCalls = Array.from(toolCallsMap.values()).map(tc => {
+        let parsedInput = tc.input;
+        if (typeof tc.input === 'string' && tc.input.trim()) {
+            try {
+                parsedInput = JSON.parse(tc.input);
+            }
+            catch (e) {
+                parsedInput = tc.input;
+            }
+        }
+        return {
+            toolUseId: tc.toolUseId,
+            name: tc.name,
+            input: parsedInput
+        };
+    });
+    if (contextUsagePercentage !== undefined) {
+        const totalTokens = Math.round(200000 * contextUsagePercentage / 100);
+        outputTokens = estimateTokens(content);
+        inputTokens = Math.max(0, totalTokens - outputTokens);
+    }
+    return {
+        content,
+        toolCalls,
+        stopReason: stopReason || (toolCalls.length > 0 ? 'tool_use' : 'end_turn'),
+        inputTokens,
+        outputTokens
+    };
+}
+function parseAwsEventStreamBuffer(buffer) {
+    const events = [];
+    let remaining = buffer;
+    let searchStart = 0;
+    while (true) {
+        const contentStart = remaining.indexOf('{"content":', searchStart);
+        const nameStart = remaining.indexOf('{"name":', searchStart);
+        const followupStart = remaining.indexOf('{"followupPrompt":', searchStart);
+        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);
+        if (candidates.length === 0)
+            break;
+        const jsonStart = Math.min(...candidates);
+        if (jsonStart < 0)
+            break;
+        let braceCount = 0;
+        let jsonEnd = -1;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = jsonStart; i < remaining.length; i++) {
+            const char = remaining[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (!inString) {
+                if (char === '{') {
+                    braceCount++;
+                }
+                else if (char === '}') {
+                    braceCount--;
+                    if (braceCount === 0) {
+                        jsonEnd = i;
+                        break;
+                    }
+                }
+            }
+        }
+        if (jsonEnd < 0) {
+            break;
+        }
+        const jsonStr = remaining.substring(jsonStart, jsonEnd + 1);
+        const parsed = parseEventLine(jsonStr);
+        if (parsed) {
+            if (parsed.content !== undefined && !parsed.followupPrompt) {
+                events.push({ type: 'content', data: parsed.content });
+            }
+            else if (parsed.name && parsed.toolUseId) {
+                events.push({
+                    type: 'toolUse',
+                    data: {
+                        name: parsed.name,
+                        toolUseId: parsed.toolUseId,
+                        input: parsed.input || '',
+                        stop: parsed.stop || false
+                    }
+                });
+            }
+            else if (parsed.input !== undefined && !parsed.name) {
+                events.push({
+                    type: 'toolUseInput',
+                    data: {
+                        input: parsed.input
+                    }
+                });
+            }
+            else if (parsed.stop !== undefined && parsed.contextUsagePercentage === undefined) {
+                events.push({
+                    type: 'toolUseStop',
+                    data: {
+                        stop: parsed.stop
+                    }
+                });
+            }
+            else if (parsed.contextUsagePercentage !== undefined) {
+                events.push({
+                    type: 'contextUsage',
+                    data: {
+                        contextUsagePercentage: parsed.contextUsagePercentage
+                    }
+                });
+            }
+        }
+        searchStart = jsonEnd + 1;
+        if (searchStart >= remaining.length) {
+            break;
+        }
+    }
+    return events;
+}
+export function parseEventLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (e) {
+        return null;
+    }
+}
+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;
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}

package/dist/src/plugin/server.d.ts

@@ -0,0 +1,10 @@
+interface CallbackResult {
+    code: string;
+    state: string;
+}
+interface CallbackServerResult {
+    url: string;
+    waitForCallback: () => Promise<CallbackResult>;
+}
+export declare function startCallbackServer(port?: number): Promise<CallbackServerResult>;
+export {};