feat(gateway): unified /v1 for local + cloud models; Open Code sees all; release 0.3.81

/v1/chat/completions now falls through to a cloud proxy when the model isn't
local: "provider/model" ids (e.g. ollamacloud/gpt-oss:120b) are forwarded —
messages, tools and streaming verbatim — to that provider's OpenAI-compatible
endpoint using the key stored in Vortelio. /v1/models lists local + cloud, and
the Open Code config now includes every configured cloud model under the one
"vortelio" provider, so ALL Vortelio models are usable in Open Code.

Also fix /v1/models (no trailing slash) which returned a bogus "model not
found" instead of the model list. Cloud model catalogue moved to the cloud
package (cloud.ModelChoices/ModelsWithKeys) so server and agent share it.

Verified end-to-end against ollamacloud: models listed and a proxied chat
returned a valid OpenAI completion.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: metiu1

vortelio-pip/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vortelio"
-version = "0.3.80"
+version = "0.3.81"
 description = "Local-first AI platform. Run LLMs, generate images & video, transcribe audio, create 3D — on your own machine. OpenAI & Ollama API compatible. Apache 2.0."
 readme = "README.md"
 requires-python = ">=3.8"

vortelio-pip/src/vortelio_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.80"
+__version__ = "0.3.81"

vortelio-pip/src/vortelio_cli/__main__.py

@@ -10,7 +10,7 @@
 import urllib.request
 from pathlib import Path
 
-VERSION = "0.3.80"
+VERSION = "0.3.81"
 RELEASE_BASE = os.environ.get(
     "VORTELIO_RELEASE_BASE",
     f"https://github.com/metiu1/Vortelio/releases/download/v{VERSION}",

vortelio-pip/src/vortelio_cli/bin/vortelio-windows-amd64.exe

@@ -16,6 +16,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/vortelio/vortelio/internal/cloud"
 	"github.com/vortelio/vortelio/internal/config"
 )
 
@@ -864,6 +865,21 @@ func writeOpenCodeConfig(path string) error {
 		}
 	}()
 
