Make /model list available providers

Author: Benedikt Koehler

.github/workflows/release.yml

@@ -0,0 +1,45 @@
+name: release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            bin: nanocode
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            bin: nanocode.exe
+          - os: macos-14
+            target: aarch64-apple-darwin
+            bin: nanocode
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - run: cargo build --release --target ${{ matrix.target }}
+      - run: |
+          mkdir -p dist
+          cp target/${{ matrix.target }}/release/${{ matrix.bin }} dist/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.target }}
+          path: dist/*
+  release:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+      - uses: softprops/action-gh-release@v2
+        with:
+          files: dist/**/*

src/main.rs

@@ -69,7 +69,7 @@ fn main() {
                     print_header(&model_label, chatbot_label.as_deref());
                     println!();
                 }
-                None => print_error("LLM error: /model requires both OPENROUTER_API_KEY and HYBRIDAI_API_KEY"),
+                None => print_error("LLM error: No providers available"),
             }
             continue;
         }
@@ -431,15 +431,28 @@ fn build_orbit_frame(step: usize) -> String {
 }
 
 fn select_provider(current: &Provider) -> Option<ProviderConfig> {
-    let open = load_openrouter()?;
-    let hybrid = load_hybrid()?;
-    let options = vec![
-        format!("OpenRouter: {}", open.model),
-        format!("HybridAI: {}", hybrid.model),
-    ];
-    let initial = if matches!(current, Provider::OpenRouter) { 0 } else { 1 };
+    let mut options = Vec::new();
+    let mut configs = Vec::new();
+    if let Some(open) = load_openrouter() {
+        options.push(format!("OpenRouter: {}", open.model));
+        configs.push(open);
+    }
+    if let Some(hybrid) = load_hybrid() {
+        options.push(format!("HybridAI: {}", hybrid.model));
+        configs.push(hybrid);
+    }
+    if options.is_empty() { return None; }
+    if options.len() == 1 {
+        let next = configs.into_iter().next();
+        if let Some(ref cfg) = next { let _ = persist_model_config(cfg); }
+        return next;
+    }
+    let initial = match current {
+        Provider::OpenRouter => options.iter().position(|o| o.starts_with("OpenRouter")).unwrap_or(0),
+        Provider::HybridAI => options.iter().position(|o| o.starts_with("HybridAI")).unwrap_or(0),
+    };
     let selected = select_menu("Select provider", &options, Some(initial))?;
-    let next = match selected { 0 => Some(open), 1 => Some(hybrid), _ => None };
+    let next = configs.into_iter().nth(selected);
     if let Some(ref cfg) = next { let _ = persist_model_config(cfg); }
     next
 }