opencode-free-fleet 0.1.0 → 0.2.1

package/dist/core/adapters/index.js

@@ -0,0 +1,546 @@
+/**
+ * Provider Adapters for OpenCode Free Fleet v0.2.0
+ *
+ * Each adapter knows how to fetch models and identify free tier models
+ * for a specific provider.
+ *
+ * v0.2.1 - Build Repair: Removed dynamic imports
+ */
+import { ELITE_FAMILIES } from '../../types/index.js';
+/**
+ * OpenRouter Adapter
+ * All models with pricing.prompt === "0" AND pricing.completion === "0" are free
+ */
+class OpenRouterAdapter {
+    providerId = 'openrouter';
+    providerName = 'OpenRouter';
+    async fetchModels() {
+        console.log('🔗 OpenRouter: Fetching models...');
+        const response = await fetch('https://openrouter.ai/api/v1/models', {
+            headers: { 'Accept': 'application/json' }
+        });
+        if (!response.ok) {
+            throw new Error(`OpenRouter API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = data.data || [];
+        console.log(`✓ OpenRouter: Found ${models.length} models`);
+        return models.map((model) => ({
+            id: model.id,
+            name: model.name,
+            description: model.description,
+            context_length: model.context_length,
+            architecture: model.architecture,
+            pricing: model.pricing,
+            top_provider: model.top_provider
+        }));
+    }
+    isFreeModel(model) {
+        // OpenRouter: Free if both prompt and completion are "0"
+        const isFreePrompt = model.pricing?.prompt === '0' || model.pricing?.prompt === '0.0';
+        const isFreeCompletion = model.pricing?.completion === '0' || model.pricing?.completion === '0.0';
+        return isFreePrompt && isFreeCompletion;
+    }
+    normalizeModel(model) {
+        const isFree = this.isFreeModel(model);
+        // Determine category
+        const id = model.id.toLowerCase();
+        let category = 'writing';
+        if (id.includes('coder') || id.includes('code') || id.includes('function')) {
+            category = 'coding';
+        }
+        else if (id.includes('r1') || id.includes('reasoning') || id.includes('cot') || id.includes('qwq')) {
+            category = 'reasoning';
+        }
+        else if (id.includes('flash') || id.includes('distill') || id.includes('nano') || id.includes('lite')) {
+            category = 'speed';
+        }
+        else if (id.includes('vl') || id.includes('vision') || id.includes('molmo')) {
+            category = 'multimodal';
+        }
+        // Determine if elite
+        const elitePatterns = ELITE_FAMILIES[category] || [];
+        const isElite = elitePatterns.some((pattern) => id.includes(pattern.toLowerCase()));
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name || model.id.split('/')[1],
+            description: model.description,
+            contextLength: model.context_length,
+            maxOutputTokens: model.max_output_tokens || model.architecture?.['context_length'],
+            pricing: {
+                prompt: model.pricing?.prompt || '0',
+                completion: model.pricing?.completion || '0',
+                request: model.pricing?.request || '0'
+            },
+            isFree,
+            isElite,
+            category
+        };
+    }
+}
+/**
+ * Groq Adapter
+ * Currently (as of 2026), most Groq models are free
+ */
+class GroqAdapter {
+    providerId = 'groq';
+    providerName = 'Groq';
+    async fetchModels() {
+        console.log('🚀 Groq: Fetching models...');
+        const response = await fetch('https://api.groq.com/openai/v1/models', {
+            headers: { 'Accept': 'application/json' }
+        });
+        if (!response.ok) {
+            throw new Error(`Groq API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = data.data || [];
+        console.log(`✓ Groq: Found ${models.length} models`);
+        return models.map((model) => ({
+            id: model.id,
+            name: model.name,
+            description: model.description,
+            context_length: model.context_length,
+            pricing: model.pricing || {},
+            top_provider: null
+        }));
+    }
+    isFreeModel(model) {
+        // Groq: Assume all models are free (current policy)
+        return true;
+    }
+    normalizeModel(model) {
+        const isFree = this.isFreeModel(model);
+        // Determine category
+        const id = model.id.toLowerCase();
+        let category = 'writing';
+        if (id.includes('coder') || id.includes('code') || id.includes('function')) {
+            category = 'coding';
+        }
+        else if (id.includes('r1') || id.includes('reasoning') || id.includes('cot') || id.includes('qwq')) {
+            category = 'reasoning';
+        }
+        else if (id.includes('flash') || id.includes('distill') || id.includes('nano') || id.includes('lite')) {
+            category = 'speed';
+        }
+        else if (id.includes('vl') || id.includes('vision') || id.includes('molmo')) {
+            category = 'multimodal';
+        }
+        // Determine if elite
+        const elitePatterns = ELITE_FAMILIES[category] || [];
+        const isElite = elitePatterns.some((pattern) => id.includes(pattern.toLowerCase()));
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name || model.id.split('/')[1],
+            description: model.description,
+            contextLength: model.context_length,
+            maxOutputTokens: model.max_output_tokens || model.architecture?.['context_length'],
+            pricing: {
+                prompt: model.pricing?.prompt || '0',
+                completion: model.pricing?.completion || '0',
+                request: model.pricing?.request || '0'
+            },
+            isFree,
+            isElite,
+            category
+        };
+    }
+}
+/**
+ * Cerebras Adapter
+ * All models are currently free
+ */
+class CerebrasAdapter {
+    providerId = 'cerebras';
+    providerName = 'Cerebras';
+    async fetchModels() {
+        console.log('⚡ Cerebras: Fetching models...');
+        const response = await fetch('https://api.cerebras.ai/v1/models', {
+            headers: { 'Accept': 'application/json' }
+        });
+        if (!response.ok) {
+            throw new Error(`Cerebras API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = data.models || [];
+        console.log(`✓ Cerebras: Found ${models.length} models`);
+        return models.map((model) => ({
+            id: model.id,
+            name: model.name,
+            description: model.description,
+            context_length: model.context_length || model.context_window,
+            pricing: model.pricing || {},
+            top_provider: null
+        }));
+    }
+    isFreeModel(model) {
+        // Cerebras: Assume all models are free (current policy)
+        return true;
+    }
+    normalizeModel(model) {
+        const isFree = this.isFreeModel(model);
+        // Determine category
+        const id = model.id.toLowerCase();
+        let category = 'writing';
+        if (id.includes('coder') || id.includes('code') || id.includes('function')) {
+            category = 'coding';
+        }
+        else if (id.includes('r1') || id.includes('reasoning') || id.includes('cot') || id.includes('qwq')) {
+            category = 'reasoning';
+        }
+        else if (id.includes('flash') || id.includes('distill') || id.includes('nano') || id.includes('lite')) {
+            category = 'speed';
+        }
+        else if (id.includes('vl') || id.includes('vision') || id.includes('molmo')) {
+            category = 'multimodal';
+        }
+        // Determine if elite
+        const elitePatterns = ELITE_FAMILIES[category] || [];
+        const isElite = elitePatterns.some((pattern) => id.includes(pattern.toLowerCase()));
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name || model.id.split('/')[1],
+            description: model.description,
+            contextLength: model.context_length || model.context_window,
+            maxOutputTokens: model.max_output_tokens || model.architecture?.['context_length'],
+            pricing: {
+                prompt: model.pricing?.prompt || '0',
+                completion: model.pricing?.completion || '0',
+                request: model.pricing?.request || '0'
+            },
+            isFree,
+            isElite,
+            category
+        };
+    }
+}
+/**
+ * Google Adapter
+ * Free models are limited (Gemini Flash, Nano)
+ */
+class GoogleAdapter {
+    providerId = 'google';
+    providerName = 'Google';
+    async fetchModels() {
+        console.log('🔵 Google: Fetching models...');
+        // Note: This requires OAuth flow
+        // For now, return a placeholder list
+        const freeModels = [
+            {
+                id: 'gemini-1.5-flash',
+                name: 'Gemini 1.5 Flash',
+                description: 'Fast, lightweight multimodal model (Free Tier)',
+                context_length: 28000,
+                pricing: { prompt: '0', completion: '0', request: '0' }
+            },
+            {
+                id: 'gemini-1.5-flash-8b',
+                name: 'Gemini 1.5 Flash-8B',
+                description: 'Even smaller and faster (Free Tier)',
+                context_length: 1000000,
+                pricing: { prompt: '0', completion: '0', request: '0' }
+            }
+        ];
+        console.log(`✓ Google: Found ${freeModels.length} free models (cached)`);
+        return freeModels;
+    }
+    isFreeModel(model) {
+        // Google: Check if explicitly marked as free (pricing === "0")
+        const isFreePrompt = model.pricing?.prompt === '0' || model.pricing?.prompt === '0.0';
+        const isFreeCompletion = model.pricing?.completion === '0' || model.pricing?.completion === '0.0';
+        return isFreePrompt && isFreeCompletion;
+    }
+    normalizeModel(model) {
+        const isFree = this.isFreeModel(model);
+        // Determine category
+        const id = model.id.toLowerCase();
+        let category = 'writing';
+        if (id.includes('coder') || id.includes('code') || id.includes('function')) {
+            category = 'coding';
+        }
+        else if (id.includes('r1') || id.includes('reasoning') || id.includes('cot') || id.includes('qwq')) {
+            category = 'reasoning';
+        }
+        else if (id.includes('flash') || id.includes('distill') || id.includes('nano') || id.includes('lite')) {
+            category = 'speed';
+        }
+        else if (id.includes('vl') || id.includes('vision') || id.includes('molmo')) {
+            category = 'multimodal';
+        }
+        // Determine if elite
+        const elitePatterns = ELITE_FAMILIES[category] || [];
+        const isElite = elitePatterns.some((pattern) => id.includes(pattern.toLowerCase()));
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name || model.id.split('/')[1],
+            description: model.description,
+            contextLength: model.context_length,
+            maxOutputTokens: model.max_output_tokens || model.architecture?.['context_length'],
+            pricing: {
+                prompt: model.pricing?.prompt || '0',
+                completion: model.pricing?.completion || '0',
+                request: model.pricing?.request || '0'
+            },
+            isFree,
+            isElite,
+            category
+        };
+    }
+}
+/**
+ * DeepSeek Adapter
+ * DeepSeek-V3.2 has 5M free tokens
+ */
+class DeepSeekAdapter {
+    providerId = 'deepseek';
+    providerName = 'DeepSeek';
+    async fetchModels() {
+        console.log('🟣 DeepSeek: Fetching models...');
+        const response = await fetch('https://api.deepseek.com/v1/models', {
+            headers: { 'Accept': 'application/json' }
+        });
+        if (!response.ok) {
+            throw new Error(`DeepSeek API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = data.data || [];
+        console.log(`✓ DeepSeek: Found ${models.length} models`);
+        return models.map((model) => ({
+            id: model.id,
+            name: model.name,
+            description: model.description,
+            context_length: model.context_length || model.max_context_tokens,
+            architecture: {
+                modality: model.modality,
+                tokenizer: model.tokenizer || 'unknown'
+            },
+            pricing: model.pricing || {},
+            top_provider: null
+        }));
+    }
+    isFreeModel(model) {
+        // DeepSeek: Check if marked as free or known free model
+        const knownFreeModels = ['deepseek-chat', 'deepseek-coder', 'deepseek-v3', 'deepseek-r1'];
+        const modelId = model.id.toLowerCase();
+        return knownFreeModels.some(freeModel => modelId.includes(freeModel));
+    }
+    normalizeModel(model) {
+        const isFree = this.isFreeModel(model);
+        // Determine category
+        const id = model.id.toLowerCase();
+        let category = 'writing';
+        if (id.includes('coder') || id.includes('code') || id.includes('function')) {
+            category = 'coding';
+        }
+        else if (id.includes('r1') || id.includes('reasoning') || id.includes('cot') || id.includes('qwq')) {
+            category = 'reasoning';
+        }
+        else if (id.includes('flash') || id.includes('distill') || id.includes('nano') || id.includes('lite')) {
+            category = 'speed';
+        }
+        else if (id.includes('vl') || id.includes('vision') || id.includes('molmo')) {
+            category = 'multimodal';
+        }
+        // Determine if elite
+        const elitePatterns = ELITE_FAMILIES[category] || [];
+        const isElite = elitePatterns.some((pattern) => id.includes(pattern.toLowerCase()));
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name || model.id.split('/')[1],
+            description: model.description,
+            contextLength: model.context_length || model.max_context_tokens,
+            maxOutputTokens: model.max_output_tokens || model.architecture?.['context_length'],
+            pricing: {
+                prompt: model.pricing?.prompt || '0',
+                completion: model.pricing?.completion || '0',
+                request: model.pricing?.request || '0'
+            },
+            isFree,
+            isElite,
+            category
+        };
+    }
+}
+/**
+ * ModelScope Adapter
+ * Some free serverless inference models
+ */
+class ModelScopeAdapter {
+    providerId = 'modelscope';
+    providerName = 'ModelScope';
+    async fetchModels() {
+        console.log('🔬 ModelScope: Fetching free serverless models...');
+        // Note: This requires authentication
+        // For now, return a placeholder list
+        const freeModels = [
+            {
+                id: 'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo',
+                name: 'Meta Llama 3.1 70B',
+                description: 'Llama 3.1 with 128K context (Serverless Free)',
+                context_length: 128000,
+                pricing: { prompt: '0', completion: '0', request: '0' }
+            }
+        ];
+        console.log(`✓ ModelScope: Found ${freeModels.length} free models (cached)`);
+        return freeModels;
+    }
+    isFreeModel(model) {
+        // ModelScope: Check if marked as serverless free
+        return model.serverless_free === true || model.pricing?.prompt === '0';
+    }
+    normalizeModel(model) {
+        const isFree = this.isFreeModel(model);
+        // Determine category
+        const id = model.id.toLowerCase();
+        let category = 'writing';
+        if (id.includes('coder') || id.includes('code') || id.includes('function')) {
+            category = 'coding';
+        }
+        else if (id.includes('r1') || id.includes('reasoning') || id.includes('cot') || id.includes('qwq')) {
+            category = 'reasoning';
+        }
+        else if (id.includes('flash') || id.includes('distill') || id.includes('nano') || id.includes('lite')) {
+            category = 'speed';
+        }
+        else if (id.includes('vl') || id.includes('vision') || id.includes('molmo')) {
+            category = 'multimodal';
+        }
+        // Determine if elite
+        const elitePatterns = ELITE_FAMILIES[category] || [];
+        const isElite = elitePatterns.some((pattern) => id.includes(pattern.toLowerCase()));
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name || model.id.split('/')[1],
+            description: model.description,
+            contextLength: model.context_length,
+            maxOutputTokens: model.max_output_tokens || model.architecture?.['context_length'],
+            pricing: {
+                prompt: model.pricing?.prompt || '0',
+                completion: model.pricing?.completion || '0',
+                request: model.pricing?.request || '0'
+            },
+            isFree,
+            isElite,
+            category
+        };
+    }
+}
+/**
+ * Hugging Face Adapter
+ * Some free serverless inference models
+ */
+class HuggingFaceAdapter {
+    providerId = 'huggingface';
+    providerName = 'Hugging Face';
+    async fetchModels() {
+        console.log('🤗 Hugging Face: Fetching free serverless models...');
+        // Note: This requires complex filtering
+        // For now, return a placeholder list
+        const freeModels = [
+            {
+                id: 'Qwen/Qwen2.5-72B-Instruct-Turbo',
+                name: 'Qwen 2.5 72B',
+                description: 'Qwen 2.5 with 128K context (Serverless Free)',
+                context_length: 128000,
+                pricing: { prompt: '0', completion: '0', request: '0' }
+            }
+        ];
+        console.log(`✓ Hugging Face: Found ${freeModels.length} free models (cached)`);
+        return freeModels;
+    }
+    isFreeModel(model) {
+        // Hugging Face: Check if marked as serverless free
+        return model.serverless_free === true || model.pricing?.prompt === '0';
+    }
+    normalizeModel(model) {
+        const isFree = this.isFreeModel(model);
+        // Determine category
+        const id = model.id.toLowerCase();
+        let category = 'writing';
+        if (id.includes('coder') || id.includes('code') || id.includes('function')) {
+            category = 'coding';
+        }
+        else if (id.includes('r1') || id.includes('reasoning') || id.includes('cot') || id.includes('qwq')) {
+            category = 'reasoning';
+        }
+        else if (id.includes('flash') || id.includes('distill') || id.includes('nano') || id.includes('lite')) {
+            category = 'speed';
+        }
+        else if (id.includes('vl') || id.includes('vision') || id.includes('molmo')) {
+            category = 'multimodal';
+        }
+        // Determine if elite
+        const elitePatterns = ELITE_FAMILIES[category] || [];
+        const isElite = elitePatterns.some((pattern) => id.includes(pattern.toLowerCase()));
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name || model.id.split('/')[1],
+            description: model.description,
+            contextLength: model.context_length,
+            maxOutputTokens: model.max_output_tokens || model.architecture?.['context_length'],
+            pricing: {
+                prompt: model.pricing?.prompt || '0',
+                completion: model.pricing?.completion || '0',
+                request: model.pricing?.request || '0'
+            },
+            isFree,
+            isElite,
+            category
+        };
+    }
+}
+/**
+ * Base Adapter implementation
+ */
+class BaseAdapter {
+    providerId;
+    providerName;
+    constructor(providerId, providerName) {
+        this.providerId = providerId;
+        this.providerName = providerName;
+    }
+    async fetchModels() {
+        return [];
+    }
+    isFreeModel(model) {
+        return false;
+    }
+    normalizeModel(model) {
+        return {
+            id: model.id,
+            provider: this.providerId,
+            name: model.name,
+            pricing: { prompt: '0', completion: '0', request: '0' },
+            isFree: false,
+            isElite: false,
+            category: 'writing'
+        };
+    }
+}
+/**
+ * Create adapter instance by provider ID
+ */
+export function createAdapter(providerId) {
+    const adapters = {
+        'openrouter': () => new OpenRouterAdapter(),
+        'groq': () => new GroqAdapter(),
+        'cerebras': () => new CerebrasAdapter(),
+        'google': () => new GoogleAdapter(),
+        'deepseek': () => new DeepSeekAdapter(),
+        'modelscope': () => new ModelScopeAdapter(),
+        'huggingface': () => new HuggingFaceAdapter()
+    };
+    const adapterFactory = adapters[providerId];
+    if (!adapterFactory) {
+        console.warn(`⚠️  No adapter found for provider: ${providerId}, using base adapter`);
+        return new BaseAdapter(providerId, providerId);
+    }
+    return adapterFactory();
+}

