free-antigravity-cli 1.0.0

package/src/cli.ts

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+/**
+ * Free Antigravity CLI - Open Source Community Edition
+ * Supports custom AI models alongside Gemini.
+ */
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs';
+import { loadModels, addModel, removeModel, listModels, getModel, ensureConfigDir, CustomModelEntry } from './config';
+import { startProxy, getProxyPort, loadCustomModels, stopProxy } from './proxy';
+import { startChat } from './chat';
+
+const program = new Command();
+
+program
+  .name('antigravity')
+  .description('Free Antigravity CLI - Open Source Community Edition\nSupports OpenAI, Anthropic, Ollama, OpenRouter, Google AI Studio, and custom providers.')
+  .version('1.0.0');
+
+// --- Chat command ---
+
+program
+  .command('chat')
+  .description('Start interactive chat (default command)')
+  .argument('[prompt]', 'One-shot prompt (non-interactive)')
+  .option('-m, --model <name>', 'Model to use')
+  .action(async (prompt?: string, options?: { model?: string }) => {
+    if (prompt) {
+      // One-shot mode
+      console.log(`Sending to ${options?.model || 'default model'}...`);
+      await startChat(options?.model);
+      // In a full implementation, would send the prompt and exit
+      console.log('One-shot mode: Use interactive chat for now.');
+    } else {
+      await startChat(options?.model);
+    }
+  });
+
+// --- Models command ---
+
+const modelsCmd = program.command('models').description('Manage custom AI models');
+
+modelsCmd
+  .command('list')
+  .description('List all configured models')
+  .action(() => {
+    const models = listModels();
+    if (models.length === 0) {
+      console.log('No models configured. Use "antigravity models add" to add one.');
+      return;
+    }
+    console.log('\nConfigured Models:');
+    console.log('─'.repeat(60));
+    for (const m of models) {
+      const keyStatus = m.apiKey && m.apiKey !== 'none' ? '🔑' : '🔓';
+      console.log(`  ${keyStatus} ${m.displayName || m.name}`);
+      console.log(`     Provider: ${m.provider}  |  Model: ${m.externalModelName}`);
+      console.log(`     URL: ${m.apiUrl}`);
+      console.log();
+    }
+    console.log(`${models.length} model(s) configured.`);
+  });
+
+modelsCmd
+  .command('add')
+  .description('Add a new custom model (interactive wizard)')
+  .action(async () => {
+    const inquirer = require('inquirer');
+
+    console.log('\n  Add Custom AI Model\n' + '─'.repeat(40));
+
+    const answers = await inquirer.prompt([
+      { type: 'list', name: 'provider', message: 'Provider:', choices: ['openai', 'anthropic', 'google', 'ollama', 'openrouter', 'custom'] },
+      { type: 'input', name: 'modelId', message: 'Model ID (e.g. gpt-4o):', validate: (v: string) => v.length > 0 },
+      { type: 'input', name: 'displayName', message: 'Display name (optional):' },
+      { type: 'password', name: 'apiKey', message: 'API Key:', mask: '*' },
+      { type: 'input', name: 'apiUrl', message: 'API URL:', default: (ans: any) => {
+        const defaults: Record<string, string> = { openai: 'https://api.openai.com/v1/chat/completions', anthropic: 'https://api.anthropic.com/v1/messages', ollama: 'http://localhost:11434/v1/chat/completions', openrouter: 'https://openrouter.ai/api/v1/chat/completions', custom: 'https://api.together.xyz/v1' };
+        return ans.provider === 'google' ? `https://generativelanguage.googleapis.com/v1beta/models/${ans.modelId}:generateContent` : (defaults[ans.provider] || '');
+      }},
+    ]);
+
+    const entry: CustomModelEntry = {
+      name: 'models/' + answers.modelId,
+      displayName: answers.displayName || answers.modelId,
+      description: `${answers.displayName || answers.modelId} custom model via Free Antigravity CLI`,
+      provider: answers.provider,
+      apiKey: answers.apiKey || 'none',
+      apiUrl: answers.apiUrl,
+      externalModelName: answers.modelId,
+    };
+
+    const result = addModel(entry);
+    if (result.success) {
+      console.log(`\n  Model "${entry.displayName}" added successfully!`);
+      console.log('  Restart the proxy or chat to use it.\n');
+    } else {
+      console.error(`\n  Failed: ${result.error}\n`);
+    }
+  });
+
+modelsCmd
+  .command('remove')
+  .description('Remove a model')
+  .argument('<name>', 'Model name or display name')
+  .action((name: string) => {
+    const result = removeModel(name);
+    if (result.success) console.log(`Model "${name}" removed.`);
+    else console.error(`Failed: ${result.error}`);
+  });
+
+modelsCmd
+  .command('import')
+  .description('Import models from Antigravity desktop custom_models.json')
+  .action(() => {
+    const desktopPath = path.join(require('os').homedir(), '.gemini', 'antigravity', 'custom_models.json');
+    if (!fs.existsSync(desktopPath)) {
+      console.log('Desktop custom_models.json not found at:', desktopPath);
+      return;
+    }
+    try {
+      const content = fs.readFileSync(desktopPath, 'utf-8');
+      const parsed = JSON.parse(content);
+      const models = parsed.models || [];
+      if (models.length === 0) { console.log('No models in desktop config.'); return; }
+
+      ensureConfigDir();
+      // Decrypt desktop keys using the crypto module
+      const { decryptString } = require('./crypto');
+      const imported: CustomModelEntry[] = [];
+      for (const m of models) {
+        let apiKey = m.apiKey || 'none';
+        if (m.encrypted && apiKey !== 'none') {
+          try { apiKey = decryptString(apiKey); } catch { /* keep as-is */ }
+        }
+        imported.push({
+          name: m.name, displayName: m.displayName, description: m.description,
+          provider: m.provider, apiKey, apiUrl: m.apiUrl,
+          externalModelName: m.externalModelName, allowUnauthorized: m.allowUnauthorized,
+        });
+      }
+      // Save all
+      const { saveModels } = require('./config');
+      saveModels(imported);
+      console.log(`Imported ${imported.length} model(s) from desktop Antigravity.`);
+      for (const m of imported) console.log(`  - ${m.displayName} (${m.provider})`);
+    } catch (e) { console.error('Import failed:', e); }
+  });
+
+// --- Proxy command ---
+
+program
+  .command('proxy')
+  .description('Start the proxy server (for IDE integration)')
+  .action(async () => {
+    try {
+      const port = await startProxy();
+      console.log(`Proxy running on http://127.0.0.1:${port}`);
+      console.log('Press Ctrl+C to stop.');
+      // Keep alive
+      process.on('SIGINT', async () => { await stopProxy(); process.exit(0); });
+    } catch (e) { console.error('Failed to start proxy:', e); }
+  });
+
+// --- Configure command ---
+
+program
+  .command('configure')
+  .description('Show configuration info')
+  .action(() => {
+    const configPath = (require('./config') as typeof import('./config')).getModelsPath();
+    console.log('Free Antigravity CLI Configuration');
+    console.log('─'.repeat(40));
+    console.log(`Models file: ${configPath}`);
+    console.log(`Models: ${listModels().length} configured`);
+    console.log(`Proxy port: ${getProxyPort() || 'not running'}`);
+  });
+
+// Default: chat if no command
+program.action(() => {
+  startChat();
+});
+
+program.parse(process.argv);

