@sunerpy/opencode-kiro-auth 0.1.0

package/dist/plugin/streaming/sdk-stream-transformer.js

@@ -0,0 +1,274 @@
+import { parseBracketToolCalls } from '../../infrastructure/transformers/tool-call-parser.js';
+import { getContextWindowSize } from '../models.js';
+import { estimateTokens } from '../response.js';
+import { convertToOpenAI } from './openai-converter.js';
+import { findRealTag } from './stream-parser.js';
+import { createTextDeltaEvents, createThinkingDeltaEvents, stopBlock } from './stream-state.js';
+import { THINKING_END_TAG, THINKING_START_TAG } from './types.js';
+export async function* transformSdkStream(sdkResponse, model, conversationId) {
+    const thinkingRequested = true;
+    const streamState = {
+        thinkingRequested,
+        buffer: '',
+        inThinking: false,
+        thinkingExtracted: false,
+        thinkingBlockIndex: null,
+        textBlockIndex: null,
+        nextBlockIndex: 0,
+        stoppedBlocks: new Set()
+    };
+    let totalContent = '';
+    let textOnlyContent = '';
+    let outputTokens = 0;
+    let inputTokens = 0;
+    let contextUsagePercentage = null;
+    const toolCalls = [];
+    let currentToolCall = null;
+    const eventStream = sdkResponse.generateAssistantResponseResponse;
+    if (!eventStream) {
+        throw new Error('SDK response has no event stream');
+    }
+    try {
+        for await (const event of eventStream) {
+            if (event.assistantResponseEvent?.content) {
+                const text = event.assistantResponseEvent.content;
+                totalContent += text;
+                textOnlyContent += text;
+                if (!thinkingRequested) {
+                    for (const ev of createTextDeltaEvents(text, streamState)) {
+                        {
+                            const _c = convertToOpenAI(ev, conversationId, model);
+                            if (_c !== null)
+                                yield _c;
+                        }
+                    }
+                    continue;
+                }
+                streamState.buffer += text;
+                const deltaEvents = [];
+                while (streamState.buffer.length > 0) {
+                    if (!streamState.inThinking && !streamState.thinkingExtracted) {
+                        const startPos = findRealTag(streamState.buffer, THINKING_START_TAG);
+                        if (startPos !== -1) {
+                            const before = streamState.buffer.slice(0, startPos);
+                            if (before) {
+                                deltaEvents.push(...createTextDeltaEvents(before, streamState));
+                            }
+                            streamState.buffer = streamState.buffer.slice(startPos + THINKING_START_TAG.length);
+                            streamState.inThinking = true;
+                            continue;
+                        }
+                        const safeLen = Math.max(0, streamState.buffer.length - THINKING_START_TAG.length);
+                        if (safeLen > 0) {
+                            const safeText = streamState.buffer.slice(0, safeLen);
+                            if (safeText) {
+                                deltaEvents.push(...createTextDeltaEvents(safeText, streamState));
+                            }
+                            streamState.buffer = streamState.buffer.slice(safeLen);
+                        }
+                        break;
+                    }
+                    if (streamState.inThinking) {
+                        const endPos = findRealTag(streamState.buffer, THINKING_END_TAG);
+                        if (endPos !== -1) {
+                            const thinkingPart = streamState.buffer.slice(0, endPos);
+                            if (thinkingPart) {
+                                deltaEvents.push(...createThinkingDeltaEvents(thinkingPart, streamState));
+                            }
+                            streamState.buffer = streamState.buffer.slice(endPos + THINKING_END_TAG.length);
+                            streamState.inThinking = false;
+                            streamState.thinkingExtracted = true;
+                            deltaEvents.push(...createThinkingDeltaEvents('', streamState));
+                            deltaEvents.push(...stopBlock(streamState.thinkingBlockIndex, streamState));
+                            if (streamState.buffer.startsWith('\n\n')) {
+                                streamState.buffer = streamState.buffer.slice(2);
+                            }
+                            continue;
+                        }
+                        const safeLen = Math.max(0, streamState.buffer.length - THINKING_END_TAG.length);
+                        if (safeLen > 0) {
+                            const safeThinking = streamState.buffer.slice(0, safeLen);
+                            if (safeThinking) {
+                                deltaEvents.push(...createThinkingDeltaEvents(safeThinking, streamState));
+                            }
+                            streamState.buffer = streamState.buffer.slice(safeLen);
+                        }
+                        break;
+                    }
+                    if (streamState.thinkingExtracted) {
+                        const rest = streamState.buffer;
+                        streamState.buffer = '';
+                        if (rest) {
+                            deltaEvents.push(...createTextDeltaEvents(rest, streamState));
+                        }
+                        break;
+                    }
+                }
+                for (const ev of deltaEvents) {
+                    const chunk = convertToOpenAI(ev, conversationId, model);
+                    if (chunk !== null)
+                        yield chunk;
+                }
+            }
+            else if (event.toolUseEvent) {
+                const tc = event.toolUseEvent;
+                if (tc.name)
+                    totalContent += tc.name;
+                if (tc.input)
+                    totalContent += tc.input;
+                if (tc.name && tc.toolUseId) {
+                    if (currentToolCall && currentToolCall.toolUseId === tc.toolUseId) {
+                        currentToolCall.input += tc.input || '';
+                    }
+                    else {
+                        if (currentToolCall)
+                            toolCalls.push(currentToolCall);
+                        currentToolCall = {
+                            toolUseId: tc.toolUseId,
+                            name: tc.name,
+                            input: tc.input || ''
+                        };
+                    }
+                    if (tc.stop && currentToolCall) {
+                        toolCalls.push(currentToolCall);
+                        currentToolCall = null;
+                    }
+                }
+            }
+            else if (event.metadataEvent) {
+                if (event.metadataEvent.contextUsagePercentage) {
+                    contextUsagePercentage = event.metadataEvent.contextUsagePercentage;
+                }
+            }
+            else if (event.contextUsageEvent) {
+                const cue = event.contextUsageEvent;
+                if (cue.contextUsagePercentage) {
+                    contextUsagePercentage = cue.contextUsagePercentage;
+                }
+            }
+        }
+        if (currentToolCall) {
+            toolCalls.push(currentToolCall);
+            currentToolCall = null;
+        }
+        if (thinkingRequested && streamState.buffer) {
+            if (streamState.inThinking) {
+                for (const ev of createThinkingDeltaEvents(streamState.buffer, streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                streamState.buffer = '';
+                for (const ev of createThinkingDeltaEvents('', streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                for (const ev of stopBlock(streamState.thinkingBlockIndex, streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+            }
+            else {
+                for (const ev of createTextDeltaEvents(streamState.buffer, streamState)) {
+                    const _c = convertToOpenAI(ev, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                streamState.buffer = '';
+            }
+        }
+        for (const ev of stopBlock(streamState.textBlockIndex, streamState)) {
+            const _c = convertToOpenAI(ev, conversationId, model);
+            if (_c !== null)
+                yield _c;
+        }
+        const bracketToolCalls = parseBracketToolCalls(totalContent);
+        if (bracketToolCalls.length > 0) {
+            for (const btc of bracketToolCalls) {
+                toolCalls.push({
+                    toolUseId: btc.toolUseId,
+                    name: btc.name,
+                    input: typeof btc.input === 'string' ? btc.input : JSON.stringify(btc.input)
+                });
+            }
+        }
+        if (toolCalls.length > 0) {
+            const baseIndex = streamState.nextBlockIndex;
+            for (let i = 0; i < toolCalls.length; i++) {
+                const tc = toolCalls[i];
+                if (!tc)
+                    continue;
+                const blockIndex = baseIndex + i;
+                {
+                    const _c = convertToOpenAI({
+                        type: 'content_block_start',
+                        index: blockIndex,
+                        content_block: {
+                            type: 'tool_use',
+                            id: tc.toolUseId,
+                            name: tc.name,
+                            input: {}
+                        }
+                    }, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                let inputJson;
+                try {
+                    const parsed = JSON.parse(tc.input);
+                    inputJson = JSON.stringify(parsed);
+                }
+                catch (e) {
+                    inputJson = tc.input;
+                }
+                {
+                    const _c = convertToOpenAI({
+                        type: 'content_block_delta',
+                        index: blockIndex,
+                        delta: {
+                            type: 'input_json_delta',
+                            partial_json: inputJson
+                        }
+                    }, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+                {
+                    const _c = convertToOpenAI({ type: 'content_block_stop', index: blockIndex }, conversationId, model);
+                    if (_c !== null)
+                        yield _c;
+                }
+            }
+        }
+        outputTokens = estimateTokens(textOnlyContent);
+        if (contextUsagePercentage !== null && contextUsagePercentage > 0) {
+            const contextWindow = getContextWindowSize(model);
+            const totalTokens = Math.round((contextWindow * contextUsagePercentage) / 100);
+            inputTokens = Math.max(0, totalTokens - outputTokens);
+        }
+        {
+            const _c = convertToOpenAI({
+                type: 'message_delta',
+                delta: { stop_reason: toolCalls.length > 0 ? 'tool_use' : 'end_turn' },
+                usage: {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    cache_creation_input_tokens: 0,
+                    cache_read_input_tokens: 0
+                }
+            }, conversationId, model);
+            if (_c !== null)
+                yield _c;
+        }
+        {
+            const _c = convertToOpenAI({ type: 'message_stop' }, conversationId, model);
+            if (_c !== null)
+                yield _c;
+        }
+    }
+    catch (e) {
+        throw e;
+    }
+}

package/dist/plugin/streaming/stream-parser.d.ts

@@ -0,0 +1,5 @@
+export declare function parseStreamBuffer(buffer: string): {
+    events: any[];
+    remaining: string;
+};
+export declare function findRealTag(buffer: string, tag: string): number;

package/dist/plugin/streaming/stream-parser.js

@@ -0,0 +1,136 @@
+import { parseEventLine } from '../../infrastructure/transformers/event-stream-parser.js';
+export function parseStreamBuffer(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) {
+            remaining = remaining.substring(jsonStart);
+            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) {
+            remaining = '';
+            break;
+        }
+    }
+    if (searchStart > 0 && remaining.length > 0) {
+        remaining = remaining.substring(searchStart);
+    }
+    return { events, remaining };
+}
+export function findRealTag(buffer, tag) {
+    const codeBlockPattern = /```[\s\S]*?```/g;
+    const codeBlocks = [];
+    let match;
+    while ((match = codeBlockPattern.exec(buffer)) !== null) {
+        codeBlocks.push([match.index, match.index + match[0].length]);
+    }
+    let pos = 0;
+    while ((pos = buffer.indexOf(tag, pos)) !== -1) {
+        let inCodeBlock = false;
+        for (const [start, end] of codeBlocks) {
+            if (pos >= start && pos < end) {
+                inCodeBlock = true;
+                break;
+            }
+        }
+        if (!inCodeBlock) {
+            return pos;
+        }
+        pos += tag.length;
+    }
+    return -1;
+}

package/dist/plugin/streaming/stream-state.d.ts

@@ -0,0 +1,5 @@
+import { StreamEvent, StreamState } from './types.js';
+export declare function ensureBlockStart(blockType: 'thinking' | 'text', streamState: StreamState): StreamEvent[];
+export declare function stopBlock(index: number | null, streamState: StreamState): StreamEvent[];
+export declare function createTextDeltaEvents(text: string, streamState: StreamState): StreamEvent[];
+export declare function createThinkingDeltaEvents(thinking: string, streamState: StreamState): StreamEvent[];

package/dist/plugin/streaming/stream-state.js

@@ -0,0 +1,59 @@
+export function ensureBlockStart(blockType, streamState) {
+    if (blockType === 'thinking') {
+        if (streamState.thinkingBlockIndex != null)
+            return [];
+        const idx = streamState.nextBlockIndex++;
+        streamState.thinkingBlockIndex = idx;
+        return [
+            {
+                type: 'content_block_start',
+                index: idx,
+                content_block: { type: 'thinking', thinking: '' }
+            }
+        ];
+    }
+    if (blockType === 'text') {
+        if (streamState.textBlockIndex != null)
+            return [];
+        const idx = streamState.nextBlockIndex++;
+        streamState.textBlockIndex = idx;
+        return [
+            {
+                type: 'content_block_start',
+                index: idx,
+                content_block: { type: 'text', text: '' }
+            }
+        ];
+    }
+    return [];
+}
+export function stopBlock(index, streamState) {
+    if (index == null)
+        return [];
+    if (streamState.stoppedBlocks.has(index))
+        return [];
+    streamState.stoppedBlocks.add(index);
+    return [{ type: 'content_block_stop', index }];
+}
+export function createTextDeltaEvents(text, streamState) {
+    if (!text)
+        return [];
+    const events = [];
+    events.push(...ensureBlockStart('text', streamState));
+    events.push({
+        type: 'content_block_delta',
+        index: streamState.textBlockIndex,
+        delta: { type: 'text_delta', text }
+    });
+    return events;
+}
+export function createThinkingDeltaEvents(thinking, streamState) {
+    const events = [];
+    events.push(...ensureBlockStart('thinking', streamState));
+    events.push({
+        type: 'content_block_delta',
+        index: streamState.thinkingBlockIndex,
+        delta: { type: 'thinking_delta', thinking }
+    });
+    return events;
+}

package/dist/plugin/streaming/stream-transformer.d.ts

@@ -0,0 +1 @@
+export declare function transformKiroStream(response: Response, model: string, conversationId: string): AsyncGenerator<any>;