@pikoloo/codex-proxy 1.0.6

package/src/kilo-format-converter.js

@@ -0,0 +1,285 @@
+/**
+ * Kilo Format Converter
+ * Converts between Anthropic Messages API and OpenAI Chat Completions format
+ */
+
+import { cleanCacheControl } from './thinking-utils.js';
+import { toAnthropicToolId, toOpenAIToolId } from './format-converter.js';
+
+function extractSystemPrompt(system) {
+    if (!system) return [];
+    if (typeof system === 'string') return [{ role: 'system', content: system }];
+    if (Array.isArray(system)) {
+        const text = system
+            .filter(block => block.type === 'text')
+            .map(block => block.text)
+            .join('\n\n');
+        return text ? [{ role: 'system', content: text }] : [];
+    }
+    return [];
+}
+
+function sanitizeSchema(schema) {
+    if (typeof schema !== 'object' || schema === null) {
+        return { type: 'object' };
+    }
+
+    const result = {};
+
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'const') {
+            result.enum = [value];
+            continue;
+        }
+
+        if ([
+            '$schema', '$id', '$ref', '$defs', '$comment',
+            'additionalItems', 'definitions', 'examples',
+            'minLength', 'maxLength', 'pattern', 'format',
+            'minItems', 'maxItems', 'minimum', 'maximum',
+            'exclusiveMinimum', 'exclusiveMaximum',
+            'allOf', 'anyOf', 'oneOf', 'not'
+        ].includes(key)) {
+            continue;
+        }
+
+        if (key === 'additionalProperties' && typeof value === 'boolean') {
+            continue;
+        }
+
+        if (key === 'type' && Array.isArray(value)) {
+            const nonNullTypes = value.filter(t => t !== 'null');
+            result.type = nonNullTypes.length > 0 ? nonNullTypes[0] : 'string';
+            continue;
+        }
+
+        if (key === 'properties' && value && typeof value === 'object') {
+            result.properties = {};
+            for (const [propKey, propValue] of Object.entries(value)) {
+                result.properties[propKey] = sanitizeSchema(propValue);
+            }
+            continue;
+        }
+
+        if (key === 'items') {
+            if (Array.isArray(value)) {
+                result.items = value.map(item => sanitizeSchema(item));
+            } else if (typeof value === 'object') {
+                result.items = sanitizeSchema(value);
+            } else {
+                result.items = value;
+            }
+            continue;
+        }
+
+        if (key === 'required' && Array.isArray(value)) {
+            result.required = value;
+            continue;
+        }
+
+        if (key === 'enum' && Array.isArray(value)) {
+            result.enum = value;
+            continue;
+        }
+
+        if (['type', 'description', 'title'].includes(key)) {
+            result[key] = value;
+        }
+    }
+
+    if (!result.type) {
+        result.type = 'object';
+    }
+
+    if (result.type === 'object' && !result.properties) {
+        result.properties = {};
+    }
+
+    return result;
+}
+
+function convertTools(tools) {
+    if (!Array.isArray(tools)) return undefined;
+    return tools.map(tool => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description || '',
+            parameters: sanitizeSchema(tool.input_schema || { type: 'object' })
+        }
+    }));
+}
+
+function convertToolChoice(toolChoice) {
+    if (!toolChoice) return undefined;
+    if (typeof toolChoice === 'string') return toolChoice;
+    if (toolChoice.type === 'tool' && toolChoice.name) {
+        return { type: 'function', function: { name: toolChoice.name } };
+    }
+    return undefined;
+}
+
+function normalizeTextBlocks(content) {
+    if (typeof content === 'string') return [content];
+    if (!Array.isArray(content)) return [];
+    return content.filter(block => block.type === 'text').map(block => block.text);
+}
+
+function normalizeToolResultContent(block) {
+    if (typeof block.content === 'string') return block.content;
+    if (Array.isArray(block.content)) {
+        return block.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+    }
+    if (block.content && typeof block.content === 'object') {
+        return JSON.stringify(block.content);
+    }
+    return '';
+}
+
+function convertMessages(messages = []) {
+    // Clean cache_control from messages first
+    const cleanedMessages = cleanCacheControl(messages);
+    
+    const output = [];
+
+    for (const msg of cleanedMessages) {
+        if (msg.role === 'user') {
+            const textParts = normalizeTextBlocks(msg.content);
+            if (textParts.length > 0) {
+                output.push({ role: 'user', content: textParts.join('\n\n') });
+            }
+
+            if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_result') {
+                        output.push({
+                            role: 'tool',
+                            tool_call_id: toOpenAIToolId(block.tool_use_id),
+                            content: normalizeToolResultContent(block)
+                        });
+                    }
+                }
+            }
+        }
+
+        if (msg.role === 'assistant') {
+            const textParts = normalizeTextBlocks(msg.content);
+            const toolCalls = [];
+
+            if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_use') {
+                        const openAIId = toOpenAIToolId(block.id);
+                        toolCalls.push({
+                            id: openAIId,
+                            type: 'function',
+                            function: {
+                                name: block.name,
+                                arguments: typeof block.input === 'string'
+                                    ? block.input
+                                    : JSON.stringify(block.input || {})
+                            }
+                        });
+                    }
+                }
+            }
+
+            if (textParts.length > 0 || toolCalls.length > 0) {
+                const message = {
+                    role: 'assistant',
+                    content: textParts.length > 0 ? textParts.join('\n\n') : null
+                };
+
+                if (toolCalls.length > 0) {
+                    message.tool_calls = toolCalls;
+                }
+
+                output.push(message);
+            }
+        }
+    }
+
+    return output;
+}
+
+export function convertAnthropicToOpenAIChat(anthropicRequest, targetModel) {
+    const { system, messages, tools, tool_choice, max_tokens, temperature, top_p, stop_sequences, stream } = anthropicRequest;
+
+    const convertedMessages = [
+        ...extractSystemPrompt(system),
+        ...convertMessages(messages || [])
+    ];
+
+    const request = {
+        model: targetModel,
+        messages: convertedMessages,
+        stream: stream !== false
+    };
+
+    if (typeof max_tokens === 'number') request.max_tokens = max_tokens;
+    if (typeof temperature === 'number') request.temperature = temperature;
+    if (typeof top_p === 'number') request.top_p = top_p;
+    if (Array.isArray(stop_sequences) && stop_sequences.length > 0) request.stop = stop_sequences;
+
+    const convertedTools = convertTools(tools);
+    if (convertedTools?.length) request.tools = convertedTools;
+
+    const convertedToolChoice = convertToolChoice(tool_choice);
+    if (convertedToolChoice) request.tool_choice = convertedToolChoice;
+
+    return request;
+}
+
+export function convertOpenAIChatToAnthropic(openAiResponse) {
+    const message = openAiResponse?.choices?.[0]?.message || {};
+    const content = [];
+
+    if (message.reasoning || message.reasoning_content) {
+        content.push({ 
+            type: 'thinking', 
+            thinking: message.reasoning || message.reasoning_content,
+            signature: 'kilo-reasoning' // Placeholder signature
+        });
+    }
+
+    if (message.content) {
+        content.push({ type: 'text', text: message.content });
+    }
+
+    if (Array.isArray(message.tool_calls)) {
+        for (const call of message.tool_calls) {
+            let input = {};
+            try {
+                input = typeof call.function?.arguments === 'string'
+                    ? JSON.parse(call.function.arguments)
+                    : call.function?.arguments || {};
+            } catch (error) {
+                input = {};
+            }
+
+            content.push({
+                type: 'tool_use',
+                id: toAnthropicToolId(call.id),
+                name: call.function?.name || 'unknown',
+                input
+            });
+        }
+    }
+
+    const finishReason = openAiResponse?.choices?.[0]?.finish_reason;
+    const stopReason = finishReason === 'tool_calls' ? 'tool_use' : 'end_turn';
+
+    return {
+        content: content.length > 0 ? content : [{ type: 'text', text: '' }],
+        stopReason,
+        usage: {
+            input_tokens: openAiResponse?.usage?.prompt_tokens || 0,
+            output_tokens: openAiResponse?.usage?.completion_tokens || 0
+        }
+    };
+}
+
+export default {
+    convertAnthropicToOpenAIChat,
+    convertOpenAIChatToAnthropic
+};