package/src/config.ts

@@ -0,0 +1,99 @@
+/**
+ * Configuration and model storage management.
+ * Stores custom models in ~/.free-antigravity/models.json
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { encryptString, decryptString } from './crypto';
+
+export interface CustomModelEntry {
+  name: string;
+  displayName?: string;
+  description?: string;
+  provider: string;
+  apiKey: string;
+  apiUrl: string;
+  externalModelName: string;
+  allowUnauthorized?: boolean;
+  encrypted?: boolean;
+  timeout?: number;
+  maxRetries?: number;
+}
+
+export function getConfigDir(): string {
+  return path.join(os.homedir(), '.free-antigravity');
+}
+
+export function getModelsPath(): string {
+  return path.join(getConfigDir(), 'models.json');
+}
+
+export function ensureConfigDir(): void {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+export function loadModels(): CustomModelEntry[] {
+  const filePath = getModelsPath();
+  if (!fs.existsSync(filePath)) return [];
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(content) as { models?: CustomModelEntry[] };
+    const models = parsed.models || [];
+
+    return models.map((m) => {
+      if (m.encrypted && m.apiKey && m.apiKey !== 'none') {
+        try { return { ...m, apiKey: decryptString(m.apiKey), encrypted: false }; }
+        catch { return m; }
+      }
+      return m;
+    });
+  } catch (e) {
+    console.error('Failed to load models:', e);
+    return [];
+  }
+}
+
+export function saveModels(models: CustomModelEntry[]): void {
+  ensureConfigDir();
+  const encrypted = models.map((m) => {
+    if (m.apiKey && m.apiKey !== 'none' && !m.encrypted) {
+      return { ...m, apiKey: encryptString(m.apiKey), encrypted: true };
+    }
+    return m;
+  });
+  fs.writeFileSync(getModelsPath(), JSON.stringify({ models: encrypted }, null, 2), 'utf-8');
+}
+
+export function addModel(model: CustomModelEntry): { success: boolean; error?: string } {
+  const models = loadModels();
+  const existingIdx = models.findIndex((m) => m.name === model.name);
+
+  if (existingIdx !== -1) {
+    if (model.apiKey && (model.apiKey.includes('...') || model.apiKey.startsWith('***'))) {
+      model.apiKey = models[existingIdx].apiKey;
+    }
+    models[existingIdx] = model;
+  } else {
+    models.push(model);
+  }
+
+  saveModels(models);
+  return { success: true };
+}
+
+export function removeModel(modelName: string): { success: boolean; error?: string } {
+  const models = loadModels().filter((m) => m.name !== modelName);
+  saveModels(models);
+  return { success: true };
+}
+
+export function getModel(modelName: string): CustomModelEntry | undefined {
+  return loadModels().find((m) => m.name === modelName || m.displayName === modelName);
+}
+
+export function listModels(): CustomModelEntry[] {
+  return loadModels();
+}

package/src/crypto.ts

@@ -0,0 +1,49 @@
+/**
+ * API key encryption for CLI.
+ * Uses base64 encoding as a basic obfuscation layer.
+ * For production use, consider integrating with OS keychain via keytar.
+ */
+import * as crypto from 'crypto';
+
+const ALGORITHM = 'aes-256-cbc';
+// Derive a machine-specific key - in production, use keytar or OS keychain
+const MACHINE_KEY = crypto.createHash('sha256').update(process.env.USERNAME || process.env.USER || 'antigravity-cli').digest();
+
+export function encryptString(plainText: string): string {
+  if (!plainText || plainText === 'none') return plainText;
+  try {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(ALGORITHM, MACHINE_KEY, iv);
+    const encrypted = Buffer.concat([cipher.update(plainText, 'utf-8'), cipher.final()]);
+    return 'enc:' + Buffer.concat([iv, encrypted]).toString('base64');
+  } catch {
+    return 'fallback:' + Buffer.from(plainText, 'utf-8').toString('base64');
+  }
+}
+
+export function decryptString(encryptedText: string): string {
+  if (!encryptedText || encryptedText === 'none') return encryptedText;
+
+  if (encryptedText.startsWith('enc:')) {
+    try {
+      const data = Buffer.from(encryptedText.substring(4), 'base64');
+      const iv = data.subarray(0, 16);
+      const encrypted = data.subarray(16);
+      const decipher = crypto.createDecipheriv(ALGORITHM, MACHINE_KEY, iv);
+      return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf-8');
+    } catch { return 'DECRYPTION_FAILED'; }
+  }
+
+  if (encryptedText.startsWith('fallback:')) {
+    try { return Buffer.from(encryptedText.substring(9), 'base64').toString('utf-8'); }
+    catch { return 'DECRYPTION_FAILED'; }
+  }
+
+  return encryptedText; // plaintext
+}
+
+export function isEncryptionAvailable(): boolean { return true; }
+export function backupFile(filePath: string): void {
+  const fs = require('fs');
+  if (fs.existsSync(filePath)) fs.copyFileSync(filePath, filePath + '.bak');
+}

