feat(new-compiler): add nebius support (#1900)

* feat: add support for @ai-sdk/openai v3.0.1

* Updated pnpm-lock.yaml to include @ai-sdk/openai version 3.0.1 with zod@4.1.12.
* Modified package.json in new-compiler to include @ai-sdk/openai as a dependency.
* Enhanced model-factory.ts to support OpenAI model creation with optional custom base URL.

* feat: add support for OpenAI-compatible providers (Nebius, etc.)

* feat: add support for Chat Completions API for OpenAI-compatible providers

* feat: enhance model-factory tests and parsing logic

* feat: update model-factory tests and fix error message in createAiModel function

Author: cherkanovart

.changeset/lovely-badgers-serve.md

@@ -0,0 +1,5 @@
+---
+"@lingo.dev/compiler": minor
+---
+
+Add support for OpenAI-compatible providers (Nebius, Together AI, etc.) by using Chat Completions API when OPENAI_BASE_URL is set

.changeset/nebius-openai-support.md

@@ -0,0 +1,6 @@
+---
+"@lingo.dev/compiler": minor
+"@lingo.dev/_compiler": minor
+---
+
+Add support for OpenAI-compatible providers (e.g., Nebius) via OPENAI_BASE_URL environment variable

packages/new-compiler/package.json

@@ -158,6 +158,7 @@
     "@ai-sdk/google": "3.0.1",
     "@ai-sdk/groq": "3.0.1",
     "@ai-sdk/mistral": "3.0.1",
+    "@ai-sdk/openai": "3.0.1",
     "@babel/core": "7.26.0",
     "@babel/generator": "7.28.5",
     "@babel/parser": "7.28.5",

packages/new-compiler/src/translators/lingo/model-factory.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
+import {
+  parseModelString,
+  getLocaleModel,
+  validateAndGetApiKeys,
+  createAiModel,
+  getKeyFromEnv,
+} from "./model-factory";
+
+vi.mock("dotenv", () => ({
+  config: vi.fn(() => ({ parsed: {} })),
+}));
+
+describe("model-factory", () => {
+  describe("parseModelString", () => {
+    it("should parse provider:model format correctly", () => {
+      const result = parseModelString("openai:gpt-4");
+      expect(result).toEqual({ provider: "openai", name: "gpt-4" });
+    });
+
+    it("should handle model names with colons", () => {
+      const result = parseModelString("openai:ft:gpt-4:my-org:custom:id");
+      expect(result).toEqual({
+        provider: "openai",
+        name: "ft:gpt-4:my-org:custom:id",
+      });
+    });
+
+    it("should handle simple model names with dashes", () => {
+      const result = parseModelString("groq:llama3-8b-8192");
+      expect(result).toEqual({ provider: "groq", name: "llama3-8b-8192" });
+    });
+
+    it("should return undefined for invalid format", () => {
+      expect(parseModelString("invalid")).toBeUndefined();
+      expect(parseModelString("")).toBeUndefined();
+    });
+  });
+
+  describe("getLocaleModel", () => {
+    it("should match exact locale pair", () => {
+      const config = {
+        "en:fr": "openai:gpt-4",
+        "*:*": "groq:llama3-8b-8192",
+      };
+
+      const result = getLocaleModel(config, "en", "fr");
+      expect(result).toEqual({ provider: "openai", name: "gpt-4" });
+    });
+
+    it("should fallback to *:targetLocale wildcard pattern", () => {
+      const config = {
+        "*:fr": "openai:gpt-3.5-turbo",
+        "*:*": "groq:llama3-8b-8192",
+      };
+
+      const result = getLocaleModel(config, "en", "fr");
+      expect(result).toEqual({ provider: "openai", name: "gpt-3.5-turbo" });
+    });
+
+    it("should fallback to sourceLocale:* wildcard pattern", () => {
+      const config = {
+        "en:*": "openai:gpt-4",
+        "*:*": "groq:llama3-8b-8192",
+      };
+
+      const result = getLocaleModel(config, "en", "de");
+      expect(result).toEqual({ provider: "openai", name: "gpt-4" });
+    });
+
+    it("should return undefined when no match found", () => {
+      const config = {
+        "en:fr": "openai:gpt-4",
+      };
+
+      const result = getLocaleModel(config, "de", "es");
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("validateAndGetApiKeys", () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it("should validate and return API keys for configured providers", () => {
+      process.env.OPENAI_API_KEY = "test-openai-key";
+      process.env.GROQ_API_KEY = "test-groq-key";
+
+      const config = {
+        "*:fr": "openai:gpt-4",
+        "*:es": "groq:llama3-8b-8192",
+      };
+
+      const result = validateAndGetApiKeys(config);
+      expect(result).toEqual({
+        openai: "test-openai-key",
+        groq: "test-groq-key",
+      });
+    });
+
+    it("should skip providers that don't require API keys (like Ollama)", () => {
+      const config = {
+        "*:*": "ollama:llama3",
+      };
+
+      // Should not throw even without OLLAMA_API_KEY
+      const result = validateAndGetApiKeys(config);
+      expect(result).toEqual({});
+    });
+
+    it("should throw error for missing required API keys", () => {
+      const config = {
+        "*:*": "openai:gpt-4",
+      };
+
+      expect(() => validateAndGetApiKeys(config)).toThrow();
+    });
+
+    it("should validate lingo.dev provider when specified", () => {
+      process.env.LINGODOTDEV_API_KEY = "test-lingo-key";
+
+      const result = validateAndGetApiKeys("lingo.dev");
+      expect(result).toEqual({
+        "lingo.dev": "test-lingo-key",
+      });
+    });
+
+    it("should throw error for unknown provider", () => {
+      const config = {
+        "*:*": "unknownprovider:model",
+      };
+
+      expect(() => validateAndGetApiKeys(config)).toThrow(
+        /Unknown provider "unknownprovider"/,
+      );
+    });
+  });
+
+  describe("createAiModel", () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it("should support OpenAI with custom baseURL from env", () => {
+      process.env.OPENAI_BASE_URL = "https://api.studio.nebius.ai/v1/";
+      process.env.OPENAI_API_KEY = "test-key";
+
+      const model = { provider: "openai", name: "gpt-4" };
+      const keys = { openai: "test-key" };
+
+      const result = createAiModel(model, keys);
+      expect(result).toBeDefined();
+    });
+
+    it("should create OpenAI model without baseURL when not set", () => {
+      delete process.env.OPENAI_BASE_URL;
+      process.env.OPENAI_API_KEY = "test-key";
+
+      const model = { provider: "openai", name: "gpt-4" };
+      const keys = { openai: "test-key" };
+
+      const result = createAiModel(model, keys);
+      expect(result).toBeDefined();
+    });
+
+    it("should create Groq model", () => {
+      const model = { provider: "groq", name: "llama3-8b-8192" };
+      const keys = { groq: "test-groq-key" };
+
+      const result = createAiModel(model, keys);
+      expect(result).toBeDefined();
+    });
+
+    it("should create Google model", () => {
+      const model = { provider: "google", name: "gemini-pro" };
+      const keys = { google: "test-google-key" };
+
+      const result = createAiModel(model, keys);
+      expect(result).toBeDefined();
+    });
+
+    it("should create OpenRouter model", () => {
+      const model = { provider: "openrouter", name: "anthropic/claude-3-opus" };
+      const keys = { openrouter: "test-openrouter-key" };
+
+      const result = createAiModel(model, keys);
+      expect(result).toBeDefined();
+    });
+
+    it("should create Ollama model without API key", () => {
+      const model = { provider: "ollama", name: "llama3" };
+      const keys = {};
+
+      const result = createAiModel(model, keys);
+      expect(result).toBeDefined();
+    });
+
+    it("should create Mistral model", () => {
+      const model = { provider: "mistral", name: "mistral-large-latest" };
+      const keys = { mistral: "test-mistral-key" };
+
+      const result = createAiModel(model, keys);
+      expect(result).toBeDefined();
+    });
+
+    it("should throw error for unsupported provider", () => {
+      const model = { provider: "unsupported", name: "model" };
+      const keys = {};
+
+      expect(() => createAiModel(model, keys)).toThrow(
+        /Provider "unsupported" is not supported/,
+      );
+    });
+  });
+
+  describe("getKeyFromEnv", () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it("should get key from process.env", () => {
+      process.env.TEST_KEY = "test-value";
+      expect(getKeyFromEnv("TEST_KEY")).toBe("test-value");
+    });
+
+    it("should return undefined for missing key", () => {
+      expect(getKeyFromEnv("NONEXISTENT_KEY")).toBeUndefined();
+    });
+  });
+});

packages/new-compiler/src/translators/lingo/model-factory.ts

@@ -7,6 +7,7 @@ import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 import { ollama } from "ai-sdk-ollama";
 import { createMistral } from "@ai-sdk/mistral";
+import { createOpenAI } from "@ai-sdk/openai";
 import type { LanguageModel } from "ai";
 import * as dotenv from "dotenv";
 import * as path from "path";
@@ -148,8 +149,14 @@ export function getLocaleModel(
  * @throws Error if format is invalid
  */
 export function parseModelString(modelString: string): LocaleModel | undefined {
-  // Split on first colon only
-  const [provider, name] = modelString.split(":", 2);
+  // Split on first colon only to allow colons in model names
+  const colonIndex = modelString.indexOf(":");
+  if (colonIndex === -1) {
+    return undefined;
+  }
+
+  const provider = modelString.substring(0, colonIndex);
+  const name = modelString.substring(colonIndex + 1);
 
   if (!provider || !name) {
     return undefined;
@@ -251,7 +258,7 @@ export function createAiModel(
   if (providerConfig.apiKeyEnvVar && !apiKey) {
     throw new Error(
       `⚠️  ${providerConfig.name} API key not found. Please set ${providerConfig.apiKeyEnvVar} environment variable.\n\n` +
-        `This should not happen if validateAndFetchApiKeys() was called. Please restart the service.`,
+      `This should not happen if validateAndGetApiKeys() was called. Please restart the service.`,
     );
   }
 
@@ -263,6 +270,18 @@ export function createAiModel(
     case "google":
       return createGoogleGenerativeAI({ apiKey: apiKey! })(model.name);
 
+    case "openai": {
+      // Support custom base URL for OpenAI-compatible providers (e.g., Nebius)
+      const baseURL = getKeyFromEnv("OPENAI_BASE_URL");
+
+      const provider = createOpenAI({
+        apiKey: apiKey!,
+        ...(baseURL && { baseURL }),
+      });
+
+      return provider.chat(model.name);
+    }
+
     case "openrouter":
       return createOpenRouter({ apiKey: apiKey! })(model.name);