package/dist/core/oracle.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Metadata Oracle - Cross-Provider Model Metadata Lookup
+ *
+ * v0.2.1 - Build Repair: Removed problematic Z.Ai SDK import
+ */
+/**
+ * Static knowledge base of confirmed free models
+ * This can be updated without code changes
+ */
+export declare const CONFIRMED_FREE_MODELS: Set<string>;
+/**
+ * Oracle result with confidence score
+ */
+export interface ModelMetadata {
+    id: string;
+    provider: string;
+    name: string;
+    isFree: boolean;
+    confidence: number;
+    reason: string;
+    lastVerified?: string;
+    pricing?: {
+        prompt: string;
+        completion: string;
+        request: string;
+    };
+}
+/**
+ * Provider adapter for metadata lookup
+ */
+export interface MetadataAdapter {
+    providerId: string;
+    providerName: string;
+    /**
+     * Fetch metadata for a specific model
+     */
+    fetchModelMetadata(modelId: string): Promise<ModelMetadata>;
+    /**
+     * Batch fetch multiple models
+     */
+    fetchModelsMetadata(modelIds?: string[]): Promise<ModelMetadata[]>;
+    /**
+     * Check if this adapter is available
+     */
+    isAvailable(): boolean;
+}
+/**
+ * Unified metadata oracle
+ * Aggregates data from multiple metadata sources
+ */
+export declare class MetadataOracle {
+    private adapters;
+    constructor();
+    /**
+     * Initialize all metadata adapters
+     */
+    private _initializeAdapters;
+    /**
+     * Check which adapters are available
+     */
+    getAvailableAdapters(): string[];
+    /**
+     * Fetch metadata for a specific model from all available sources
+     * This is the main method Scout should call for free tier detection
+     */
+    fetchModelMetadata(modelId: string): Promise<ModelMetadata>;
+    /**
+     * Batch fetch metadata for multiple models
+     */
+    fetchModelsMetadata(modelIds: string[]): Promise<ModelMetadata[]>;
+    /**
+     * Get list of all confirmed free models
+     */
+    getConfirmedFreeModels(): Set<string>;
+    /**
+     * Add a manually confirmed free model
+     * This allows updating of static knowledge base
+     */
+    addConfirmedFreeModel(modelId: string): void;
+    /**
+     * Remove a model from confirmed free list
+     */
+    removeConfirmedFreeModel(modelId: string): void;
+}