codex-claude-proxy 1.0.0

package/src/kilo-streamer.js

@@ -0,0 +1,198 @@
+/**
+ * Kilo Streamer
+ * Streams OpenAI Chat Completions SSE and converts to Anthropic SSE events
+ */
+
+import { generateMessageId } from './format-converter.js';
+
+export async function* streamOpenAIChat(response, model) {
+    const messageId = generateMessageId();
+    let hasEmittedStart = false;
+    let blockIndex = 0;
+    let currentBlockType = null;
+    let currentToolCallId = null;
+    let currentToolName = null;
+    let pendingToolArgs = new Map();
+    let stopReason = 'end_turn';
+    let usage = { input_tokens: 0, output_tokens: 0 };
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    const emitMessageStart = () => ({
+        event: 'message_start',
+        data: {
+            type: 'message_start',
+            message: {
+                id: messageId,
+                type: 'message',
+                role: 'assistant',
+                model,
+                content: [],
+                stop_reason: null,
+                stop_sequence: null,
+                usage: { input_tokens: 0, output_tokens: 0 }
+            }
+        }
+    });
+
+    const emitContentBlockStart = (contentBlock) => ({
+        event: 'content_block_start',
+        data: {
+            type: 'content_block_start',
+            index: blockIndex,
+            content_block: contentBlock
+        }
+    });
+
+    const emitContentBlockDelta = (delta) => ({
+        event: 'content_block_delta',
+        data: {
+            type: 'content_block_delta',
+            index: blockIndex,
+            delta
+        }
+    });
+
+    const emitContentBlockStop = () => ({
+        event: 'content_block_stop',
+        data: { type: 'content_block_stop', index: blockIndex }
+    });
+
+    const startTextBlock = () => {
+        currentBlockType = 'text';
+        currentToolCallId = null;
+        currentToolName = null;
+        return emitContentBlockStart({ type: 'text', text: '' });
+    };
+
+    const startToolBlock = (toolCall) => {
+        currentBlockType = 'tool_use';
+        currentToolCallId = toolCall.id;
+        currentToolName = toolCall.function?.name || 'tool';
+        stopReason = 'tool_use';
+        return emitContentBlockStart({
+            type: 'tool_use',
+            id: currentToolCallId,
+            name: currentToolName,
+            input: {}
+        });
+    };
+
+    const handleDelta = (delta) => {
+        const events = [];
+
+        if (delta.content) {
+            if (!hasEmittedStart) {
+                hasEmittedStart = true;
+                events.push(emitMessageStart());
+                events.push(startTextBlock());
+            } else if (currentBlockType !== 'text') {
+                events.push(emitContentBlockStop());
+                blockIndex++;
+                events.push(startTextBlock());
+            }
+
+            events.push(emitContentBlockDelta({ type: 'text_delta', text: delta.content }));
+        }
+
+        if (Array.isArray(delta.tool_calls)) {
+            for (const toolCall of delta.tool_calls) {
+                if (!hasEmittedStart) {
+                    hasEmittedStart = true;
+                    events.push(emitMessageStart());
+                }
+
+                if (currentBlockType !== 'tool_use' || currentToolCallId !== toolCall.id) {
+                    if (currentBlockType) {
+                        events.push(emitContentBlockStop());
+                        blockIndex++;
+                    }
+                    events.push(startToolBlock(toolCall));
+                }
+
+                const argsDelta = toolCall.function?.arguments || '';
+                if (argsDelta) {
+                    const prev = pendingToolArgs.get(toolCall.id) || '';
+                    pendingToolArgs.set(toolCall.id, prev + argsDelta);
+                    events.push(emitContentBlockDelta({
+                        type: 'input_json_delta',
+                        partial_json: argsDelta
+                    }));
+                }
+            }
+        }
+
+        return events;
+    };
+
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+            if (!line.startsWith('data:')) continue;
+            const jsonText = line.slice(5).trim();
+            if (!jsonText) continue;
+            if (jsonText === '[DONE]') continue;
+
+            try {
+                const chunk = JSON.parse(jsonText);
+
+                if (chunk.usage) {
+                    usage = {
+                        input_tokens: chunk.usage.prompt_tokens || 0,
+                        output_tokens: chunk.usage.completion_tokens || 0
+                    };
+                }
+
+                const choice = chunk.choices?.[0];
+                if (!choice) continue;
+
+                const events = handleDelta(choice.delta || {});
+                for (const evt of events) {
+                    yield evt;
+                }
+
+                if (choice.finish_reason) {
+                    stopReason = choice.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn';
+                }
+            } catch (err) {
+                // ignore malformed chunks
+            }
+        }
+    }
+
+    if (!hasEmittedStart) {
+        hasEmittedStart = true;
+        yield emitMessageStart();
+        yield emitContentBlockStart({ type: 'text', text: '' });
+        yield emitContentBlockDelta({ type: 'text_delta', text: '' });
+        yield emitContentBlockStop();
+    } else if (currentBlockType) {
+        yield emitContentBlockStop();
+    }
+
+    yield {
+        event: 'message_delta',
+        data: {
+            type: 'message_delta',
+            delta: { stop_reason: stopReason, stop_sequence: null },
+            usage
+        }
+    };
+
+    yield {
+        event: 'message_stop',
+        data: { type: 'message_stop' }
+    };
+}
+
+export default {
+    streamOpenAIChat
+};

package/src/model-api.js

