Stabilize provider routing and quality checks

.github/workflows/ci.yml

@@ -136,3 +136,60 @@ jobs:
         with:
           name: rust-lcov
           path: src-tauri/lcov.info
+
+  check-cross-platform:
+    name: Cross-platform Compatibility (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 35
+    continue-on-error: true
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Linux system dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libwebkit2gtk-4.1-dev \
+            libayatana-appindicator3-dev \
+            librsvg2-dev \
+            patchelf \
+            libxdo-dev
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: "26.1.0"
+          cache: "npm"
+          cache-dependency-path: src/package-lock.json
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@631a55b12751854ce901bb631d5902ceb48146f7 # stable
+        with:
+          toolchain: 1.95.0
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@65012b490220f477f20ab979e35ae732e6de4e68 # node24
+        continue-on-error: true
+        with:
+          workspaces: "src-tauri -> target"
+          cache-targets: false
+
+      - name: Install Dependencies
+        run: |
+          cd src
+          npm ci
+
+      - name: Frontend Type Check
+        run: |
+          cd src
+          npm run typecheck
+
+      - name: Backend Target Check
+        run: |
+          cd src-tauri
+          cargo check --all-targets --all-features

src-tauri/src/api/system/log_targets.rs

@@ -0,0 +1,102 @@
+use crate::domain::engine::manager::canonical_engine_id;
+use crate::errors::AppError;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+pub(super) fn resolve_console_log_target(view_id: &str) -> Result<PathBuf, AppError> {
+    if let Some(engine_id) = view_id.strip_prefix("engine:") {
+        let engine_id = canonical_engine_id(engine_id);
+        validate_console_log_segment(&engine_id, "Engine ID")?;
+        return Ok(crate::utils::paths::ENGINE_LOGS_DIR.join(engine_id));
+    }
+
+    if let Some(module_id) = view_id.strip_prefix("module:") {
+        crate::domain::modules::downloader::validate_module_id(module_id)?;
+        return Ok(crate::utils::paths::INTEGRATION_LOGS_DIR.join(module_id));
+    }
+
+    Ok(crate::utils::paths::LOG_DIR.clone())
+}
+
+fn validate_console_log_segment(value: &str, label: &str) -> Result<(), AppError> {
+    if value.is_empty() {
+        return Err(AppError::Validation(format!("{label} cannot be empty")));
+    }
+
+    if !value
+        .chars()
+        .all(|character| character.is_ascii_alphanumeric() || character == '-')
+    {
+        return Err(AppError::Validation(format!(
+            "{label} contains invalid characters"
+        )));
+    }
+
+    Ok(())
+}
+
+pub(super) fn canonical_console_view_id(view_id: &str) -> String {
+    if let Some(engine_id) = view_id.strip_prefix("engine:") {
+        return format!("engine:{}", canonical_engine_id(engine_id));
+    }
+
+    view_id.trim().to_string()
+}
+
+pub(super) fn clear_console_log_target(view_id: &str, target: &Path) -> Result<(), AppError> {
+    if view_id == "general" {
+        clear_log_file(&target.join("axelate.log"))?;
+        return Ok(());
+    }
+
+    if !target.exists() {
+        return Ok(());
+    }
+
+    for entry in fs::read_dir(target)? {
+        let path = entry?.path();
+        if path
+            .extension()
+            .is_some_and(|extension| extension.eq_ignore_ascii_case("log"))
+        {
+            clear_log_file(&path)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn clear_log_file(path: &Path) -> Result<(), AppError> {
+    if !path.exists() {
+        return Ok(());
+    }
+
+    fs::OpenOptions::new()
+        .write(true)
+        .truncate(true)
+        .open(path)?;
+    Ok(())
+}
+
+pub(super) fn clear_all_console_log_files(root: &Path) -> Result<(), AppError> {
+    if !root.exists() {
+        return Ok(());
+    }
+
+    for entry in fs::read_dir(root)? {
+        let path = entry?.path();
+        if path.is_dir() {
+            clear_all_console_log_files(&path)?;
+            continue;
+        }
+
+        if path
+            .extension()
+            .is_some_and(|extension| extension.eq_ignore_ascii_case("log"))
+        {
+            clear_log_file(&path)?;
+        }
+    }
+
+    Ok(())
+}

src-tauri/src/api/system/logs.rs

@@ -6,11 +6,15 @@ use crate::infrastructure::logging::{self as logs, LogEntry};
 use crate::models::{SelectedModule, UIState};
 use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
-use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::Arc;
 use tauri::State;
 
+use super::log_targets::{
+    canonical_console_view_id, clear_all_console_log_files, clear_console_log_target,
+    resolve_console_log_target,
+};
+
 struct ConsoleOverviewBuilder;
 
 struct ConsoleLabelFormatter;
@@ -203,104 +207,6 @@ const fn describe_status(status: ConsoleRuntimeStatus) -> &'static str {
     }
 }
 
-fn resolve_console_log_target(view_id: &str) -> Result<PathBuf, AppError> {
-    if let Some(engine_id) = view_id.strip_prefix("engine:") {
-        let engine_id = canonical_engine_id(engine_id);
-        validate_console_log_segment(&engine_id, "Engine ID")?;
-        return Ok(crate::utils::paths::ENGINE_LOGS_DIR.join(engine_id));
-    }
-
-    if let Some(module_id) = view_id.strip_prefix("module:") {
-        crate::domain::modules::downloader::validate_module_id(module_id)?;
-        return Ok(crate::utils::paths::INTEGRATION_LOGS_DIR.join(module_id));
-    }
-
-    Ok(crate::utils::paths::LOG_DIR.clone())
-}
-
-fn validate_console_log_segment(value: &str, label: &str) -> Result<(), AppError> {
-    if value.is_empty() {
-        return Err(AppError::Validation(format!("{label} cannot be empty")));
-    }
-
-    if !value
-        .chars()
-        .all(|character| character.is_ascii_alphanumeric() || character == '-')
-    {
-        return Err(AppError::Validation(format!(
-            "{label} contains invalid characters"
-        )));
-    }
-
-    Ok(())
-}
-
-fn canonical_console_view_id(view_id: &str) -> String {
-    if let Some(engine_id) = view_id.strip_prefix("engine:") {
-        return format!("engine:{}", canonical_engine_id(engine_id));
-    }
-
-    view_id.trim().to_string()
-}
-
-fn clear_console_log_target(view_id: &str, target: &Path) -> Result<(), AppError> {
-    if view_id == "general" {
-        clear_log_file(&target.join("axelate.log"))?;
-        return Ok(());
-    }
-
-    if !target.exists() {
-        return Ok(());
-    }
-
-    for entry in fs::read_dir(target)? {
-        let path = entry?.path();
-        if path
-            .extension()
-            .is_some_and(|extension| extension.eq_ignore_ascii_case("log"))
-        {
-            clear_log_file(&path)?;
-        }
-    }
-
-    Ok(())
-}
-
-fn clear_log_file(path: &Path) -> Result<(), AppError> {
-    if !path.exists() {
-        return Ok(());
-    }
-
-    fs::OpenOptions::new()
-        .write(true)
-        .truncate(true)
-        .open(path)?;
-    Ok(())
-}
-
-fn clear_all_console_log_files(root: &Path) -> Result<(), AppError> {
-    if !root.exists() {
-        return Ok(());
-    }
-
-    for entry in fs::read_dir(root)? {
-        let path = entry?.path();
-        if path.is_dir() {
-            clear_all_console_log_files(&path)?;
-            continue;
-        }
-
-        if path
-            .extension()
-            .is_some_and(|extension| extension.eq_ignore_ascii_case("log"))
-        {
-            clear_log_file(&path)?;
-        }
-    }
-
-    Ok(())
-}
-
 impl ConsoleOverviewBuilder {
     async fn build(
         engine_state: &crate::domain::engine::types::EngineState,

src-tauri/src/api/system/mod.rs

@@ -4,6 +4,7 @@ pub mod bootstrap;
 pub mod config;
 /// Health check commands
 pub mod health;
+mod log_targets;
 /// Logging commands
 pub mod logs;
 

src/features/ai/services/AIBridgeMessageController.test.ts

@@ -161,6 +161,29 @@ function createImageController() {
 }
 
 describe('AIBridgeMessageController custom providers', () => {
+    it('routes built-in cloud text providers through their OpenRouter catalog base URL', async () => {
+        const { controller, transport, manager, context } = createTextController();
+        manager.activeProviderId = 'gpt';
+        manager.model = 'openai/gpt-5.5';
+        manager.getProviderBaseUrl.mockReturnValue('https://openrouter.ai/api/v1');
+        context.aiSettings.getInternetAccessEnabled.mockReturnValue(true);
+
+        await controller.sendMessage('What is the latest release today?', 'chat', [], []);
+
+        expect(context.aiSettings.getThinkingLevel).toHaveBeenCalledWith('gpt');
+        expect(context.aiSettings.getInternetAccessEnabled).toHaveBeenCalledWith('gpt');
+        expect(manager.getProviderBaseUrl).toHaveBeenCalledWith('gpt');
+        expect(transport.send).toHaveBeenCalledWith(
+            expect.objectContaining({
+                provider: 'gpt',
+                model: 'openai/gpt-5.5',
+                cloud_api_base_url: 'https://openrouter.ai/api/v1',
+                thinking_level: 'high',
+                web_search: { enabled: true },
+            }),
+        );
+    });
+
     it('routes custom text providers through the custom backend slot without changing model ids', async () => {
         const { controller, transport } = createTextController();
 

src/features/ai/ui/AISettingsRenderer.test.ts

@@ -229,6 +229,40 @@ describe('AISettingsRenderer', () => {
         expect(settingsService.getSecureKeyMeta).toHaveBeenCalledWith(CUSTOM_TEXT_PROVIDER_ID);
     });
 
+    it('labels built-in providers as OpenRouter and custom text as a separate provider', async () => {
+        const container = document.getElementById('root') as HTMLElement;
+
+        await aiSettingsRenderer.render(container, {
+            id: 'gpt',
+            name: 'OpenAI',
+            apiProviderData: { models },
+        } as never);
+
+        expect(container.textContent).toContain('OpenRouter API key');
+        expect(container.textContent).toContain('Built-in cloud cards use OpenRouter.');
+        expect(container.textContent).not.toContain('Custom provider API key');
+        expect(container.querySelector('.ai-api-endpoint-card')).toBeNull();
+
+        await aiSettingsRenderer.render(container, {
+            id: CUSTOM_TEXT_PROVIDER_ID,
+            name: 'Custom',
+            apiProviderData: { models: [] },
+        } as never);
+
+        expect(container.textContent).toContain('Custom provider API key');
+        expect(container.textContent).toContain('Uses a custom provider key.');
+        expect(container.textContent).not.toContain('Built-in cloud cards use OpenRouter.');
+        expect(
+            container.querySelector('.ai-api-endpoint-card[data-provider="openrouter"]'),
+        ).not.toBeNull();
+        expect(
+            container.querySelector('.ai-api-endpoint-card[data-provider="openai"]'),
+        ).not.toBeNull();
+        expect(
+            container.querySelector('.ai-api-endpoint-card[data-provider="custom"]'),
+        ).not.toBeNull();
+    });
+
     it('validates custom provider keys against the selected API endpoint', async () => {
         vi.useFakeTimers();
         const container = document.getElementById('root') as HTMLElement;