package/src/kilo-models.js

@@ -0,0 +1,103 @@
+/**
+ * Kilo Models
+ * Fetches and caches available free models from the Kilo API.
+ */
+
+const KILO_MODELS_URL = 'https://api.kilo.ai/api/openrouter/models';
+const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+let cachedModels = null;
+let cacheTimestamp = 0;
+
+const KILO_HEADERS = {
+    Authorization: 'Bearer anonymous',
+    'HTTP-Referer': 'https://kilo.ai'
+};
+
+/**
+ * Fetch all models from Kilo API and filter to free ones with tool support.
+ * Results are cached for 10 minutes.
+ * @returns {Promise<Array<{id: string, name: string, context_length: number}>>}
+ */
+export async function fetchFreeModels() {
+    const now = Date.now();
+    if (cachedModels && (now - cacheTimestamp) < CACHE_TTL_MS) {
+        return cachedModels;
+    }
+
+    try {
+        const response = await fetch(KILO_MODELS_URL, {
+            headers: KILO_HEADERS
+        });
+
+        if (!response.ok) {
+            console.warn(`[KiloModels] Failed to fetch models: ${response.status}`);
+            return cachedModels || getHardcodedFallback();
+        }
+
+        const data = await response.json();
+        const allModels = data?.data || [];
+
+        const freeModels = allModels
+            .filter(m => m.isFree === true)
+            .filter(m => !m.id.includes('deprecated') && m.id !== 'kilo/auto-free')
+            .map(m => ({
+                id: m.id,
+                name: m.name || m.id,
+                context_length: m.context_length || 0,
+                supportsTools: (m.supported_parameters || []).includes('tools')
+            }));
+
+        cachedModels = freeModels;
+        cacheTimestamp = now;
+        console.log(`[KiloModels] Fetched ${freeModels.length} free models from API`);
+        return freeModels;
+    } catch (error) {
+        console.warn(`[KiloModels] Error fetching models: ${error.message}`);
+        return cachedModels || getHardcodedFallback();
+    }
+}
+
+/**
+ * Get the list of free model IDs (just the id strings).
+ * @returns {Promise<string[]>}
+ */
+export async function getFreeModelIds() {
+    const models = await fetchFreeModels();
+    return models.map(m => m.id);
+}
+
+/**
+ * Check if a given model ID is currently free.
+ * @param {string} modelId
+ * @returns {Promise<boolean>}
+ */
+export async function isModelFree(modelId) {
+    const models = await fetchFreeModels();
+    return models.some(m => m.id === modelId);
+}
+
+/**
+ * Invalidate the cache (e.g. after a failed request).
+ */
+export function invalidateCache() {
+    cachedModels = null;
+    cacheTimestamp = 0;
+}
+
+/**
+ * Hardcoded fallback in case the API is unreachable.
+ */
+function getHardcodedFallback() {
+    return [
+        { id: 'minimax/minimax-m2.5:free', name: 'MiniMax M2.5', context_length: 204800, supportsTools: true },
+        { id: 'kilo-auto/free', name: 'Kilo Auto Free', context_length: 204800, supportsTools: true }
+    ];
+}
+
+export default {
+    fetchFreeModels,
+    getFreeModelIds,
+    isModelFree,
+    invalidateCache
+};

