@blockrun/franklin 3.0.0

package/dist/plugins-bundled/social/index.js

@@ -0,0 +1,363 @@
+/**
+ * Social Workflow Plugin.
+ *
+ * IMPORTANT: This file ONLY imports from `../../plugin-sdk/`.
+ * It does NOT import from `src/agent/`, `src/commands/`, `src/social/`, etc.
+ * This is the boundary that keeps plugins decoupled from core internals.
+ */
+import { DEFAULT_MODEL_TIERS } from '../../plugin-sdk/index.js';
+import { DEFAULT_REPLY_STYLE } from './types.js';
+import { FILTER_SYSTEM, LEAD_SCORE_SYSTEM, buildReplyPrompt, buildKeywordPrompt, buildSubredditPrompt, } from './prompts.js';
+// ─── Workflow Implementation ──────────────────────────────────────────────
+const socialWorkflow = {
+    id: 'social',
+    name: 'Social Growth',
+    description: 'AI-powered social engagement on Reddit/X',
+    defaultConfig() {
+        return {
+            name: 'social',
+            models: { ...DEFAULT_MODEL_TIERS },
+            products: [],
+            platforms: {},
+            replyStyle: { ...DEFAULT_REPLY_STYLE },
+            targetUsers: '',
+        };
+    },
+    onboardingQuestions: [
+        {
+            id: 'product',
+            prompt: "What's your product? (name + one-line description)",
+            type: 'text',
+        },
+        {
+            id: 'targetUsers',
+            prompt: 'Who are your target users? (be specific)',
+            type: 'text',
+        },
+        {
+            id: 'platform',
+            prompt: 'Which platforms?',
+            type: 'select',
+            options: ['X/Twitter', 'Reddit', 'Both'],
+            default: 'Both',
+        },
+        {
+            id: 'handle',
+            prompt: "What's your social media handle/username?",
+            type: 'text',
+        },
+    ],
+    async buildConfigFromAnswers(answers, llm) {
+        const [productName, ...descParts] = (answers.product || '').split('—').map(s => s.trim());
+        const productDesc = descParts.join(' — ') || productName;
+        const targetUsers = answers.targetUsers || '';
+        const platform = answers.platform || 'Both';
+        const handle = answers.handle || '';
+        // Auto-generate keywords using LLM
+        let keywords = [];
+        let subreddits = [];
+        try {
+            const kwResponse = await llm(buildKeywordPrompt(productName, productDesc, targetUsers));
+            const parsed = JSON.parse(kwResponse.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
+            if (Array.isArray(parsed))
+                keywords = parsed;
+        }
+        catch { /* use empty */ }
+        if (platform === 'Reddit' || platform === 'Both') {
+            try {
+                const srResponse = await llm(buildSubredditPrompt(productName, productDesc, targetUsers));
+                const parsed = JSON.parse(srResponse.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
+                if (Array.isArray(parsed))
+                    subreddits = parsed;
+            }
+            catch { /* use empty */ }
+        }
+        const config = {
+            name: 'social',
+            models: { ...DEFAULT_MODEL_TIERS },
+            products: [{
+                    name: productName,
+                    description: productDesc,
+                    keywords: keywords.slice(0, 10),
+                }],
+            platforms: {},
+            replyStyle: { ...DEFAULT_REPLY_STYLE },
+            targetUsers,
+        };
+        if (platform === 'X/Twitter' || platform === 'Both') {
+            config.platforms.x = {
+                username: handle.startsWith('@') ? handle : `@${handle}`,
+                dailyTarget: 20,
+                minDelaySeconds: 300,
+                searchQueries: keywords.slice(0, 10),
+            };
+        }
+        if (platform === 'Reddit' || platform === 'Both') {
+            config.platforms.reddit = {
+                username: handle.replace('@', ''),
+                dailyTarget: 10,
+                minDelaySeconds: 600,
+                subreddits: subreddits.slice(0, 8),
+            };
+        }
+        return config;
+    },
+    steps: [
+        {
+            name: 'search',
+            modelTier: 'none',
+            execute: searchStep,
+        },
+        {
+            name: 'filter',
+            modelTier: 'cheap',
+            execute: filterStep,
+        },
+        {
+            name: 'score',
+            modelTier: 'cheap',
+            execute: scoreStep,
+        },
+        {
+            name: 'draft',
+            modelTier: 'dynamic',
+            execute: draftStep,
+        },
+        {
+            name: 'preview',
+            modelTier: 'none',
+            execute: previewStep,
+        },
+        {
+            name: 'post',
+            modelTier: 'none',
+            execute: postStep,
+            skipInDryRun: true,
+        },
+        {
+            name: 'track',
+            modelTier: 'none',
+            execute: trackStep,
+        },
+    ],
+};
+// ─── Step Implementations ─────────────────────────────────────────────────
+async function searchStep(ctx) {
+    const sc = ctx.config;
+    const allResults = [];
+    // Search using configured queries
+    const queries = sc.platforms?.x?.searchQueries ?? sc.products?.[0]?.keywords ?? [];
+    for (const query of queries.slice(0, 5)) {
+        const results = await ctx.search(query, {
+            maxResults: 5,
+            sources: ['reddit', 'x', 'web'],
+        });
+        allResults.push(...results);
+    }
+    if (allResults.length === 0) {
+        return { summary: 'No posts found (search returned empty — channel plugins may not be installed)', abort: true };
+    }
+    // Dedup by URL
+    const seen = new Set();
+    const unique = allResults.filter(r => {
+        if (seen.has(r.url))
+            return false;
+        seen.add(r.url);
+        return true;
+    });
+    return {
+        data: { searchResults: unique, itemCount: unique.length },
+        summary: `Found ${unique.length} posts`,
+    };
+}
+async function filterStep(ctx) {
+    const results = (ctx.data.searchResults ?? []);
+    const sc = ctx.config;
+    const product = sc.products?.[0];
+    if (!product)
+        return { summary: 'No product configured', abort: true };
+    const relevant = [];
+    for (const post of results) {
+        if (await ctx.isDuplicate(post.url))
+            continue;
+        const prompt = `Product: ${product.name} — ${product.description}\n\nPost:\nTitle: ${post.title}\nBody: ${post.snippet}\n\nIs this post relevant?`;
+        try {
+            const response = await ctx.callModel('cheap', prompt, FILTER_SYSTEM);
+            const parsed = JSON.parse(response.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
+            if (parsed.relevant && parsed.score >= 5) {
+                relevant.push({ ...post, relevanceScore: parsed.score });
+            }
+        }
+        catch { /* skip parse failures */ }
+    }
+    if (relevant.length === 0) {
+        return { summary: 'No relevant posts after filtering', abort: true };
+    }
+    relevant.sort((a, b) => b.relevanceScore - a.relevanceScore);
+    return {
+        data: { filteredPosts: relevant, itemCount: relevant.length },
+        summary: `${relevant.length}/${results.length} posts are relevant`,
+    };
+}
+async function scoreStep(ctx) {
+    const posts = (ctx.data.filteredPosts ?? []);
+    const sc = ctx.config;
+    const product = sc.products[0];
+    const scored = [];
+    for (const post of posts) {
+        const prompt = `Product: ${product.name} — ${product.description}\n\nPost:\nTitle: ${post.title}\nBody: ${post.snippet}\nAuthor: ${post.author ?? 'unknown'}`;
+        try {
+            const response = await ctx.callModel('cheap', prompt, LEAD_SCORE_SYSTEM);
+            const parsed = JSON.parse(response.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
+            scored.push({
+                title: post.title,
+                url: post.url,
+                snippet: post.snippet,
+                platform: post.source.includes('reddit') ? 'reddit' : 'x',
+                author: post.author,
+                timestamp: post.timestamp,
+                commentCount: post.commentCount,
+                relevanceScore: post.relevanceScore,
+                leadScore: parsed.leadScore ?? 5,
+                urgency: parsed.urgency ?? 'medium',
+                painPoints: parsed.painPoints ?? [],
+            });
+        }
+        catch {
+            scored.push({
+                title: post.title,
+                url: post.url,
+                snippet: post.snippet,
+                platform: post.source.includes('reddit') ? 'reddit' : 'x',
+                relevanceScore: post.relevanceScore,
+                leadScore: 5,
+                urgency: 'medium',
+                painPoints: [],
+            });
+        }
+    }
+    // Track high-score leads
+    for (const s of scored.filter(s => s.leadScore >= 7)) {
+        await ctx.track('lead', {
+            url: s.url,
+            title: s.title,
+            leadScore: s.leadScore,
+            urgency: s.urgency,
+            painPoints: s.painPoints,
+            platform: s.platform,
+        });
+    }
+    return {
+        data: { scoredPosts: scored },
+        summary: `${scored.filter(s => s.leadScore >= 7).length} high-value leads, ${scored.length} total`,
+    };
+}
+async function draftStep(ctx) {
+    const posts = (ctx.data.scoredPosts ?? []);
+    const sc = ctx.config;
+    const product = sc.products[0];
+    const drafts = [];
+    for (const post of posts) {
+        const tier = post.leadScore >= 7 ? 'premium' : 'cheap';
+        const maxLength = post.platform === 'reddit' ? sc.replyStyle.maxLengthReddit : sc.replyStyle.maxLengthX;
+        const prompt = buildReplyPrompt({ title: post.title, body: post.snippet, platform: post.platform }, { name: product.name, description: product.description }, { tone: sc.replyStyle.tone, maxLength, rules: sc.replyStyle.rules });
+        try {
+            const text = await ctx.callModel(tier, prompt);
+            drafts.push({
+                post,
+                text: text.trim(),
+                model: tier,
+                tier,
+                estimatedCost: 0, // Cost tracked at runner level
+            });
+        }
+        catch (err) {
+            ctx.log(`Failed to draft reply for ${post.url}: ${err.message}`);
+        }
+    }
+    return {
+        data: { drafts, itemCount: drafts.length },
+        summary: `${drafts.length} draft replies generated`,
+    };
+}
+async function previewStep(ctx) {
+    const drafts = (ctx.data.drafts ?? []);
+    if (drafts.length === 0)
+        return { summary: 'No drafts to preview' };
+    const high = drafts.filter(d => d.post.leadScore >= 7);
+    const medium = drafts.filter(d => d.post.leadScore < 7);
+    ctx.log('\n' + '═'.repeat(50));
+    ctx.log('DRAFT REPLIES');
+    ctx.log('═'.repeat(50));
+    if (high.length > 0) {
+        ctx.log(`\n🎯 HIGH VALUE (${high.length} posts)`);
+        for (const d of high) {
+            ctx.log(`\n  ${d.post.platform}: "${d.post.title.slice(0, 60)}"`);
+            ctx.log(`  ⭐ Lead: ${d.post.leadScore}/10 | Tier: ${d.tier}`);
+            ctx.log(`  Reply: "${d.text.slice(0, 120)}..."`);
+        }
+    }
+    if (medium.length > 0) {
+        ctx.log(`\n📋 MEDIUM (${medium.length} posts)`);
+        for (const d of medium) {
+            ctx.log(`  ${d.post.platform}: "${d.post.title.slice(0, 50)}" | Lead: ${d.post.leadScore}/10`);
+        }
+    }
+    ctx.log('═'.repeat(50));
+    return { summary: `${high.length} high + ${medium.length} medium drafts` };
+}
+async function postStep(ctx) {
+    const drafts = (ctx.data.drafts ?? []);
+    let posted = 0;
+    for (const draft of drafts) {
+        await ctx.track('reply', {
+            url: draft.post.url,
+            platform: draft.post.platform,
+            tier: draft.tier,
+            leadScore: draft.post.leadScore,
+            replyLength: draft.text.length,
+        });
+        // Post via channel if available
+        if (ctx.sendMessage) {
+            try {
+                await ctx.sendMessage(draft.post.platform, {
+                    text: draft.text,
+                    inReplyTo: draft.post.url,
+                });
+                posted++;
+            }
+            catch (err) {
+                ctx.log(`Failed to post to ${draft.post.platform}: ${err.message}`);
+            }
+        }
+        else {
+            ctx.log(`✓ Would post to ${draft.post.platform}: ${draft.post.url}`);
+            posted++;
+        }
+    }
+    return {
+        data: { postedCount: posted },
+        summary: `${posted} replies ${ctx.dryRun ? 'drafted' : 'posted'}`,
+    };
+}
+async function trackStep(ctx) {
+    const drafts = (ctx.data.drafts ?? []);
+    return {
+        summary: `${drafts.length} replies tracked`,
+    };
+}
+// ─── Plugin Export ────────────────────────────────────────────────────────
+const plugin = {
+    manifest: {
+        id: 'social',
+        name: 'Social Growth',
+        description: 'AI-powered social engagement on Reddit/X',
+        version: '1.0.0',
+        provides: { workflows: ['social'] },
+        entry: 'index.js',
+    },
+    workflows: {
+        social: () => socialWorkflow,
+    },
+};
+export default plugin;

package/dist/plugins-bundled/social/plugin.json

@@ -0,0 +1,14 @@
+{
+  "id": "social",
+  "name": "Social Growth",
+  "description": "AI-powered social engagement — find relevant posts on Reddit/X, generate quality replies with multi-model routing",
+  "version": "1.0.0",
+  "provides": {
+    "workflows": ["social"]
+  },
+  "entry": "index.js",
+  "author": "BlockRun",
+  "homepage": "https://github.com/BlockRunAI/runcode",
+  "license": "Apache-2.0",
+  "runcodeVersion": ">=2.6.0"
+}

package/dist/plugins-bundled/social/prompts.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Social workflow prompts.
+ */
+export declare const FILTER_SYSTEM = "You are a social media relevance filter. Given a post and a product description, determine if the post is relevant for engagement.\n\nRespond with a JSON object:\n{\"relevant\": true/false, \"score\": 1-10, \"reason\": \"one line explanation\"}\n\nScore guide:\n- 9-10: Directly asking for what the product does, or complaining about the exact problem it solves\n- 7-8: Discussing the product's domain, comparing alternatives\n- 5-6: Tangentially related, could be relevant with a creative angle\n- 1-4: Not relevant enough to engage\n\nOnly mark as relevant if score >= 5.";
+export declare const LEAD_SCORE_SYSTEM = "You are a lead qualification analyst. Given a social media post and product info, score the poster as a potential customer.\n\nRespond with a JSON object:\n{\"leadScore\": 1-10, \"urgency\": \"high\"|\"medium\"|\"low\", \"painPoints\": [\"point1\", \"point2\"], \"businessType\": \"description\"}\n\nLead score guide:\n- 9-10: Actively looking for a solution, has budget, decision maker\n- 7-8: Has the problem, open to solutions\n- 5-6: In the right space but not actively looking\n- 1-4: Low intent or wrong audience";
+export declare function buildReplyPrompt(post: {
+    title: string;
+    body: string;
+    platform: string;
+}, product: {
+    name: string;
+    description: string;
+}, style: {
+    tone: string;
+    maxLength: number;
+    rules: string[];
+}): string;
+export declare function buildKeywordPrompt(productName: string, productDesc: string, targetUsers: string): string;
+export declare function buildSubredditPrompt(productName: string, productDesc: string, targetUsers: string): string;

package/dist/plugins-bundled/social/prompts.js

@@ -0,0 +1,67 @@
+/**
+ * Social workflow prompts.
+ */
+export const FILTER_SYSTEM = `You are a social media relevance filter. Given a post and a product description, determine if the post is relevant for engagement.
+
+Respond with a JSON object:
+{"relevant": true/false, "score": 1-10, "reason": "one line explanation"}
+
+Score guide:
+- 9-10: Directly asking for what the product does, or complaining about the exact problem it solves
+- 7-8: Discussing the product's domain, comparing alternatives
+- 5-6: Tangentially related, could be relevant with a creative angle
+- 1-4: Not relevant enough to engage
+
+Only mark as relevant if score >= 5.`;
+export const LEAD_SCORE_SYSTEM = `You are a lead qualification analyst. Given a social media post and product info, score the poster as a potential customer.
+
+Respond with a JSON object:
+{"leadScore": 1-10, "urgency": "high"|"medium"|"low", "painPoints": ["point1", "point2"], "businessType": "description"}
+
+Lead score guide:
+- 9-10: Actively looking for a solution, has budget, decision maker
+- 7-8: Has the problem, open to solutions
+- 5-6: In the right space but not actively looking
+- 1-4: Low intent or wrong audience`;
+export function buildReplyPrompt(post, product, style) {
+    return `Write a reply to this ${post.platform} post. You are NOT writing an ad. You are a real user sharing your experience.
+
+POST:
+Title: ${post.title}
+Body: ${post.body}
+
+YOUR PRODUCT (mention naturally, not as an ad):
+${product.name}: ${product.description}
+
+REPLY STYLE:
+- Tone: ${style.tone}
+- Max length: ${style.maxLength} characters
+- Rules:
+${style.rules.map(r => `  - ${r}`).join('\n')}
+
+Write ONLY the reply text. No quotation marks, no meta-commentary, no "Here's my reply:".`;
+}
+export function buildKeywordPrompt(productName, productDesc, targetUsers) {
+    return `Given this product and target audience, generate 10 search queries that would find relevant social media posts to engage with.
+
+Product: ${productName}
+Description: ${productDesc}
+Target users: ${targetUsers}
+
+Return a JSON array of 10 search queries. Mix specific and broad queries.
+Example: ["claude code rate limit alternative", "ai coding agent comparison 2026", ...]
+
+Return ONLY the JSON array.`;
+}
+export function buildSubredditPrompt(productName, productDesc, targetUsers) {
+    return `Given this product and target audience, suggest 5-8 subreddits where the target users hang out.
+
+Product: ${productName}
+Description: ${productDesc}
+Target users: ${targetUsers}
+
+Return a JSON array of subreddit names (without r/ prefix).
+Example: ["programming", "MachineLearning", "LocalLLaMA", ...]
+
+Return ONLY the JSON array.`;
+}

package/dist/plugins-bundled/social/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Social plugin types — extends WorkflowConfig with social-specific fields.
+ */
+import type { WorkflowConfig } from '../../plugin-sdk/index.js';
+export interface SocialProduct {
+    name: string;
+    description: string;
+    keywords: string[];
+    url?: string;
+}
+export interface SocialPlatformConfig {
+    username: string;
+    dailyTarget: number;
+    minDelaySeconds: number;
+}
+export interface SocialReplyStyle {
+    tone: string;
+    maxLengthReddit: number;
+    maxLengthX: number;
+    rules: string[];
+    imageForHighValue: boolean;
+}
+export interface SocialConfig extends WorkflowConfig {
+    name: 'social';
+    products: SocialProduct[];
+    platforms: {
+        reddit?: SocialPlatformConfig & {
+            subreddits: string[];
+        };
+        x?: SocialPlatformConfig & {
+            searchQueries: string[];
+        };
+    };
+    replyStyle: SocialReplyStyle;
+    targetUsers: string;
+}
+export interface ScoredPost {
+    title: string;
+    url: string;
+    snippet: string;
+    platform: 'reddit' | 'x';
+    author?: string;
+    timestamp?: string;
+    commentCount?: number;
+    relevanceScore: number;
+    leadScore: number;
+    urgency: 'high' | 'medium' | 'low';
+    painPoints: string[];
+}
+export interface DraftReply {
+    post: ScoredPost;
+    text: string;
+    model: string;
+    tier: 'cheap' | 'premium';
+    estimatedCost: number;
+    imageUrl?: string;
+}
+export declare const DEFAULT_REPLY_STYLE: SocialReplyStyle;

package/dist/plugins-bundled/social/types.js

@@ -0,0 +1,16 @@
+/**
+ * Social plugin types — extends WorkflowConfig with social-specific fields.
+ */
+export const DEFAULT_REPLY_STYLE = {
+    tone: 'knowledgeable developer sharing experience',
+    maxLengthReddit: 400,
+    maxLengthX: 260,
+    rules: [
+        'Lead with a genuine insight or question about the post',
+        'Mention product naturally as "what I use/built" — not as an ad',
+        'Never start with "Great post!" or "I agree!"',
+        'Sound like a real developer who has faced this problem',
+        'If post is not directly relevant, skip — do not force a mention',
+    ],
+    imageForHighValue: true,
+};

package/dist/pricing.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Single source of truth for model pricing (per 1M tokens).
+ * Used by agent loop, proxy server, stats tracker, and router.
+ */
+export declare const MODEL_PRICING: Record<string, {
+    input: number;
+    output: number;
+    perCall?: number;
+}>;
+/** Opus pricing for savings calculations */
+export declare const OPUS_PRICING: {
+    input: number;
+    output: number;
+    perCall?: number;
+};
+/**
+ * Estimate cost in USD for a request.
+ * Falls back to $2/$10 per 1M for unknown models.
+ * For per-call models (perCall > 0), uses flat per-call pricing instead of per-token.
+ */
+export declare function estimateCost(model: string, inputTokens: number, outputTokens: number, calls?: number): number;

package/dist/pricing.js

@@ -0,0 +1,91 @@
+/**
+ * Single source of truth for model pricing (per 1M tokens).
+ * Used by agent loop, proxy server, stats tracker, and router.
+ */
+export const MODEL_PRICING = {
+    // Routing profiles (blended averages)
+    'blockrun/auto': { input: 0.8, output: 4.0 },
+    'blockrun/eco': { input: 0.2, output: 1.0 },
+    'blockrun/premium': { input: 3.0, output: 15.0 },
+    'blockrun/free': { input: 0, output: 0 },
+    // FREE - NVIDIA models
+    'nvidia/gpt-oss-120b': { input: 0, output: 0 },
+    'nvidia/gpt-oss-20b': { input: 0, output: 0 },
+    'nvidia/nemotron-ultra-253b': { input: 0, output: 0 },
+    'nvidia/nemotron-3-super-120b': { input: 0, output: 0 },
+    'nvidia/nemotron-super-49b': { input: 0, output: 0 },
+    'nvidia/deepseek-v3.2': { input: 0, output: 0 },
+    'nvidia/mistral-large-3-675b': { input: 0, output: 0 },
+    'nvidia/qwen3-coder-480b': { input: 0, output: 0 },
+    'nvidia/devstral-2-123b': { input: 0, output: 0 },
+    'nvidia/glm-4.7': { input: 0, output: 0 },
+    'nvidia/llama-4-maverick': { input: 0, output: 0 },
+    // Anthropic
+    'anthropic/claude-sonnet-4.6': { input: 3.0, output: 15.0 },
+    'anthropic/claude-opus-4.6': { input: 5.0, output: 25.0 },
+    'anthropic/claude-haiku-4.5': { input: 1.0, output: 5.0 },
+    'anthropic/claude-haiku-4.5-20251001': { input: 1.0, output: 5.0 },
+    // OpenAI
+    'openai/gpt-5-nano': { input: 0.05, output: 0.4 },
+    'openai/gpt-4.1-nano': { input: 0.1, output: 0.4 },
+    'openai/gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'openai/gpt-5-mini': { input: 0.25, output: 2.0 },
+    'openai/gpt-4.1-mini': { input: 0.4, output: 1.6 },
+    'openai/gpt-5.2': { input: 1.75, output: 14.0 },
+    'openai/gpt-5.3': { input: 1.75, output: 14.0 },
+    'openai/gpt-5.3-codex': { input: 1.75, output: 14.0 },
+    'openai/gpt-4.1': { input: 2.0, output: 8.0 },
+    'openai/o3': { input: 2.0, output: 8.0 },
+    'openai/gpt-4o': { input: 2.5, output: 10.0 },
+    'openai/gpt-5.4': { input: 2.5, output: 15.0 },
+    'openai/o1-mini': { input: 1.1, output: 4.4 },
+    'openai/o3-mini': { input: 1.1, output: 4.4 },
+    'openai/o4-mini': { input: 1.1, output: 4.4 },
+    'openai/o1': { input: 15.0, output: 60.0 },
+    'openai/gpt-5.2-pro': { input: 21.0, output: 168.0 },
+    'openai/gpt-5.4-pro': { input: 30.0, output: 180.0 },
+    // Google
+    'google/gemini-2.5-flash-lite': { input: 0.1, output: 0.4 },
+    'google/gemini-2.5-flash': { input: 0.3, output: 2.5 },
+    'google/gemini-3-flash-preview': { input: 0.5, output: 3.0 },
+    'google/gemini-2.5-pro': { input: 1.25, output: 10.0 },
+    'google/gemini-3-pro-preview': { input: 2.0, output: 12.0 },
+    'google/gemini-3.1-pro': { input: 2.0, output: 12.0 },
+    // xAI
+    'xai/grok-4-fast': { input: 0.2, output: 0.5 },
+    'xai/grok-4-fast-reasoning': { input: 0.2, output: 0.5 },
+    'xai/grok-4-1-fast': { input: 0.2, output: 0.5 },
+    'xai/grok-4-1-fast-reasoning': { input: 0.2, output: 0.5 },
+    'xai/grok-4-0709': { input: 0.2, output: 1.5 },
+    'xai/grok-3-mini': { input: 0.3, output: 0.5 },
+    'xai/grok-2-vision': { input: 2.0, output: 10.0 },
+    'xai/grok-3': { input: 3.0, output: 15.0 },
+    // DeepSeek
+    'deepseek/deepseek-chat': { input: 0.28, output: 0.42 },
+    'deepseek/deepseek-reasoner': { input: 0.28, output: 0.42 },
+    // Minimax
+    'minimax/minimax-m2.7': { input: 0.3, output: 1.2 },
+    'minimax/minimax-m2.5': { input: 0.3, output: 1.2 },
+    // Others
+    'moonshot/kimi-k2.5': { input: 0.6, output: 3.0 },
+    'nvidia/kimi-k2.5': { input: 0.55, output: 2.5 },
+    // PROMOTION (active ~2026-04): flat $0.001/call. Normal pricing: input:1.00, output:3.20
+    'zai/glm-5.1': { input: 0, output: 0, perCall: 0.001 },
+    // PROMOTION (active ~2026-04): flat $0.001/call. Normal pricing: input:1.20, output:4.00
+    'zai/glm-5.1-turbo': { input: 0, output: 0, perCall: 0.001 },
+};
+/** Opus pricing for savings calculations */
+export const OPUS_PRICING = MODEL_PRICING['anthropic/claude-opus-4.6'];
+/**
+ * Estimate cost in USD for a request.
+ * Falls back to $2/$10 per 1M for unknown models.
+ * For per-call models (perCall > 0), uses flat per-call pricing instead of per-token.
+ */
+export function estimateCost(model, inputTokens, outputTokens, calls = 1) {
+    const pricing = MODEL_PRICING[model] || { input: 2.0, output: 10.0 };
+    if (pricing.perCall) {
+        return pricing.perCall * calls;
+    }
+    return ((inputTokens / 1_000_000) * pricing.input +
+        (outputTokens / 1_000_000) * pricing.output);
+}