@blockrun/franklin 3.0.0

package/dist/proxy/sse-translator.js

@@ -0,0 +1,270 @@
+/**
+ * SSE Event Translator: OpenAI → Anthropic Messages API format
+ *
+ * Handles three critical gaps in the streaming pipeline:
+ * 1. Tool calls: choice.delta.tool_calls → content_block_start/content_block_delta (tool_use)
+ * 2. Reasoning: reasoning_content → content_block_start/content_block_delta (thinking)
+ * 3. Ensures proper content_block_stop and message_stop events
+ */
+// ─── SSE Translator ─────────────────────────────────────────────────────────
+export class SSETranslator {
+    state;
+    buffer = '';
+    constructor(model = 'unknown') {
+        this.state = {
+            messageId: `msg_runcode_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            model,
+            blockIndex: 0,
+            activeToolCalls: new Map(),
+            thinkingBlockActive: false,
+            textBlockActive: false,
+            messageStarted: false,
+            inputTokens: 0,
+            outputTokens: 0,
+        };
+    }
+    /**
+     * Detect whether an SSE chunk is in OpenAI format.
+     * Returns true if it contains OpenAI-style `choices[].delta` structure.
+     */
+    static isOpenAIFormat(chunk) {
+        return (chunk.includes('"choices"') &&
+            chunk.includes('"delta"') &&
+            !chunk.includes('"content_block_'));
+    }
+    /**
+     * Process a raw SSE text chunk and return translated Anthropic-format SSE events.
+     * Returns null if no translation needed (already Anthropic format or not parseable).
+     */
+    processChunk(rawChunk) {
+        this.buffer += rawChunk;
+        const events = this.parseSSEEvents();
+        if (events.length === 0)
+            return null;
+        const translated = [];
+        for (const event of events) {
+            if (event.data === '[DONE]') {
+                translated.push(...this.closeActiveBlocks());
+                translated.push(this.formatSSE('message_delta', {
+                    type: 'message_delta',
+                    delta: { stop_reason: 'end_turn', stop_sequence: null },
+                    usage: { output_tokens: this.state.outputTokens },
+                }));
+                translated.push(this.formatSSE('message_stop', { type: 'message_stop' }));
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(event.data);
+            }
+            catch {
+                continue;
+            }
+            // Skip if not OpenAI format
+            const choices = parsed.choices;
+            if (!choices || choices.length === 0) {
+                // Could be a usage-only event
+                const usage = parsed.usage;
+                if (usage) {
+                    this.state.inputTokens = usage.prompt_tokens ?? 0;
+                    this.state.outputTokens = usage.completion_tokens ?? 0;
+                }
+                continue;
+            }
+            // Emit message_start on first chunk
+            if (!this.state.messageStarted) {
+                this.state.messageStarted = true;
+                if (parsed.model)
+                    this.state.model = parsed.model;
+                translated.push(this.formatSSE('message_start', {
+                    type: 'message_start',
+                    message: {
+                        id: this.state.messageId,
+                        type: 'message',
+                        role: 'assistant',
+                        model: this.state.model,
+                        content: [],
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: this.state.inputTokens, output_tokens: 0 },
+                    },
+                }));
+                translated.push(this.formatSSE('ping', { type: 'ping' }));
+            }
+            const choice = choices[0];
+            const delta = choice.delta;
+            // ── Reasoning content → thinking block ──
+            if (delta.reasoning_content) {
+                if (!this.state.thinkingBlockActive) {
+                    if (this.state.textBlockActive)
+                        translated.push(...this.closeTextBlock());
+                    this.state.thinkingBlockActive = true;
+                    translated.push(this.formatSSE('content_block_start', {
+                        type: 'content_block_start',
+                        index: this.state.blockIndex,
+                        content_block: { type: 'thinking', thinking: '' },
+                    }));
+                }
+                translated.push(this.formatSSE('content_block_delta', {
+                    type: 'content_block_delta',
+                    index: this.state.blockIndex,
+                    delta: { type: 'thinking_delta', thinking: delta.reasoning_content },
+                }));
+                this.state.outputTokens++;
+            }
+            // ── Text content → text block ──
+            if (delta.content) {
+                if (this.state.thinkingBlockActive)
+                    translated.push(...this.closeThinkingBlock());
+                if (!this.state.textBlockActive) {
+                    translated.push(...this.closeToolCalls());
+                    this.state.textBlockActive = true;
+                    translated.push(this.formatSSE('content_block_start', {
+                        type: 'content_block_start',
+                        index: this.state.blockIndex,
+                        content_block: { type: 'text', text: '' },
+                    }));
+                }
+                translated.push(this.formatSSE('content_block_delta', {
+                    type: 'content_block_delta',
+                    index: this.state.blockIndex,
+                    delta: { type: 'text_delta', text: delta.content },
+                }));
+                this.state.outputTokens++;
+            }
+            // ── Tool calls → tool_use blocks ──
+            const toolCalls = delta.tool_calls;
+            if (toolCalls && toolCalls.length > 0) {
+                if (this.state.thinkingBlockActive)
+                    translated.push(...this.closeThinkingBlock());
+                if (this.state.textBlockActive)
+                    translated.push(...this.closeTextBlock());
+                for (const tc of toolCalls) {
+                    const tcIndex = tc.index;
+                    const fn = tc.function;
+                    if (tc.id && fn?.name) {
+                        if (this.state.activeToolCalls.has(tcIndex)) {
+                            translated.push(this.formatSSE('content_block_stop', {
+                                type: 'content_block_stop',
+                                index: this.state.blockIndex,
+                            }));
+                            this.state.blockIndex++;
+                        }
+                        this.state.activeToolCalls.set(tcIndex, { id: tc.id, name: fn.name });
+                        translated.push(this.formatSSE('content_block_start', {
+                            type: 'content_block_start',
+                            index: this.state.blockIndex,
+                            content_block: { type: 'tool_use', id: tc.id, name: fn.name, input: {} },
+                        }));
+                        if (fn.arguments) {
+                            translated.push(this.formatSSE('content_block_delta', {
+                                type: 'content_block_delta',
+                                index: this.state.blockIndex,
+                                delta: { type: 'input_json_delta', partial_json: fn.arguments },
+                            }));
+                        }
+                    }
+                    else if (fn?.arguments) {
+                        translated.push(this.formatSSE('content_block_delta', {
+                            type: 'content_block_delta',
+                            index: this.state.blockIndex,
+                            delta: { type: 'input_json_delta', partial_json: fn.arguments },
+                        }));
+                    }
+                }
+                this.state.outputTokens++;
+            }
+            // ── Handle finish_reason ──
+            if (choice.finish_reason) {
+                translated.push(...this.closeActiveBlocks());
+                const stopReason = choice.finish_reason === 'tool_calls'
+                    ? 'tool_use'
+                    : choice.finish_reason === 'stop'
+                        ? 'end_turn'
+                        : choice.finish_reason;
+                translated.push(this.formatSSE('message_delta', {
+                    type: 'message_delta',
+                    delta: { stop_reason: stopReason, stop_sequence: null },
+                    usage: { output_tokens: this.state.outputTokens },
+                }));
+            }
+        }
+        return translated.length > 0 ? translated.join('') : null;
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────────
+    parseSSEEvents() {
+        const events = [];
+        const lines = this.buffer.split('\n');
+        let currentEvent;
+        let dataLines = [];
+        let consumed = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.startsWith('event: ')) {
+                currentEvent = line.slice(7).trim();
+            }
+            else if (line.startsWith('data: ')) {
+                dataLines.push(line.slice(6));
+            }
+            else if (line === '' && dataLines.length > 0) {
+                events.push({ event: currentEvent, data: dataLines.join('\n') });
+                currentEvent = undefined;
+                dataLines = [];
+                consumed = lines.slice(0, i + 1).join('\n').length + 1;
+            }
+        }
+        if (consumed > 0)
+            this.buffer = this.buffer.slice(consumed);
+        return events;
+    }
+    formatSSE(event, data) {
+        return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    }
+    closeThinkingBlock() {
+        if (!this.state.thinkingBlockActive)
+            return [];
+        this.state.thinkingBlockActive = false;
+        const events = [
+            this.formatSSE('content_block_stop', {
+                type: 'content_block_stop',
+                index: this.state.blockIndex,
+            }),
+        ];
+        this.state.blockIndex++;
+        return events;
+    }
+    closeTextBlock() {
+        if (!this.state.textBlockActive)
+            return [];
+        this.state.textBlockActive = false;
+        const events = [
+            this.formatSSE('content_block_stop', {
+                type: 'content_block_stop',
+                index: this.state.blockIndex,
+            }),
+        ];
+        this.state.blockIndex++;
+        return events;
+    }
+    closeToolCalls() {
+        if (this.state.activeToolCalls.size === 0)
+            return [];
+        const events = [];
+        for (const [_index] of this.state.activeToolCalls) {
+            events.push(this.formatSSE('content_block_stop', {
+                type: 'content_block_stop',
+                index: this.state.blockIndex,
+            }));
+            this.state.blockIndex++;
+        }
+        this.state.activeToolCalls.clear();
+        return events;
+    }
+    closeActiveBlocks() {
+        return [
+            ...this.closeThinkingBlock(),
+            ...this.closeTextBlock(),
+            ...this.closeToolCalls(),
+        ];
+    }
+}

package/dist/router/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Smart Router for runcode
+ * Smart Router - 15-dimension weighted scoring for tier classification
+ */
+export type Tier = 'SIMPLE' | 'MEDIUM' | 'COMPLEX' | 'REASONING';
+export type RoutingProfile = 'auto' | 'eco' | 'premium' | 'free';
+export interface RoutingResult {
+    model: string;
+    tier: Tier;
+    confidence: number;
+    signals: string[];
+    savings: number;
+}
+export declare function routeRequest(prompt: string, profile?: RoutingProfile): RoutingResult;
+/**
+ * Get fallback models for a tier
+ */
+export declare function getFallbackChain(tier: Tier, profile?: RoutingProfile): string[];
+/**
+ * Parse routing profile from model string
+ */
+export declare function parseRoutingProfile(model: string): RoutingProfile | null;

package/dist/router/index.js

@@ -0,0 +1,269 @@
+/**
+ * Smart Router for runcode
+ * Smart Router - 15-dimension weighted scoring for tier classification
+ */
+import { MODEL_PRICING, OPUS_PRICING } from '../pricing.js';
+// ─── Tier Model Configs ───
+const AUTO_TIERS = {
+    SIMPLE: {
+        primary: 'google/gemini-2.5-flash',
+        fallback: ['deepseek/deepseek-chat', 'nvidia/nemotron-ultra-253b'],
+    },
+    MEDIUM: {
+        primary: 'moonshot/kimi-k2.5',
+        fallback: ['google/gemini-2.5-flash', 'minimax/minimax-m2.7'],
+    },
+    COMPLEX: {
+        primary: 'google/gemini-3.1-pro',
+        fallback: ['anthropic/claude-sonnet-4.6', 'google/gemini-2.5-pro'],
+    },
+    REASONING: {
+        primary: 'xai/grok-4-1-fast-reasoning',
+        fallback: ['deepseek/deepseek-reasoner', 'openai/o4-mini'],
+    },
+};
+const ECO_TIERS = {
+    SIMPLE: {
+        primary: 'nvidia/nemotron-ultra-253b',
+        fallback: ['nvidia/gpt-oss-120b', 'nvidia/deepseek-v3.2'],
+    },
+    MEDIUM: {
+        primary: 'google/gemini-2.5-flash-lite',
+        fallback: ['nvidia/nemotron-ultra-253b', 'nvidia/qwen3-coder-480b'],
+    },
+    COMPLEX: {
+        primary: 'google/gemini-2.5-flash-lite',
+        fallback: ['deepseek/deepseek-chat', 'nvidia/mistral-large-3-675b'],
+    },
+    REASONING: {
+        primary: 'xai/grok-4-1-fast-reasoning',
+        fallback: ['deepseek/deepseek-reasoner', 'nvidia/nemotron-ultra-253b'],
+    },
+};
+const PREMIUM_TIERS = {
+    SIMPLE: {
+        primary: 'moonshot/kimi-k2.5',
+        fallback: ['anthropic/claude-haiku-4.5'],
+    },
+    MEDIUM: {
+        primary: 'openai/gpt-5.3-codex',
+        fallback: ['anthropic/claude-sonnet-4.6'],
+    },
+    COMPLEX: {
+        primary: 'anthropic/claude-opus-4.6',
+        fallback: ['openai/gpt-5.4', 'anthropic/claude-sonnet-4.6'],
+    },
+    REASONING: {
+        primary: 'anthropic/claude-sonnet-4.6',
+        fallback: ['anthropic/claude-opus-4.6', 'openai/o3'],
+    },
+};
+// ─── Keywords for Classification ───
+const CODE_KEYWORDS = [
+    'function', 'class', 'import', 'def', 'SELECT', 'async', 'await',
+    'const', 'let', 'var', 'return', '```', '函数', '类', '导入',
+];
+const REASONING_KEYWORDS = [
+    'prove', 'theorem', 'derive', 'step by step', 'chain of thought',
+    'formally', 'mathematical', 'proof', 'logically', '证明', '定理', '推导',
+];
+const SIMPLE_KEYWORDS = [
+    'what is', 'define', 'translate', 'hello', 'yes or no', 'capital of',
+    'how old', 'who is', 'when was', '什么是', '翻译', '你好',
+];
+const TECHNICAL_KEYWORDS = [
+    'algorithm', 'optimize', 'architecture', 'distributed', 'kubernetes',
+    'microservice', 'database', 'infrastructure', '算法', '架构', '优化',
+];
+const AGENTIC_KEYWORDS = [
+    'read file', 'edit', 'modify', 'update', 'create file', 'execute',
+    'deploy', 'install', 'npm', 'pip', 'fix', 'debug', 'verify',
+    '编辑', '修改', '部署', '安装', '修复', '调试',
+];
+function countMatches(text, keywords) {
+    const lower = text.toLowerCase();
+    return keywords.filter(kw => lower.includes(kw.toLowerCase())).length;
+}
+function classifyRequest(prompt, tokenCount) {
+    const signals = [];
+    let score = 0;
+    // Token count scoring (reduced weight - don't penalize short prompts too much)
+    if (tokenCount < 30) {
+        score -= 0.15;
+        signals.push('short');
+    }
+    else if (tokenCount > 500) {
+        score += 0.2;
+        signals.push('long');
+    }
+    // Code detection (weight: 0.20) - increased weight
+    const codeMatches = countMatches(prompt, CODE_KEYWORDS);
+    // Extra weight for code blocks (triple backticks)
+    const codeBlockCount = (prompt.match(/```/g) || []).length / 2; // pairs
+    if (codeBlockCount >= 1 || codeMatches >= 2) {
+        score += 0.5;
+        signals.push(codeBlockCount >= 1 ? 'code-block' : 'code');
+    }
+    else if (codeMatches >= 1) {
+        score += 0.25;
+        signals.push('code-light');
+    }
+    // Reasoning detection (weight: 0.18)
+    const reasoningMatches = countMatches(prompt, REASONING_KEYWORDS);
+    if (reasoningMatches >= 2) {
+        // Direct reasoning override
+        return { tier: 'REASONING', confidence: 0.9, signals: [...signals, 'reasoning'] };
+    }
+    else if (reasoningMatches >= 1) {
+        score += 0.4;
+        signals.push('reasoning-light');
+    }
+    // Simple detection (weight: -0.12) - only trigger on strong simple signals
+    const simpleMatches = countMatches(prompt, SIMPLE_KEYWORDS);
+    if (simpleMatches >= 2) {
+        score -= 0.4;
+        signals.push('simple');
+    }
+    else if (simpleMatches >= 1 && codeMatches === 0 && tokenCount < 50) {
+        // Only mark as simple if no code and very short
+        score -= 0.25;
+        signals.push('simple');
+    }
+    // Technical complexity (weight: 0.15) - increased
+    const techMatches = countMatches(prompt, TECHNICAL_KEYWORDS);
+    if (techMatches >= 2) {
+        score += 0.4;
+        signals.push('technical');
+    }
+    else if (techMatches >= 1) {
+        score += 0.2;
+        signals.push('technical-light');
+    }
+    // Agentic detection (weight: 0.10) - increased
+    const agenticMatches = countMatches(prompt, AGENTIC_KEYWORDS);
+    if (agenticMatches >= 3) {
+        score += 0.35;
+        signals.push('agentic');
+    }
+    else if (agenticMatches >= 2) {
+        score += 0.2;
+        signals.push('agentic-light');
+    }
+    // Multi-step patterns
+    if (/first.*then|step \d|\d\.\s/i.test(prompt)) {
+        score += 0.2;
+        signals.push('multi-step');
+    }
+    // Question complexity
+    const questionCount = (prompt.match(/\?/g) || []).length;
+    if (questionCount > 3) {
+        score += 0.15;
+        signals.push(`${questionCount} questions`);
+    }
+    // Imperative verbs (build, create, implement, etc.)
+    const imperativeMatches = countMatches(prompt, [
+        'build', 'create', 'implement', 'design', 'develop', 'write', 'make',
+        'generate', 'construct', '构建', '创建', '实现', '设计', '开发'
+    ]);
+    if (imperativeMatches >= 1) {
+        score += 0.15;
+        signals.push('imperative');
+    }
+    // Map score to tier (adjusted boundaries)
+    let tier;
+    if (score < -0.1) {
+        tier = 'SIMPLE';
+    }
+    else if (score < 0.25) {
+        tier = 'MEDIUM';
+    }
+    else if (score < 0.45) {
+        tier = 'COMPLEX';
+    }
+    else {
+        tier = 'REASONING';
+    }
+    // Calculate confidence based on distance from boundary
+    const confidence = Math.min(0.95, 0.7 + Math.abs(score) * 0.3);
+    return { tier, confidence, signals };
+}
+// ─── Main Router ───
+export function routeRequest(prompt, profile = 'auto') {
+    // Free profile - always use free model
+    if (profile === 'free') {
+        return {
+            model: 'nvidia/nemotron-ultra-253b',
+            tier: 'SIMPLE',
+            confidence: 1.0,
+            signals: ['free-profile'],
+            savings: 1.0,
+        };
+    }
+    // Estimate token count (use byte length / 4 for better accuracy with non-ASCII)
+    const byteLen = Buffer.byteLength(prompt, 'utf-8');
+    const tokenCount = Math.ceil(byteLen / 4);
+    // Classify the request
+    const { tier, confidence, signals } = classifyRequest(prompt, tokenCount);
+    // Select tier config based on profile
+    let tierConfigs;
+    switch (profile) {
+        case 'eco':
+            tierConfigs = ECO_TIERS;
+            break;
+        case 'premium':
+            tierConfigs = PREMIUM_TIERS;
+            break;
+        default:
+            tierConfigs = AUTO_TIERS;
+    }
+    const model = tierConfigs[tier].primary;
+    // Calculate savings estimate vs Claude Opus
+    const opusCostPer1K = (OPUS_PRICING.input + OPUS_PRICING.output) / 2 / 1000;
+    const modelPricing = MODEL_PRICING[model];
+    const modelCostPer1K = modelPricing
+        ? (modelPricing.input + modelPricing.output) / 2 / 1000
+        : 0.005;
+    const savings = Math.max(0, (opusCostPer1K - modelCostPer1K) / opusCostPer1K);
+    return {
+        model,
+        tier,
+        confidence,
+        signals,
+        savings,
+    };
+}
+/**
+ * Get fallback models for a tier
+ */
+export function getFallbackChain(tier, profile = 'auto') {
+    let tierConfigs;
+    switch (profile) {
+        case 'eco':
+            tierConfigs = ECO_TIERS;
+            break;
+        case 'premium':
+            tierConfigs = PREMIUM_TIERS;
+            break;
+        case 'free':
+            return ['nvidia/nemotron-ultra-253b'];
+        default:
+            tierConfigs = AUTO_TIERS;
+    }
+    const config = tierConfigs[tier];
+    return [config.primary, ...config.fallback];
+}
+/**
+ * Parse routing profile from model string
+ */
+export function parseRoutingProfile(model) {
+    const lower = model.toLowerCase();
+    if (lower === 'blockrun/auto' || lower === 'auto')
+        return 'auto';
+    if (lower === 'blockrun/eco' || lower === 'eco')
+        return 'eco';
+    if (lower === 'blockrun/premium' || lower === 'premium')
+        return 'premium';
+    if (lower === 'blockrun/free' || lower === 'free')
+        return 'free';
+    return null;
+}

package/dist/session/search.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Session search — find past conversations by keyword.
+ *
+ * Inspired by Hermes Agent's FTS5 search (`hermes_state.py`). For RunCode's
+ * scale (last 20 sessions) we use a lightweight in-memory tokenized search
+ * instead of SQLite FTS5 — zero install cost, same user experience.
+ */
+import type { SessionMeta } from './storage.js';
+export interface SearchMatch {
+    session: SessionMeta;
+    /** Relevance score (higher = better) */
+    score: number;
+    /** Number of times all query terms appear in this session */
+    hitCount: number;
+    /** Best snippet (~200 chars) around the first match */
+    snippet: string;
+    /** Which message role contained the match */
+    matchedRole: 'user' | 'assistant';
+}
+export interface SearchOptions {
+    /** Maximum number of results */
+    limit?: number;
+    /** Filter by model substring (e.g. "sonnet") */
+    model?: string;
+    /** Only sessions newer than this timestamp (ms) */
+    since?: number;
+}
+/**
+ * Search sessions for a query string.
+ * Returns results ranked by relevance (term frequency + recency).
+ */
+export declare function searchSessions(query: string, options?: SearchOptions): SearchMatch[];
+export declare function formatSearchResults(matches: SearchMatch[], query: string): string;