package/src/kilo-streamer.js

@@ -0,0 +1,243 @@
+/**
+ * Kilo Streamer
+ * Streams OpenAI Chat Completions SSE and converts to Anthropic SSE events
+ */
+
+import { generateMessageId, toAnthropicToolId } 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 startThinkingBlock = () => {
+        currentBlockType = 'thinking';
+        currentToolCallId = null;
+        currentToolName = null;
+        return emitContentBlockStart({ type: 'thinking', thinking: '' });
+    };
+
+    const startToolBlock = (toolCall) => {
+        currentBlockType = 'tool_use';
+        const rawId = toolCall.id || `call_${Math.random().toString(36).slice(2)}`;
+        currentToolCallId = toAnthropicToolId(rawId);
+        currentToolName = toolCall.function?.name || 'tool';
+        stopReason = 'tool_use';
+        return emitContentBlockStart({
+            type: 'tool_use',
+            id: currentToolCallId,
+            name: currentToolName,
+            input: {}
+        });
+    };
+
+    const handleDelta = (delta) => {
+        const events = [];
+
+        // Handle reasoning/thinking content (from models like MiniMax M2.5)
+        const reasoningContent = delta.reasoning || delta.reasoning_content;
+        if (reasoningContent) {
+            if (!hasEmittedStart) {
+                hasEmittedStart = true;
+                events.push(emitMessageStart());
+                events.push(startThinkingBlock());
+            } else if (currentBlockType !== 'thinking') {
+                if (currentBlockType === 'thinking') {
+                    events.push(emitContentBlockDelta({ type: 'signature_delta', signature: 'kilo-reasoning' }));
+                }
+                events.push(emitContentBlockStop());
+                blockIndex++;
+                events.push(startThinkingBlock());
+            }
+
+            events.push(emitContentBlockDelta({ type: 'thinking_delta', thinking: reasoningContent }));
+        }
+
+        const shouldStartText = (delta.content !== undefined && delta.content !== null) && (
+            delta.content.length > 0 || (!hasEmittedStart && !reasoningContent)
+        );
+
+        if (shouldStartText) {
+            if (!hasEmittedStart) {
+                hasEmittedStart = true;
+                events.push(emitMessageStart());
+                events.push(startTextBlock());
+            } else if (currentBlockType !== 'text') {
+                if (currentBlockType === 'thinking') {
+                    events.push(emitContentBlockDelta({ type: 'signature_delta', signature: 'kilo-reasoning' }));
+                }
+                events.push(emitContentBlockStop());
+                blockIndex++;
+                events.push(startTextBlock());
+            }
+
+            if (delta.content.length > 0) {
+                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());
+                }
+
+                const toolId = toolCall.id ? toAnthropicToolId(toolCall.id) : currentToolCallId;
+
+                if (currentBlockType !== 'tool_use' || currentToolCallId !== toolId) {
+                    if (currentBlockType) {
+                        if (currentBlockType === 'thinking') {
+                            events.push(emitContentBlockDelta({ type: 'signature_delta', signature: 'kilo-reasoning' }));
+                        }
+                        events.push(emitContentBlockStop());
+                        blockIndex++;
+                    }
+                    events.push(startToolBlock(toolCall));
+                }
+
+                const argsDelta = toolCall.function?.arguments || '';
+                if (argsDelta) {
+                    const callIdForArgs = toolCall.id || currentToolCallId;
+                    const prev = pendingToolArgs.get(callIdForArgs) || '';
+                    pendingToolArgs.set(callIdForArgs, 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) {
+        if (currentBlockType === 'thinking') {
+            yield emitContentBlockDelta({ type: 'signature_delta', signature: 'kilo-reasoning' });
+        }
+        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
+};