package/src/logger.ts

@@ -0,0 +1,8 @@
+type LogFn = (message: string, ...args: unknown[]) => void;
+
+export const log = {
+  info: console.log as LogFn,
+  warn: console.warn as LogFn,
+  error: console.error as LogFn,
+  debug: console.debug as LogFn,
+};

package/src/proxy/modelUtils.ts

@@ -0,0 +1,86 @@
+/**
+ * Centralized model capability detection.
+ * Replaces ~9 duplicate regex blocks across proxy.js.
+ */
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+export interface CustomModelConfig {
+  name: string;
+  provider: string;
+  externalModelName?: string;
+  displayName?: string;
+}
+
+export interface ModelCapabilities {
+  isThinking: boolean;
+  isDeepSeek: boolean;
+  isClaude: boolean;
+  maxTokens: number;
+  maxOutputTokens: number;
+  supportsImages: boolean;
+}
+
+export interface ModelNameCapabilities {
+  isClaudeThinkingModel: boolean;
+  isThinkingModel: boolean;
+}
+
+// ─── Detection ────────────────────────────────────────────────────────────
+
+const THINKING_PATTERN = /thinking|reasoning|reasoner|o1|o3|r1|opus-4|sonnet-4|claude-4|3-7|4-7|3\.7|4\.7/i;
+const DEEPSEEK_PATTERN = /deepseek/i;
+const CLAUDE_PATTERN = /claude|opus|sonnet/i;
+const CLAUDE_THINKING_PATTERN = /opus-4|sonnet-4|claude-4|claude-3-5|claude-3-7/i;
+const THINKING_MODEL_PATTERN = /opus-4|sonnet-4|claude-4/i;
+const IMAGE_SUPPORT_PATTERN = /gpt-4o|gpt-4-turbo|claude|gemini|vision|llava|qwenvl|pixtral|yi-vision|cogvlm|kimi|moonshot/i;
+const NO_IMAGE_PATTERN = /deepseek(?!.*vision)|llama(?!.*vision)|mixtral(?!.*vision)|mistral(?!.*pixtral)|codestral|qwen(?!.*vl)/i;
+
+/**
+ * Detects model capabilities from a custom model config object.
+ */
+export function detectModelCapabilities(m: CustomModelConfig, includeDisplayName = true): ModelCapabilities {
+  const nameLower = (m.name || '').toLowerCase();
+  const extLower = (m.externalModelName || '').toLowerCase();
+  const displayLower = includeDisplayName ? (m.displayName || '').toLowerCase() : '';
+
+  const isThinking =
+    m.provider === 'anthropic' ||
+    m.provider === 'openai' ||
+    m.provider === 'openrouter' ||
+    THINKING_PATTERN.test(nameLower) ||
+    THINKING_PATTERN.test(extLower) ||
+    (includeDisplayName && THINKING_PATTERN.test(displayLower));
+
+  const isDeepSeek =
+    DEEPSEEK_PATTERN.test(nameLower) ||
+    DEEPSEEK_PATTERN.test(extLower) ||
+    (includeDisplayName && DEEPSEEK_PATTERN.test(displayLower));
+
+  const isClaude = m.provider === 'anthropic' || CLAUDE_PATTERN.test(nameLower) || CLAUDE_PATTERN.test(extLower);
+
+  const maxTokens = isClaude ? 200_000 : 1_048_576;
+  const maxOutputTokens = isDeepSeek ? 32_768 : isThinking ? 32_768 : 16_384;
+
+  // Image support: Claude, GPT-4o, Gemini always support images. DeepSeek, Ollama text models don't.
+  const allNames = nameLower + ' ' + extLower + ' ' + displayLower;
+  const supportsImages =
+    m.provider === 'anthropic' ||
+    m.provider === 'google' ||
+    (m.provider === 'openai' && IMAGE_SUPPORT_PATTERN.test(allNames)) ||
+    (m.provider === 'openrouter' && IMAGE_SUPPORT_PATTERN.test(allNames)) ||
+    (IMAGE_SUPPORT_PATTERN.test(allNames) && !NO_IMAGE_PATTERN.test(allNames));
+
+  return { isThinking, isDeepSeek, isClaude, maxTokens, maxOutputTokens, supportsImages };
+}
+
+/**
+ * Simplified detection for Gemini↔Anthropic translation (checks modelName string only).
+ */
+export function detectModelCapabilitiesByName(modelName: string): ModelNameCapabilities {
+  const lower = (modelName || '').toLowerCase();
+  return {
+    isClaudeThinkingModel: CLAUDE_THINKING_PATTERN.test(lower),
+    isThinkingModel: THINKING_MODEL_PATTERN.test(lower),
+  };
+}

