feat: add support for openrouter

Author: zerob13

CLAUDE.md

@@ -82,10 +82,110 @@ Single provider JSON:
 
 ## Adding New Providers
 
-1. Create new provider file in `src/providers/`
-2. Implement the `Provider` trait
-3. Add to `src/providers/mod.rs`
-4. Register in `src/main.rs`
+### Step-by-Step Guide
+
+1. **Create Provider Implementation**
+   - Create new file in `src/providers/` (e.g., `src/providers/newprovider.rs`)
+   - Implement the `Provider` trait with required methods:
+     - `async fn fetch_models(&self) -> Result<Vec<ModelInfo>>`
+     - `fn provider_id(&self) -> &str`
+     - `fn provider_name(&self) -> &str`
+   
+2. **Add Module Reference**
+   - Add `pub mod newprovider;` to `src/providers/mod.rs`
+   
+3. **Register in Main**
+   - Import the provider in `src/main.rs`: `providers::newprovider::NewProviderProvider`
+   - Add provider initialization in `fetch_all_providers()` function
+   
+4. **Update Documentation**
+   - Add JSON link to README.md "Available Model Data" section
+   - Update "Currently Supported Providers" section with provider status
+
+### Template for New Provider
+
+```rust
+use async_trait::async_trait;
+use anyhow::Result;
+use serde::Deserialize;
+use crate::models::{ModelInfo, ModelType};
+use crate::providers::Provider;
+
+#[derive(Debug, Deserialize)]
+struct NewProviderModel {
+    // Define API response structure
+}
+
+#[derive(Debug, Deserialize)]  
+struct NewProviderResponse {
+    // Define API response wrapper
+}
+
+pub struct NewProviderProvider {
+    api_url: String,
+    client: reqwest::Client,
+}
+
+impl NewProviderProvider {
+    pub fn new(api_url: String) -> Self {
+        Self {
+            api_url,
+            client: reqwest::Client::new(),
+        }
+    }
+
+    fn convert_model(&self, model: NewProviderModel) -> ModelInfo {
+        // Convert API model to standardized ModelInfo
+        // Detect capabilities: vision, function_call, reasoning
+        ModelInfo::new(
+            model.id,
+            model.name,
+            context_length,
+            max_tokens,
+            vision,
+            function_call,
+            reasoning,
+            ModelType::Chat,
+            description,
+        )
+    }
+}
+
+#[async_trait]
+impl Provider for NewProviderProvider {
+    async fn fetch_models(&self) -> Result<Vec<ModelInfo>> {
+        let response = self.client
+            .get(&self.api_url)
+            .send()
+            .await?
+            .json::<NewProviderResponse>()
+            .await?;
+
+        let models = response.data
+            .into_iter()
+            .map(|model| self.convert_model(model))
+            .collect();
+
+        Ok(models)
+    }
+
+    fn provider_id(&self) -> &str {
+        "newprovider"
+    }
+
+    fn provider_name(&self) -> &str {
+        "New Provider"
+    }
+}
+```
+
+### After Adding Provider
+
+The system will automatically:
+- Generate `{provider_id}.json` file in `dist/` directory
+- Include provider data in `all.json` aggregated file
+- Update GitHub Actions to fetch from new provider
+- Create downloadable JSON links in releases
 
 ## GitHub Actions
 

README.md