@@ -0,0 +1,189 @@
+/**
+ * Model API for ChatGPT Codex
+ * Handles model listing and quota retrieval from ChatGPT backend API.
+ */
+
+const CHATGPT_API_BASE = 'https://chatgpt.com/backend-api';
+const CLIENT_VERSION = '0.100.0';
+
+const MODEL_CACHE = {
+    models: null,
+    lastFetched: 0,
+    ttlMs: 5 * 60 * 1000
+};
+
+export async function fetchModels(accessToken, accountId) {
+    const now = Date.now();
+    
+    if (MODEL_CACHE.models && (now - MODEL_CACHE.lastFetched) < MODEL_CACHE.ttlMs) {
+        return MODEL_CACHE.models;
+    }
+    
+    const url = `${CHATGPT_API_BASE}/codex/models?client_version=${CLIENT_VERSION}`;
+    
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'ChatGPT-Account-ID': accountId,
+            'Accept': 'application/json'
+        }
+    });
+    
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to fetch models: ${response.status} - ${errorText}`);
+    }
+    
+    const data = await response.json();
+    
+    const models = (data.models || []).map(m => ({
+        id: m.slug,
+        name: m.display_name || m.slug,
+        description: m.description || '',
+        defaultReasoningLevel: m.default_reasoning_level || 'medium',
+        supportedReasoningLevels: m.supported_reasoning_levels || [],
+        supportedInApi: m.supported_in_api || false,
+        visibility: m.visibility || 'list'
+    }));
+    
+    MODEL_CACHE.models = models;
+    MODEL_CACHE.lastFetched = now;
+    
+    return models;
+}
+
+export async function fetchUsage(accessToken, accountId) {
+    const url = `${CHATGPT_API_BASE}/wham/usage`;
+    
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'ChatGPT-Account-ID': accountId,
+            'Accept': 'application/json'
+        }
+    });
+    
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to fetch usage: ${response.status} - ${errorText}`);
+    }
+    
+    const data = await response.json();
+    
+    const primaryWindow = data.rate_limit?.primary_window || {};
+    const usedPercentRaw = Number(primaryWindow?.used_percent);
+    const usedPercent = Number.isFinite(usedPercentRaw) ? usedPercentRaw : 0;
+
+    const limitWindowSecondsRaw = Number(primaryWindow?.limit_window_seconds);
+    const limitWindowSeconds = Number.isFinite(limitWindowSecondsRaw) ? limitWindowSecondsRaw : null;
+
+    const resetAfterSecondsRaw = Number(primaryWindow?.reset_after_seconds);
+    const resetAfterSeconds = Number.isFinite(resetAfterSecondsRaw) ? resetAfterSecondsRaw : null;
+
+    const resetAtEpoch = Number(primaryWindow?.reset_at);
+    const resetAt = Number.isFinite(resetAtEpoch) ? new Date(resetAtEpoch * 1000).toISOString() : null;
+    
+    return {
+        totalTokenUsage: usedPercent,
+        limit: 100,
+        remaining: 100 - usedPercent,
+        percentage: usedPercent,
+        resetAt: resetAt,
+        resetAfterSeconds: resetAfterSeconds,
+        limitWindowSeconds: limitWindowSeconds,
+        planType: data.plan_type || null,
+        limitReached: data.rate_limit?.limit_reached || false,
+        allowed: data.rate_limit?.allowed ?? true,
+        raw: data
+    };
+}
+
+export async function fetchAccountCheck(accessToken, accountId) {
+    const url = `${CHATGPT_API_BASE}/wham/accounts/check`;
+    
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'ChatGPT-Account-ID': accountId,
+            'Accept': 'application/json'
+        }
+    });
+    
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to fetch account check: ${response.status} - ${errorText}`);
+    }
+    
+    return await response.json();
+}
+
+export async function getAccountQuota(accessToken, accountId) {
+    try {
+        const [usage, accountCheck] = await Promise.allSettled([
+            fetchUsage(accessToken, accountId),
+            fetchAccountCheck(accessToken, accountId)
+        ]);
+        
+        const quotaInfo = {
+            usage: usage.status === 'fulfilled' ? usage.value : null,
+            account: accountCheck.status === 'fulfilled' ? accountCheck.value : null,
+            fetchedAt: new Date().toISOString()
+        };
+        
+        if (usage.status === 'rejected') {
+            quotaInfo.usageError = usage.reason?.message || 'Unknown error';
+        }
+        
+        if (accountCheck.status === 'rejected') {
+            quotaInfo.accountError = accountCheck.reason?.message || 'Unknown error';
+        }
+        
+        return quotaInfo;
+    } catch (error) {
+        return {
+            usage: null,
+            account: null,
+            error: error.message,
+            fetchedAt: new Date().toISOString()
+        };
+    }
+}
+
+export async function getModelsAndQuota(accessToken, accountId) {
+    try {
+        const [models, quota] = await Promise.all([
+            fetchModels(accessToken, accountId),
+            getAccountQuota(accessToken, accountId)
+        ]);
+        
+        return {
+            models,
+            quota,
+            success: true
+        };
+    } catch (error) {
+        return {
+            models: null,
+            quota: null,
+            error: error.message,
+            success: false
+        };
+    }
+}
+
+export function clearModelCache() {
+    MODEL_CACHE.models = null;
+    MODEL_CACHE.lastFetched = 0;
+}
+
+export default {
+    fetchModels,
+    fetchUsage,
+    fetchAccountCheck,
+    getAccountQuota,
+    getModelsAndQuota,
+    clearModelCache
+};