package/src/proxy/registry.ts

@@ -0,0 +1,196 @@
+/**
+ * Provider Translator Registry.
+ * Auto-discovers translator modules and provides a unified interface for request/response mapping.
+ *
+ * To add a new provider:
+ *   1. Create a file in ./translators/ named <provider>.ts
+ *   2. Export: mapGeminiTo<Provider>, map<Provider>ToGemini, map<Provider>ChunkToGemini
+ *   3. The registry detects it automatically — no config changes needed.
+ */
+
+import { log } from '../logger';
+import * as openaiModule from './translators/openai';
+import * as anthropicModule from './translators/anthropic';
+import * as googleModule from './translators/google';
+import * as ollamaModule from './translators/ollama';
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+export interface TranslatorModule {
+  mapGeminiToOpenAI?: (body: unknown, modelName: string) => unknown;
+  mapOpenAIToGemini?: (res: unknown, modelName: string) => unknown;
+  mapOpenAIChunkToGemini?: (chunk: unknown, modelName: string) => unknown | null;
+  mapGeminiToAnthropic?: (body: unknown, modelName: string) => unknown;
+  mapAnthropicToGemini?: (res: unknown, modelName: string) => unknown;
+  mapAnthropicChunkToGemini?: (chunk: unknown, modelName: string) => unknown | null;
+  mapGeminiToGoogle?: (body: unknown, modelName: string) => unknown;
+  mapGoogleToGemini?: (res: unknown, modelName: string) => unknown;
+  mapGoogleChunkToGemini?: (chunk: unknown, modelName: string) => unknown | null;
+  getGoogleApiUrl?: (baseUrl: string, modelName: string, isStream: boolean) => string;
+  [key: string]: unknown;
+}
+
+export interface ProviderHeaders {
+  'Content-Type': string;
+  Authorization?: string;
+  'x-api-key'?: string;
+  'anthropic-version'?: string;
+  'x-goog-api-key'?: string;
+  'HTTP-Referer'?: string;
+  'X-Title'?: string;
+  [key: string]: string | undefined;
+}
+
+// ─── Registry State ───────────────────────────────────────────────────────
+
+const translators = new Map<string, TranslatorModule>();
+
+// ─── Auto-Discovery ───────────────────────────────────────────────────────
+
+function loadTranslators(): void {
+  translators.set('openai', openaiModule as unknown as TranslatorModule);
+  translators.set('anthropic', anthropicModule as unknown as TranslatorModule);
+  translators.set('google', googleModule as unknown as TranslatorModule);
+  translators.set('ollama', ollamaModule as unknown as TranslatorModule);
+  log.info(`[TranslatorRegistry] 4 provider translator(s) loaded: openai, anthropic, google, ollama`);
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────
+
+export function getTranslator(provider: string): TranslatorModule | null {
+  // openrouter uses OpenAI-compatible API — reuse OpenAI translator
+  if (provider === 'openrouter') return translators.get('openai') || null;
+  const key = provider === 'custom' ? 'openai' : provider;
+  return translators.get(key) || translators.get('openai') || null;
+}
+
+export function translateRequest(provider: string, geminiBody: unknown, modelName: string): unknown {
+  const t = getTranslator(provider);
+
+  if (provider === 'google') {
+    return geminiBody; // passthrough
+  }
+
+  if (provider === 'openai' || provider === 'ollama' || provider === 'custom' || provider === 'openrouter') {
+    return t?.mapGeminiToOpenAI ? t.mapGeminiToOpenAI(geminiBody, modelName) : geminiBody;
+  }
+
+  if (provider === 'anthropic') {
+    return t?.mapGeminiToAnthropic ? t.mapGeminiToAnthropic(geminiBody, modelName) : geminiBody;
+  }
+
+  // Generic: try mapGeminiTo<Provider> convention
+  const fnName = `mapGeminiTo${provider.charAt(0).toUpperCase() + provider.slice(1)}`;
+  if (t && typeof t[fnName] === 'function') {
+    return (t[fnName] as (...args: unknown[]) => unknown)(geminiBody, modelName);
+  }
+
+  log.warn(`[TranslatorRegistry] No request translator for provider "${provider}", passing through`);
+  return geminiBody;
+}
+
+export function translateResponse(provider: string, providerRes: unknown, modelName: string): unknown {
+  const t = getTranslator(provider);
+
+  if (provider === 'google') return providerRes;
+
+  if (provider === 'openai' || provider === 'ollama' || provider === 'custom' || provider === 'openrouter') {
+    return t?.mapOpenAIToGemini ? t.mapOpenAIToGemini(providerRes, modelName) : providerRes;
+  }
+
+  if (provider === 'anthropic') {
+    return t?.mapAnthropicToGemini ? t.mapAnthropicToGemini(providerRes, modelName) : providerRes;
+  }
+
+  const fnName = `map${provider.charAt(0).toUpperCase() + provider.slice(1)}ToGemini`;
+  if (t && typeof t[fnName] === 'function') {
+    return (t[fnName] as (...args: unknown[]) => unknown)(providerRes, modelName);
+  }
+
+  log.warn(`[TranslatorRegistry] No response translator for provider "${provider}", passing through`);
+  return providerRes;
+}
+
+export function translateStreamChunk(provider: string, chunk: unknown, modelName: string): unknown {
+  const t = getTranslator(provider);
+
+  if (provider === 'google') {
+    return t?.mapGoogleChunkToGemini ? t.mapGoogleChunkToGemini(chunk, modelName) : null;
+  }
+
+  if (provider === 'openai' || provider === 'ollama' || provider === 'custom' || provider === 'openrouter') {
+    return t?.mapOpenAIChunkToGemini ? t.mapOpenAIChunkToGemini(chunk, modelName) : null;
+  }
+
+  if (provider === 'anthropic') {
+    return t?.mapAnthropicChunkToGemini ? t.mapAnthropicChunkToGemini(chunk, modelName) : null;
+  }
+
+  const fnName = `map${provider.charAt(0).toUpperCase() + provider.slice(1)}ChunkToGemini`;
+  if (t && typeof t[fnName] === 'function') {
+    return (t[fnName] as (...args: unknown[]) => unknown)(chunk, modelName);
+  }
+
+  return null;
+}
+
+export function getProviderHeaders(provider: string, apiKey: string): ProviderHeaders {
+  const headers: ProviderHeaders = { 'Content-Type': 'application/json' };
+
+  switch (provider) {
+    case 'openai':
+    case 'custom':
+      headers['Authorization'] = `Bearer ${apiKey}`;
+      break;
+    case 'openrouter':
+      headers['Authorization'] = `Bearer ${apiKey}`;
+      // OpenRouter optional headers for leaderboard attribution
+      headers['HTTP-Referer'] = 'https://antigravity.google';
+      headers['X-Title'] = 'Antigravity';
+      break;
+    case 'anthropic':
+      headers['x-api-key'] = apiKey;
+      headers['anthropic-version'] = '2025-04-01';
+      break;
+    case 'google':
+      headers['x-goog-api-key'] = apiKey;
+      break;
+    case 'ollama':
+      // Ollama typically doesn't need auth headers
+      break;
+    default:
+      if (apiKey && apiKey !== 'none') {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+      }
+      break;
+  }
+
+  return headers;
+}
+
+export function supportsStreaming(provider: string): boolean {
+  return ['openai', 'ollama', 'custom', 'anthropic', 'google', 'openrouter'].includes(provider);
+}
+
+// ─── URL Helpers ──────────────────────────────────────────────────────────
+
+export function getProviderUrl(
+  baseUrl: string,
+  modelName: string,
+  isStream: boolean,
+  translator: TranslatorModule | null,
+): string {
+  // Google AI Studio: dynamic streaming vs non-streaming URL
+  if (translator && typeof translator['getGoogleApiUrl'] === 'function') {
+    return (translator['getGoogleApiUrl'] as (...args: unknown[]) => string)(baseUrl, modelName, isStream);
+  }
+  // Ollama: normalize to standard /v1/chat/completions endpoint
+  if (translator && typeof translator['getOllamaApiUrl'] === 'function') {
+    return (translator['getOllamaApiUrl'] as (...args: unknown[]) => string)(baseUrl);
+  }
+  return baseUrl;
+}
+
+// ─── Boot ─────────────────────────────────────────────────────────────────
+
+loadTranslators();