@@ -11,6 +11,14 @@ Automated tool to fetch AI model information from various providers (PPInfra, Op
 - 🎯 **Aggregated Output**: Generate both individual provider files and complete aggregated files
 - 🚀 **GitHub Actions**: Automated scheduled updates for model information
 
+### 📄 Available Model Data
+
+Access the latest AI model information in JSON format:
+
+- **All Providers Combined**: [all.json](https://github.com/zerob13/PublicProviderConf/raw/main/provider_configs/all.json) - Complete aggregated data from all providers
+- **PPInfra**: [ppinfra.json](https://github.com/zerob13/PublicProviderConf/raw/main/provider_configs/ppinfra.json) - PPInfra provider models
+- **OpenRouter**: [openrouter.json](https://github.com/zerob13/PublicProviderConf/raw/main/provider_configs/openrouter.json) - OpenRouter provider models
+
 ## 📦 Installation
 
 ### Prerequisites
@@ -217,7 +225,7 @@ For detailed development guide, see [Architecture Documentation](docs/architectu
 ## 📊 Currently Supported Providers
 
 - ✅ **PPInfra** - 38 models with reasoning, function calling, and vision capability detection
-- 🚧 **OpenRouter** - Planned
+- ✅ **OpenRouter** - 600+ models with comprehensive capability detection and metadata
 - 🚧 **OpenAI** - Planned  
 - 🚧 **Google Gemini** - Planned
 

dist/all.json

@@ -1,7 +1,7 @@
 {
   "provider": "ppinfra",
   "providerName": "PPInfra",
-  "lastUpdated": "2025-08-30T09:13:28.078738Z",
+  "lastUpdated": "2025-08-30T10:30:25.289860Z",
   "models": [
     {
       "id": "deepseek/deepseek-v3.1",

dist/openrouter.json

@@ -4,6 +4,7 @@ use anyhow::Result;
 
 use public_provider_conf::{
     providers::ppinfra::PPInfraProvider,
+    providers::openrouter::OpenRouterProvider,
     fetcher::DataFetcher,
     output::OutputManager,
 };
@@ -63,12 +64,18 @@ async fn fetch_all_providers(output_dir: String, _config_path: String) -> Result
 
     let mut fetcher = DataFetcher::new();
 
-    // Add PPInfra provider as example
+    // Add PPInfra provider
     let ppinfra = Arc::new(PPInfraProvider::new(
         "https://api.ppinfra.com/openai/v1/models".to_string()
     ));
     fetcher.add_provider(ppinfra);
 
+    // Add OpenRouter provider
+    let openrouter = Arc::new(OpenRouterProvider::new(
+        "https://openrouter.ai/api/v1/models".to_string()
+    ));
+    fetcher.add_provider(openrouter);
+    
     let provider_data = fetcher.fetch_all().await?;
 
     let output_manager = OutputManager::new(output_dir);

dist/ppinfra.json

@@ -1,4 +1,5 @@
 pub mod ppinfra;
+pub mod openrouter;
 
 use async_trait::async_trait;
 use anyhow::Result;

src/main.rs

@@ -0,0 +1,137 @@
+use async_trait::async_trait;
+use anyhow::Result;
+use serde::Deserialize;
+use crate::models::{ModelInfo, ModelType};
+use crate::providers::Provider;
+
+#[derive(Debug, Deserialize)]
+struct OpenRouterArchitecture {
+    modality: Option<String>,
+    #[serde(rename = "input_modalities")]
+    input_modalities: Option<Vec<String>>,
+    #[serde(rename = "output_modalities")]
+    output_modalities: Option<Vec<String>>,
+    tokenizer: Option<String>,
+    #[serde(rename = "instruct_type")]
+    instruct_type: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenRouterTopProvider {
+    #[serde(rename = "is_moderated")]
+    is_moderated: Option<bool>,
+    #[serde(rename = "context_length")]
+    context_length: Option<u32>,
+    #[serde(rename = "max_completion_tokens")]
+    max_completion_tokens: Option<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenRouterModel {
+    id: String,
+    #[serde(rename = "canonical_slug")]
+    canonical_slug: Option<String>,
+    #[serde(rename = "hugging_face_id")]
+    hugging_face_id: Option<String>,
+    name: String,
+    created: Option<i64>,
+    description: Option<String>,
+    architecture: Option<OpenRouterArchitecture>,
+    #[serde(rename = "top_provider")]
+    top_provider: Option<OpenRouterTopProvider>,
+    #[serde(rename = "context_length")]
+    context_length: u32,
+    #[serde(rename = "per_request_limits")]
+    per_request_limits: Option<serde_json::Value>,
+    #[serde(rename = "supported_parameters")]
+    supported_parameters: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenRouterResponse {
+    data: Vec<OpenRouterModel>,
+}
+
+pub struct OpenRouterProvider {
+    api_url: String,
+    client: reqwest::Client,
+}
+
+impl OpenRouterProvider {
+    pub fn new(api_url: String) -> Self {
+        Self {
+            api_url,
+            client: reqwest::Client::new(),
+        }
+    }
+
+    fn convert_model(&self, model: OpenRouterModel) -> ModelInfo {
+        let vision = model.architecture
+            .as_ref()
+            .and_then(|arch| arch.input_modalities.as_ref())
+            .map(|modalities| modalities.iter().any(|m| m.contains("image")))
+            .unwrap_or(false);
+
+        let function_call = model.supported_parameters
+            .as_ref()
+            .map(|params| params.iter().any(|p| p.contains("tool") || p.contains("function")))
+            .unwrap_or(false);
+
+        let reasoning = model.supported_parameters
+            .as_ref()
+            .map(|params| params.iter().any(|p| p.contains("reasoning") || p.contains("include_reasoning")))
+            .unwrap_or(false);
+
+        let max_tokens = model.top_provider
+            .as_ref()
+            .and_then(|tp| tp.max_completion_tokens)
+            .unwrap_or(4096);
+
+        let context_length = model.top_provider
+            .as_ref()
+            .and_then(|tp| tp.context_length)
+            .unwrap_or(model.context_length);
+
+        ModelInfo::new(
+            model.id,
+            model.name,
+            context_length,
+            max_tokens,
+            vision,
+            function_call,
+            reasoning,
+            ModelType::Chat,
+            model.description,
+        )
+    }
+}
+
+#[async_trait]
+impl Provider for OpenRouterProvider {
+    async fn fetch_models(&self) -> Result<Vec<ModelInfo>> {
+        let response_text = self.client
+            .get(&self.api_url)
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        let response: OpenRouterResponse = serde_json::from_str(&response_text)
+            .map_err(|e| anyhow::anyhow!("Failed to parse OpenRouter response: {}\nFirst 1000 chars: {}", e, &response_text[..std::cmp::min(1000, response_text.len())]))?;
+
+        let models = response.data
+            .into_iter()
+            .map(|model| self.convert_model(model))
+            .collect();
+
+        Ok(models)
+    }
+
+    fn provider_id(&self) -> &str {
+        "openrouter"
+    }
+
+    fn provider_name(&self) -> &str {
+        "OpenRouter"
+    }
+}