+	// Add every configured cloud model too — the unified /v1 gateway proxies
+	// "provider/model" ids to the right cloud provider, so Open Code can use
+	// ALL of Vortelio's models (local + cloud) under the one "vortelio" provider.
+	for _, cm := range cloud.ModelsWithKeys() {
+		id := cm.Provider + "/" + cm.Model
+		label := cm.Label
+		if label == "" {
+			label = id
+		}
+		models[id] = map[string]string{"name": cm.ProviderName + " · " + label}
+		if defaultModel == "" {
+			defaultModel = "vortelio/" + id
+		}
+	}
+
 	cfg := map[string]interface{}{
 		"$schema": "https://opencode.ai/config.json",
 		"provider": map[string]interface{}{

vortelio/internal/agent/agent.go

@@ -0,0 +1,104 @@
+package cloud
+
+// ModelChoices is the curated model list per provider (model id, display label).
+// Users can still send any model string via the API; this is just the picker.
+var ModelChoices = map[string][][2]string{
+	"openai": {
+		{"gpt-4o", "GPT-4o"},
+		{"gpt-4o-mini", "GPT-4o mini"},
+		{"o3-mini", "o3-mini"},
+		{"o1-mini", "o1-mini"},
+	},
+	"anthropic": {
+		{"claude-3-5-sonnet-20241022", "Claude 3.5 Sonnet"},
+		{"claude-3-5-haiku-20241022", "Claude 3.5 Haiku"},
+		{"claude-3-opus-20240229", "Claude 3 Opus"},
+	},
+	"gemini": {
+		{"gemini-2.0-flash", "Gemini 2.0 Flash"},
+		{"gemini-2.5-flash", "Gemini 2.5 Flash"},
+		{"gemini-2.5-pro", "Gemini 2.5 Pro"},
+	},
+	"groq": {
+		{"llama-3.3-70b-versatile", "Llama 3.3 70B"},
+		{"llama3-8b-8192", "Llama 3 8B"},
+	},
+	"mistral": {
+		{"mistral-small-latest", "Mistral Small"},
+		{"mistral-large-latest", "Mistral Large"},
+	},
+	"openrouter": {
+		{"meta-llama/llama-3.1-8b-instruct:free", "Llama 3.1 8B (free)"},
+		{"anthropic/claude-3.5-sonnet", "Claude 3.5 Sonnet"},
+		{"openai/gpt-4o", "GPT-4o"},
+		{"deepseek/deepseek-r1", "DeepSeek R1"},
+	},
+	"xai": {
+		{"grok-2-latest", "Grok 2"},
+		{"grok-2-vision-latest", "Grok 2 Vision"},
+		{"grok-beta", "Grok Beta"},
+	},
+	"together": {
+		{"meta-llama/Llama-3.3-70B-Instruct-Turbo", "Llama 3.3 70B Turbo"},
+		{"Qwen/Qwen2.5-72B-Instruct-Turbo", "Qwen2.5 72B Turbo"},
+		{"mistralai/Mixtral-8x7B-Instruct-v0.1", "Mixtral 8x7B"},
+	},
+	"deepseek": {
+		{"deepseek-chat", "DeepSeek V3 (chat)"},
+		{"deepseek-reasoner", "DeepSeek R1 (reasoner)"},
+	},
+	"perplexity": {
+		{"sonar", "Sonar"},
+		{"sonar-pro", "Sonar Pro"},
+		{"sonar-reasoning", "Sonar Reasoning"},
+	},
+	"ollamacloud": {
+		{"gpt-oss:120b", "gpt-oss 120B"},
+		{"deepseek-v3.1:671b", "DeepSeek V3.1 671B"},
+		{"qwen3-coder:480b", "Qwen3 Coder 480B"},
+		{"kimi-k2:1t", "Kimi K2 1T"},
+	},
+}
+
+// CloudModel is a ready-to-use cloud model (provider + model id + label).
+type CloudModel struct {
+	Provider     string
+	ProviderName string
+	Model        string
+	Label        string
+}
+
+// ModelsWithKeys returns the cloud models the user can actually use — every
+// provider that has at least one saved API key. Used by the unified /v1 gateway
+// and the Open Code config generator.
+func ModelsWithKeys() []CloudModel {
+	var out []CloudModel
+	for _, p := range Providers {
+		if LoadKey(p.ID) == "" {
+			continue
+		}
+		choices := ModelChoices[p.ID]
+		if len(choices) == 0 {
+			choices = [][2]string{{p.DefaultModel, p.DefaultModel}}
+		}
+		for _, c := range choices {
+			out = append(out, CloudModel{Provider: p.ID, ProviderName: p.Name, Model: c[0], Label: c[1]})
+		}
+	}
+	return out
+}
+
+// ChatCompletionsURL returns a provider's OpenAI-compatible /chat/completions
+// endpoint, suitable for a transparent proxy that forwards a full OpenAI request
+// (messages, tools, stream). Anthropic and Gemini expose dedicated
+// OpenAI-compatible endpoints; the rest already point there.
+func ChatCompletionsURL(p Provider) string {
+	switch p.ID {
+	case "anthropic":
+		return "https://api.anthropic.com/v1/chat/completions"
+	case "gemini":
+		return "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions"
+	default:
+		return p.BaseURL
+	}
+}

vortelio/internal/cloud/cloud_models.go

@@ -227,7 +227,7 @@ func NewMux() *http.ServeMux {
 	mux.HandleFunc("/api/blobs/", ca(handleOllamaBlobs))
 
 	// ── OpenAI-compatible API ─────────────────────────────────────────────────
-	mux.HandleFunc("/v1/models", ca(handleOpenAIModelByID))
+	mux.HandleFunc("/v1/models", ca(handleOpenAIModels))
 	mux.HandleFunc("/v1/models/", ca(handleOpenAIModelByID))
 	mux.HandleFunc("/v1/chat/completions", ca(withRateLimit(generateLimiter, handleOpenAIChatCompletions)))
 	mux.HandleFunc("/v1/completions", ca(withRateLimit(generateLimiter, handleOpenAICompletions)))

vortelio/internal/server/server.go

@@ -17,65 +17,9 @@ import (
 // cloud package; requests are made directly to the provider with the user's key
 // and streamed back as a uniform SSE stream of {"delta": "..."} events.
 
-// cloudModelChoices is the curated model list shown in the picker per provider.
-// Users can still send any model string via the API; this is just for the UI.
-var cloudModelChoices = map[string][][2]string{
-	"openai": {
-		{"gpt-4o", "GPT-4o"},
-		{"gpt-4o-mini", "GPT-4o mini"},
-		{"o3-mini", "o3-mini"},
-		{"o1-mini", "o1-mini"},
-	},
-	"anthropic": {
-		{"claude-3-5-sonnet-20241022", "Claude 3.5 Sonnet"},
-		{"claude-3-5-haiku-20241022", "Claude 3.5 Haiku"},
-		{"claude-3-opus-20240229", "Claude 3 Opus"},
-	},
-	"gemini": {
-		{"gemini-2.0-flash", "Gemini 2.0 Flash"},
-		{"gemini-2.5-flash", "Gemini 2.5 Flash"},
-		{"gemini-2.5-pro", "Gemini 2.5 Pro"},
-	},
-	"groq": {
-		{"llama-3.3-70b-versatile", "Llama 3.3 70B"},
-		{"llama3-8b-8192", "Llama 3 8B"},
-	},
-	"mistral": {
-		{"mistral-small-latest", "Mistral Small"},
-		{"mistral-large-latest", "Mistral Large"},
-	},
-	"openrouter": {
-		{"meta-llama/llama-3.1-8b-instruct:free", "Llama 3.1 8B (free)"},
-		{"anthropic/claude-3.5-sonnet", "Claude 3.5 Sonnet"},
-		{"openai/gpt-4o", "GPT-4o"},
-		{"deepseek/deepseek-r1", "DeepSeek R1"},
-	},
-	"xai": {
-		{"grok-2-latest", "Grok 2"},
-		{"grok-2-vision-latest", "Grok 2 Vision"},
-		{"grok-beta", "Grok Beta"},
-	},
-	"together": {
-		{"meta-llama/Llama-3.3-70B-Instruct-Turbo", "Llama 3.3 70B Turbo"},
-		{"Qwen/Qwen2.5-72B-Instruct-Turbo", "Qwen2.5 72B Turbo"},
-		{"mistralai/Mixtral-8x7B-Instruct-v0.1", "Mixtral 8x7B"},
-	},
-	"deepseek": {
-		{"deepseek-chat", "DeepSeek V3 (chat)"},
-		{"deepseek-reasoner", "DeepSeek R1 (reasoner)"},
-	},
-	"perplexity": {
-		{"sonar", "Sonar"},
-		{"sonar-pro", "Sonar Pro"},
-		{"sonar-reasoning", "Sonar Reasoning"},
-	},
-	"ollamacloud": {
-		{"gpt-oss:120b", "gpt-oss 120B"},
-		{"deepseek-v3.1:671b", "DeepSeek V3.1 671B"},
-		{"qwen3-coder:480b", "Qwen3 Coder 480B"},
-		{"kimi-k2:1t", "Kimi K2 1T"},
-	},
-}
+// The curated per-provider model list lives in the cloud package as
+// cloud.ModelChoices so the unified /v1 gateway and the Open Code config
+// generator can share it.
 
 // GET /api/cloud/providers
 // Lists providers, whether a key is stored, and the model choices.
@@ -95,7 +39,7 @@ func CloudModelsForCLI() []CLICloudModel {
 		if cloud.LoadKey(p.ID) == "" {
 			continue
 		}
-		choices := cloudModelChoices[p.ID]
+		choices := cloud.ModelChoices[p.ID]
 		if len(choices) == 0 {
 			choices = [][2]string{{p.DefaultModel, p.DefaultModel}}
 		}
@@ -230,7 +174,7 @@ func handleCloudProviders(w http.ResponseWriter, r *http.Request) {
 	out := make([]providerOut, 0, len(cloud.Providers))
 	for _, p := range cloud.Providers {
 		models := []modelOut{}
-		if choices, ok := cloudModelChoices[p.ID]; ok {
+		if choices, ok := cloud.ModelChoices[p.ID]; ok {
 			for _, c := range choices {
 				models = append(models, modelOut{ID: c[0], Label: c[1]})
 			}

vortelio/internal/server/server_cloud.go

@@ -0,0 +1,85 @@
+package server
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/vortelio/vortelio/internal/cloud"
+)
+
+// proxyCloudChatCompletion turns /v1/chat/completions into a unified gateway:
+// when the requested model isn't a local one, it's treated as "provider/model"
+// (e.g. "anthropic/claude-3-5-haiku-20241022") and forwarded — verbatim, tools
+// and streaming included — to that cloud provider's OpenAI-compatible endpoint
+// using the API key stored in Vortelio. Returns true if it handled the request.
+func proxyCloudChatCompletion(w http.ResponseWriter, modelID string, rawBody []byte) bool {
+	slash := strings.Index(modelID, "/")
+	if slash <= 0 || slash >= len(modelID)-1 {
+		return false // not a "provider/model" id
+	}
+	provID := modelID[:slash]
+	realModel := modelID[slash+1:]
+
+	p, ok := cloud.FindProvider(provID)
+	if !ok {
+		return false // unknown provider — let the caller 404
+	}
+	keys := cloud.LoadKeys(provID)
+	if len(keys) == 0 {
+		jsonError(w, 402, "no API key configured for cloud provider "+provID+" — add one in Vortelio (Cloud Models)")
+		return true
+	}
+
+	// Rewrite only the model field; keep messages, tools, stream, etc. intact.
+	var body map[string]interface{}
+	if err := json.Unmarshal(rawBody, &body); err != nil {
+		jsonError(w, 400, "invalid JSON: "+err.Error())
+		return true
+	}
+	body["model"] = realModel
+	outBody, _ := json.Marshal(body)
+
+	preq, err := http.NewRequest(http.MethodPost, cloud.ChatCompletionsURL(p), bytes.NewReader(outBody))
+	if err != nil {
+		jsonError(w, 500, err.Error())
+		return true
+	}
+	preq.Header.Set("Content-Type", "application/json")
+	preq.Header.Set("Authorization", "Bearer "+keys[0])
+	// Anthropic's OpenAI-compatible endpoint still wants an API version header.
+	if p.ID == "anthropic" {
+		preq.Header.Set("anthropic-version", "2023-06-01")
+	}
+
+	resp, err := http.DefaultClient.Do(preq)
+	if err != nil {
+		jsonError(w, 502, "cloud request failed: "+err.Error())
+		return true
+	}
+	defer resp.Body.Close()
+
+	// Relay status, content-type and the (possibly streamed) body verbatim.
+	if ct := resp.Header.Get("Content-Type"); ct != "" {
+		w.Header().Set("Content-Type", ct)
+	}
+	w.Header().Set("Cache-Control", "no-cache")
+	w.WriteHeader(resp.StatusCode)
+
+	flusher, _ := w.(http.Flusher)
+	buf := make([]byte, 8192)
+	for {
+		n, rerr := resp.Body.Read(buf)
+		if n > 0 {
+			w.Write(buf[:n])
+			if flusher != nil {
+				flusher.Flush()
+			}
+		}
+		if rerr != nil {
+			break
+		}
+	}
+	return true
+}

vortelio/internal/server/server_cloud_proxy.go

@@ -3,10 +3,12 @@ package server
 import (
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"strings"
 	"time"
 
+	"github.com/vortelio/vortelio/internal/cloud"
 	"github.com/vortelio/vortelio/internal/hub"
 	"github.com/vortelio/vortelio/internal/runtime"
 )
@@ -76,6 +78,16 @@ func handleOpenAIModels(w http.ResponseWriter, r *http.Request) {
 			OwnedBy: "vortelio",
 		})
 	}
+	// Also advertise configured cloud models (provider/model), so the /v1
+	// endpoint is a unified catalogue of everything usable in Vortelio.
+	for _, cm := range cloud.ModelsWithKeys() {
+		data = append(data, oaiModel{
+			ID:      cm.Provider + "/" + cm.Model,
+			Object:  "model",
+			Created: time.Now().Unix(),
+			OwnedBy: cm.Provider,
+		})
+	}
 	if data == nil {
 		data = []oaiModel{}
 	}
@@ -117,8 +129,13 @@ func handleOpenAIChatCompletions(w http.ResponseWriter, r *http.Request) {
 		jsonError(w, 405, "POST only")
 		return
 	}
+	rawBody, err := io.ReadAll(r.Body)
+	if err != nil {
+		jsonError(w, 400, "could not read body: "+err.Error())
+		return
+	}
 	var req openAIChatRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+	if err := json.Unmarshal(rawBody, &req); err != nil {
 		jsonError(w, 400, "invalid JSON: "+err.Error())
 		return
 	}
@@ -129,6 +146,11 @@ func handleOpenAIChatCompletions(w http.ResponseWriter, r *http.Request) {
 
 	model, err := resolveModel(req.Model)
 	if err != nil {
+		// Not a local model — try routing it to a configured cloud provider so
+		// /v1 is a unified gateway (local + cloud). Model ids are "provider/model".
+		if proxyCloudChatCompletion(w, req.Model, rawBody) {
+			return
+		}
 		jsonError(w, 404, err.Error())
 		return
 	}