@swarmai/local-agent 0.1.0

package/src/agenticChatHandler.js

@@ -0,0 +1,566 @@
+/**
+ * Agentic Chat Handler
+ *
+ * Spawns Claude Code CLI with Ollama as the backend provider,
+ * giving full agentic capabilities (tool use, file editing, multi-turn)
+ * powered by local or cloud models.
+ *
+ * Falls back to raw Ollama HTTP chat if Claude CLI is unavailable.
+ */
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { buildAgenticChatClaudeMd } = require('./agenticChatClaudeMd');
+
+const MAX_OUTPUT = 500 * 1024; // 500KB
+const MAX_TURNS_CAP = 50;
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000; // 30 min sync default
+const ASYNC_TIMEOUT_MS = 60 * 60 * 1000;  // 60 min async max
+const STALE_DEFAULT_MS = 5 * 60 * 1000;   // 5 min stale threshold
+
+// Regex for [FILE_GENERATED: /path/to/file] markers
+const FILE_MARKER_RE = /\[FILE_GENERATED:\s*([^\]]+)\]/g;
+
+// Windows/Unix path regex for scanning output
+const WIN_PATH_RE = /[A-Za-z]:\\[\w\\./ -]+/g;
+const UNIX_PATH_RE = /\/[\w./ -]{4,}/g;
+
+/**
+ * Create the agentic chat handler with injected dependencies.
+ *
+ * @param {object} deps
+ * @param {Map} deps.activeProcesses - Shared map for kill support
+ * @param {Function} deps.emitChunk - Streaming output emitter
+ * @param {Function} deps.uploadToServer - File upload function
+ * @param {Function} deps.getSecurityConfig - Security config getter
+ * @param {Function} deps.validateFilePath - Path validation function
+ * @returns {Function} handleAgenticChat(params, commandId)
+ */
+function createAgenticChatHandler(deps) {
+  const { activeProcesses, emitChunk, uploadToServer, getSecurityConfig, validateFilePath } = deps;
+
+  /**
+   * Handle an agenticChat command.
+   *
+   * @param {object} params
+   * @param {string} params.model - Ollama model name (e.g., 'qwen3.5:397b-cloud')
+   * @param {Array} params.messages - [{role, content}] conversation
+   * @param {string} [params.systemPrompt] - Agent personality
+   * @param {string} [params.workspaceProfile] - Workspace profile name
+   * @param {string} [params.ollamaBaseUrl] - Override Ollama URL
+   * @param {number} [params.timeout] - Timeout in ms
+   * @param {boolean} [params.asyncMode] - Enable async (fire-and-deliver)
+   * @param {number} [params.staleThresholdMs] - Kill if no output for this long
+   * @param {number} [params.maxTurns] - Max Claude turns (capped at 50)
+   * @param {string} [params.cwd] - Working directory override
+   * @param {string} [params.taskContext] - Task description for CLAUDE.md
+   * @param {string} commandId - Unique command ID for streaming/kill
+   * @returns {Promise<object>} Structured result
+   */
+  async function handleAgenticChat(params, commandId) {
+    const {
+      model,
+      messages = [],
+      systemPrompt = '',
+      workspaceProfile = 'agentic-chat',
+      ollamaBaseUrl = 'http://localhost:11434',
+      timeout,
+      asyncMode = false,
+      staleThresholdMs = STALE_DEFAULT_MS,
+      maxTurns = 10,
+      cwd,
+      taskContext = '',
+    } = params || {};
+
+    if (!model) throw new Error('agenticChat: model is required');
+    if (!messages || messages.length === 0) throw new Error('agenticChat: messages array is required');
+
+    // Validate Ollama base URL (prevent SSRF)
+    _validateOllamaUrl(ollamaBaseUrl);
+
+    // Find Claude CLI executable
+    const claudePath = _findClaudeExecutable();
+    if (!claudePath) {
+      console.log('[agenticChat] Claude CLI not found, falling back to raw Ollama');
+      return _fallbackToOllamaChat(params);
+    }
+
+    // Resolve workspace
+    const workspacePath = _resolveWorkspace(workspaceProfile, cwd);
+    const outputDir = path.join(workspacePath, 'output');
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    // Write CLAUDE.md
+    const claudeMdContent = buildAgenticChatClaudeMd({
+      profileName: workspaceProfile,
+      systemPrompt,
+      model,
+      taskContext,
+      outputDir,
+    });
+    fs.writeFileSync(path.join(workspacePath, 'CLAUDE.md'), claudeMdContent, 'utf-8');
+
+    // Take pre-execution snapshot of output dir
+    const preSnapshot = _snapshotDir(outputDir);
+
+    // Build prompt from messages (last user message + context)
+    const prompt = _buildPromptFromMessages(messages, systemPrompt);
+
+    // Build spawn args — use the full path found by _findClaudeExecutable
+    const isWindows = os.platform() === 'win32';
+    const executable = claudePath;
+    const effectiveMaxTurns = Math.min(maxTurns || 10, MAX_TURNS_CAP);
+
+    const args = [
+      '--dangerously-skip-permissions',
+      '-p', prompt,
+      '--model', model,
+      '--max-turns', String(effectiveMaxTurns),
+    ];
+
+    // Environment: redirect Claude to Ollama
+    // Per Ollama docs: ANTHROPIC_API_KEY="" but Windows EINVAL on empty strings.
+    // Using 'ollama' as dummy value — forces Claude CLI to use ANTHROPIC_BASE_URL
+    // instead of its stored Anthropic credentials.
+    // The hang fix was: stdin='ignore' + removing --output-format text (not the key).
+    const env = { ...process.env };
+    env.ANTHROPIC_BASE_URL = ollamaBaseUrl;
+    env.ANTHROPIC_AUTH_TOKEN = 'ollama';
+    env.ANTHROPIC_API_KEY = 'ollama';
+    // Remove CLAUDECODE env var to prevent "nested session" detection
+    // when this agent is launched from within a Claude Code session
+    delete env.CLAUDECODE;
+
+    // Timeout
+    const effectiveTimeout = asyncMode
+      ? Math.min(timeout || ASYNC_TIMEOUT_MS, ASYNC_TIMEOUT_MS)
+      : Math.min(timeout || DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS);
+
+    console.log(`[agenticChat] Spawning: ${executable} ${args.map((a, i) => i === 2 ? '"<prompt>"' : a).join(' ')}`);
+    console.log(`[agenticChat] CWD: ${workspacePath}`);
+    console.log(`[agenticChat] ANTHROPIC_BASE_URL=${ollamaBaseUrl}, ANTHROPIC_API_KEY=${env.ANTHROPIC_API_KEY}, MODEL=${model}`);
+
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let stdout = '';
+      let stderr = '';
+      let killed = false;
+      let killTimer = null;
+      let lastOutputTime = Date.now();
+      let staleCheckTimer = null;
+
+      const child = spawn(executable, args, {
+        cwd: workspacePath,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],  // stdin='ignore' — prevents hang waiting for input
+        windowsHide: true,
+        shell: isWindows,  // Windows requires shell:true for .cmd files
+      });
+
+      // Track for kill support
+      if (commandId) activeProcesses.set(commandId, child);
+
+      child.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        lastOutputTime = Date.now();
+        if (commandId) emitChunk(commandId, chunk, 'stdout');
+        if (stdout.length > MAX_OUTPUT) {
+          stdout = stdout.substring(0, MAX_OUTPUT);
+          if (!killed) { killed = true; child.kill('SIGTERM'); }
+        }
+      });
+
+      child.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        lastOutputTime = Date.now();
+        if (commandId) emitChunk(commandId, chunk, 'stderr');
+        if (stderr.length > MAX_OUTPUT) {
+          stderr = stderr.substring(0, MAX_OUTPUT);
+        }
+      });
+
+      // Stale detection for async mode
+      if (asyncMode) {
+        staleCheckTimer = setInterval(() => {
+          const silentMs = Date.now() - lastOutputTime;
+          if (silentMs > staleThresholdMs && !killed) {
+            killed = true;
+            child.kill('SIGTERM');
+            setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 5000);
+            if (staleCheckTimer) clearInterval(staleCheckTimer);
+          }
+        }, 30000);
+      }
+
+      // Timeout handler
+      const timeoutTimer = setTimeout(() => {
+        if (!killed) {
+          killed = true;
+          child.kill('SIGTERM');
+          killTimer = setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 5000);
+        }
+      }, effectiveTimeout);
+
+      child.on('close', async (code) => {
+        clearTimeout(timeoutTimer);
+        if (killTimer) clearTimeout(killTimer);
+        if (staleCheckTimer) clearInterval(staleCheckTimer);
+        if (commandId) activeProcesses.delete(commandId);
+
+        const duration = Date.now() - startTime;
+        const truncated = stdout.length >= MAX_OUTPUT;
+
+        // Debug logging
+        console.log(`[agenticChat] Process exited with code ${code} after ${duration}ms`);
+        if (stderr) console.log(`[agenticChat] stderr: ${stderr.substring(0, 500)}`);
+        if (!stdout && !stderr) console.log(`[agenticChat] No output at all. Executable: ${executable}, args: ${JSON.stringify(args).substring(0, 200)}`);
+
+        // 3-layer file detection
+        const detectedFiles = _detectFiles(stdout, workspacePath, outputDir, preSnapshot);
+
+        // Upload detected files to server
+        const uploadedFiles = [];
+        for (const filePath of detectedFiles) {
+          try {
+            const uploaded = await _uploadFile(filePath, uploadToServer);
+            if (uploaded) uploadedFiles.push(uploaded);
+          } catch (e) {
+            // Upload failure is non-fatal
+            uploadedFiles.push({ path: filePath, error: e.message });
+          }
+        }
+
+        // If Claude CLI failed quickly (< 5s with exit code != 0 and no stdout),
+        // it means the CLI itself failed — fallback to raw Ollama
+        if (code !== 0 && !stdout && duration < 5000) {
+          console.log(`[agenticChat] Claude CLI failed fast (${duration}ms, code=${code}). Falling back to Ollama.`);
+          console.log(`[agenticChat] stderr: ${stderr.substring(0, 300)}`);
+          try {
+            const fallbackResult = await _fallbackToOllamaChat(params);
+            return resolve(fallbackResult);
+          } catch (fbErr) {
+            // Fallback also failed — return the original error
+            console.log(`[agenticChat] Ollama fallback also failed: ${fbErr.message}`);
+          }
+        }
+
+        // If stdout is empty but stderr has content, include stderr as the response
+        const effectiveContent = stdout || (stderr ? `[stderr] ${stderr}` : '');
+
+        const result = {
+          content: effectiveContent,
+          model,
+          provider: 'claude+ollama',
+          files: uploadedFiles,
+          exitCode: code,
+          duration,
+          truncated,
+          workspacePath,
+          async: asyncMode,
+        };
+
+        // Async mode: also emit via async-result event
+        if (asyncMode && deps._socket && commandId) {
+          deps._socket.emit('command:async-result', {
+            commandId,
+            result,
+            error: code !== 0 ? `Claude CLI exited with code ${code}` : null,
+          });
+        }
+
+        resolve(result);
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutTimer);
+        if (killTimer) clearTimeout(killTimer);
+        if (staleCheckTimer) clearInterval(staleCheckTimer);
+        if (commandId) activeProcesses.delete(commandId);
+
+        // Fallback to raw Ollama on spawn failure
+        console.log(`[agenticChat] Claude CLI spawn failed: ${err.message}. Falling back to raw Ollama.`);
+        _fallbackToOllamaChat(params).then(resolve).catch(reject);
+      });
+    });
+  }
+
+  return handleAgenticChat;
+}
+
+// =====================================================
+// Internal helpers
+// =====================================================
+
+/**
+ * Validate Ollama base URL to prevent SSRF
+ */
+function _validateOllamaUrl(urlStr) {
+  try {
+    const url = new URL(urlStr);
+    const hostname = url.hostname;
+    const allowed = ['localhost', '127.0.0.1', '0.0.0.0', '::1'];
+    if (!allowed.includes(hostname)) {
+      throw new Error(`agenticChat: ollamaBaseUrl must be localhost. Got: ${hostname}`);
+    }
+  } catch (e) {
+    if (e.message.includes('agenticChat')) throw e;
+    throw new Error(`agenticChat: invalid ollamaBaseUrl: ${urlStr}`);
+  }
+}
+
+/**
+ * Find Claude CLI executable path.
+ * Returns the full path or executable name, or null if not found.
+ * On Windows, claude is typically installed as claude.exe (not .cmd).
+ */
+function _findClaudeExecutable() {
+  try {
+    const { execSync } = require('child_process');
+    const isWindows = os.platform() === 'win32';
+
+    if (isWindows) {
+      // Try multiple possible names: claude.exe, claude.cmd, claude
+      const cmd = 'where claude.exe 2>nul || where claude.cmd 2>nul || where claude 2>nul';
+      const result = execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], shell: true }).trim();
+      // `where` returns multiple lines if found in multiple locations; take the first
+      const firstPath = result.split('\n')[0].trim();
+      if (firstPath) return firstPath;
+    } else {
+      const result = execSync('which claude', { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], shell: true }).trim();
+      if (result) return result;
+    }
+  } catch { /* not found */ }
+  return null;
+}
+
+/**
+ * Resolve workspace directory
+ */
+function _resolveWorkspace(profileName, explicitCwd) {
+  if (explicitCwd && fs.existsSync(explicitCwd)) return explicitCwd;
+
+  try {
+    const { getWorkspaceManager } = require('./workspace');
+    const wm = getWorkspaceManager();
+    if (wm) {
+      return wm.ensureProfileWorkspace(profileName, {});
+    }
+  } catch { /* fall through */ }
+
+  // Fallback: create workspace in home dir
+  const fallback = path.join(os.homedir(), '.swarmai', 'agentic-chat', profileName || 'default');
+  fs.mkdirSync(fallback, { recursive: true });
+  return fallback;
+}
+
+/**
+ * Build a single prompt string from messages array
+ */
+function _buildPromptFromMessages(messages, systemPrompt) {
+  const parts = [];
+
+  // System prompt as context
+  if (systemPrompt) {
+    parts.push(`[System Instructions]\n${systemPrompt}\n`);
+  }
+
+  // Include conversation history (last 10 messages for context window efficiency)
+  const recent = messages.slice(-10);
+  for (const msg of recent) {
+    const role = msg.role === 'user' ? 'User' : msg.role === 'assistant' ? 'Assistant' : msg.role;
+    parts.push(`[${role}]\n${msg.content}`);
+  }
+
+  return parts.join('\n\n');
+}
+
+/**
+ * Snapshot a directory — returns Set of {filename: mtime} entries
+ */
+function _snapshotDir(dirPath) {
+  const snapshot = new Map();
+  if (!fs.existsSync(dirPath)) return snapshot;
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const fullPath = path.join(dirPath, entry.name);
+        try {
+          const stat = fs.statSync(fullPath);
+          snapshot.set(fullPath, stat.mtimeMs);
+        } catch { /* skip */ }
+      }
+    }
+  } catch { /* non-critical */ }
+  return snapshot;
+}
+
+/**
+ * 3-layer file detection
+ * Layer 1: [FILE_GENERATED:] markers
+ * Layer 2: Path regex scan
+ * Layer 3: Directory diff
+ */
+function _detectFiles(stdout, workspacePath, outputDir, preSnapshot) {
+  const found = new Set();
+
+  // Layer 1: Sentinel markers
+  let match;
+  while ((match = FILE_MARKER_RE.exec(stdout)) !== null) {
+    const filePath = match[1].trim();
+    if (fs.existsSync(filePath)) {
+      found.add(path.resolve(filePath));
+    }
+  }
+
+  // Layer 2: Path regex scan
+  const isWindows = os.platform() === 'win32';
+  const pathRegex = isWindows ? WIN_PATH_RE : UNIX_PATH_RE;
+  const pathMatches = stdout.match(pathRegex) || [];
+  for (const p of pathMatches) {
+    const resolved = path.resolve(p.trim());
+    // Only include paths within workspace
+    if (resolved.startsWith(workspacePath) && fs.existsSync(resolved)) {
+      try {
+        if (fs.statSync(resolved).isFile()) {
+          found.add(resolved);
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  // Layer 3: Directory diff (new or modified files in output/)
+  if (fs.existsSync(outputDir)) {
+    try {
+      const entries = fs.readdirSync(outputDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        const fullPath = path.join(outputDir, entry.name);
+        try {
+          const stat = fs.statSync(fullPath);
+          const prevMtime = preSnapshot.get(fullPath);
+          if (!prevMtime || stat.mtimeMs > prevMtime) {
+            found.add(fullPath);
+          }
+        } catch { /* skip */ }
+      }
+    } catch { /* non-critical */ }
+  }
+
+  return [...found];
+}
+
+/**
+ * Upload a file to the server
+ */
+async function _uploadFile(filePath, uploadToServer) {
+  if (!uploadToServer) {
+    return { path: filePath, originalName: path.basename(filePath), size: fs.statSync(filePath).size };
+  }
+
+  const buffer = fs.readFileSync(filePath);
+  const originalName = path.basename(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = _getMimeType(ext);
+
+  const result = await uploadToServer(buffer, originalName, mimeType);
+  if (result) {
+    return {
+      downloadUrl: result.downloadUrl,
+      originalName,
+      mimeType,
+      size: buffer.length,
+    };
+  }
+
+  // Fallback: return local path info
+  return { path: filePath, originalName, size: buffer.length };
+}
+
+/**
+ * Basic MIME type lookup
+ */
+function _getMimeType(ext) {
+  const map = {
+    '.txt': 'text/plain', '.md': 'text/markdown', '.json': 'application/json',
+    '.html': 'text/html', '.css': 'text/css', '.js': 'application/javascript',
+    '.ts': 'application/typescript', '.py': 'text/x-python',
+    '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.svg': 'image/svg+xml',
+    '.csv': 'text/csv', '.xml': 'application/xml', '.zip': 'application/zip',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  };
+  return map[ext] || 'application/octet-stream';
+}
+
+/**
+ * Fallback: raw Ollama HTTP chat (when Claude CLI is unavailable)
+ */
+async function _fallbackToOllamaChat(params) {
+  const { model, messages = [], systemPrompt, ollamaBaseUrl = 'http://localhost:11434' } = params;
+  const http = require('http');
+
+  const fullMessages = [...messages];
+  if (systemPrompt && !fullMessages.find(m => m.role === 'system')) {
+    fullMessages.unshift({ role: 'system', content: systemPrompt });
+  }
+
+  const payload = JSON.stringify({
+    model,
+    messages: fullMessages,
+    stream: false,
+    options: { temperature: 0.7, num_predict: 4096 },
+  });
+
+  return new Promise((resolve, reject) => {
+    const url = new URL(`${ollamaBaseUrl}/api/chat`);
+    const req = http.request({
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+      timeout: 120000,
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve({
+            content: parsed.message?.content || '',
+            model: parsed.model || model,
+            provider: 'ollama-fallback',
+            files: [],
+            exitCode: 0,
+            duration: parsed.total_duration || 0,
+            truncated: false,
+            fallback: true,
+            fallbackReason: 'Claude CLI not available',
+            usage: {
+              promptTokens: parsed.prompt_eval_count || 0,
+              completionTokens: parsed.eval_count || 0,
+            },
+          });
+        } catch (e) {
+          reject(new Error(`Ollama fallback: invalid response — ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => reject(new Error(`Ollama fallback failed: ${e.message}`)));
+    req.on('timeout', () => { req.destroy(); reject(new Error('Ollama fallback timed out')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+module.exports = { createAgenticChatHandler };

package/src/aiProviderScanner.js

@@ -0,0 +1,115 @@
+/**
+ * AI Provider Scanner for Local Agent
+ *
+ * Auto-discovers local AI services (Ollama, LM Studio) on the user's machine.
+ * Reports available providers and models to the SwarmAI server so they can be
+ * used as AI providers via Task Routing.
+ */
+
+const http = require('http');
+
+const SCAN_TIMEOUT_MS = 3000; // 3s per service
+
+/**
+ * Known local AI service endpoints to scan
+ */
+const AI_SERVICES = [
+  {
+    type: 'ollama',
+    baseUrl: 'http://localhost:11434',
+    modelsPath: '/api/tags',
+    parseModels: (data) => {
+      // Ollama /api/tags returns { models: [{ name, size, details: { parameter_size, ... } }] }
+      if (!data || !data.models) return [];
+      return data.models.map(m => ({
+        id: m.name,
+        name: m.name,
+        size: m.size ? `${(m.size / (1024 * 1024 * 1024)).toFixed(1)}GB` : null,
+        parameterSize: m.details?.parameter_size || null,
+        family: m.details?.family || null,
+        quantization: m.details?.quantization_level || null,
+      }));
+    },
+  },
+  {
+    type: 'lmstudio',
+    baseUrl: 'http://localhost:1234',
+    modelsPath: '/v1/models',
+    parseModels: (data) => {
+      // LM Studio OpenAI-compatible: { data: [{ id, object, owned_by }] }
+      if (!data || !data.data) return [];
+      return data.data.map(m => ({
+        id: m.id,
+        name: m.id,
+        ownedBy: m.owned_by || null,
+      }));
+    },
+  },
+];
+
+/**
+ * Make a GET request with timeout (uses Node.js built-in http module)
+ */
+function httpGet(urlStr, timeoutMs) {
+  return new Promise((resolve) => {
+    try {
+      const url = new URL(urlStr);
+      const req = http.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: 'GET',
+        timeout: timeoutMs,
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try { resolve(JSON.parse(data)); } catch { resolve(null); }
+        });
+      });
+
+      req.on('error', () => resolve(null));
+      req.on('timeout', () => { req.destroy(); resolve(null); });
+      req.end();
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+/**
+ * Scan for all known local AI services.
+ * Returns array of discovered providers with their models.
+ * Non-blocking — services that are down are silently skipped.
+ *
+ * @returns {Promise<Array<{ type: string, baseUrl: string, models: Array }>>}
+ */
+async function scanAiProviders() {
+  const results = [];
+
+  // Scan all services in parallel
+  const scans = AI_SERVICES.map(async (service) => {
+    const url = `${service.baseUrl}${service.modelsPath}`;
+    const data = await httpGet(url, SCAN_TIMEOUT_MS);
+
+    if (!data) return null;
+
+    const models = service.parseModels(data);
+    if (models.length === 0) return null;
+
+    return {
+      type: service.type,
+      baseUrl: service.baseUrl,
+      models,
+    };
+  });
+
+  const scanResults = await Promise.all(scans);
+  for (const result of scanResults) {
+    if (result) results.push(result);
+  }
+
+  return results;
+}
+
+module.exports = { scanAiProviders, AI_SERVICES };