feat: add DeepSeek, Moonshot, xAI, Groq, Ollama; drop v1; migrate TUI to v2

Five OpenAI-compatible providers join the library as first-class constructors
(llm.DeepSeek, llm.Moonshot, llm.XAI, llm.Groq, llm.Ollama). Their wire-level
implementation is shared via a new v2/openaicompat package which is the
extracted guts of the old v2/openai provider; each provider supplies its own
Rules value to declare per-model constraints (e.g., DeepSeek Reasoner rejects
tools and temperature, Moonshot/xAI accept images only on *-vision* models,
Groq rejects audio input). v2/openai itself becomes a thin wrapper that sets
RestrictTemperature for o-series and gpt-5 models.

A new provider registry (v2/registry.go) exposes llm.Providers() and drives
the TUI's provider picker so adding a provider in future is a single-file
change.

The TUI at cmd/llm was migrated from v1 to v2 and moved to v2/cmd/llm. With
nothing else depending on v1, the v1 code at the repo root (all .go files,
schema/, internal/, provider/, root go.mod/go.sum) is deleted.

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

v2/openai/openai.go

@@ -1,433 +1,35 @@
 // Package openai implements the go-llm v2 provider interface for OpenAI.
+//
+// The actual wire-protocol logic lives in the shared openaicompat package;
+// this file encodes OpenAI-specific Rules (temperature is rejected on o-series
+// and gpt-5* models) and supplies the default base URL.
 package openai
 
 import (
-	"context"
-	"encoding/base64"
-	"fmt"
-	"io"
-	"net/http"
-	"path"
 	"strings"
 
-	"github.com/openai/openai-go"
-	"github.com/openai/openai-go/option"
-	"github.com/openai/openai-go/packages/param"
-	"github.com/openai/openai-go/shared"
-
-	"gitea.stevedudenhoeffer.com/steve/go-llm/v2/provider"
+	"gitea.stevedudenhoeffer.com/steve/go-llm/v2/openaicompat"
 )
 
-// Provider implements the provider.Provider interface for OpenAI.
-type Provider struct {
-	apiKey  string
-	baseURL string
-}
+// DefaultBaseURL is the public OpenAI Chat Completions endpoint.
+const DefaultBaseURL = "https://api.openai.com/v1"
 
-// New creates a new OpenAI provider.
+// Provider is the OpenAI chat-completion provider. It's a type alias over
+// openaicompat.Provider so existing callers using openai.Provider keep compiling.
+type Provider = openaicompat.Provider
+
+// New creates a new OpenAI provider. An empty baseURL uses DefaultBaseURL.
 func New(apiKey string, baseURL string) *Provider {
-	return &Provider{apiKey: apiKey, baseURL: baseURL}
+	if baseURL == "" {
+		baseURL = DefaultBaseURL
+	}
+	return openaicompat.New(apiKey, baseURL, openaicompat.Rules{
+		RestrictTemperature: restrictTemperature,
+	})
 }
 
-// Complete performs a non-streaming completion.
-func (p *Provider) Complete(ctx context.Context, req provider.Request) (provider.Response, error) {
-	var opts []option.RequestOption
-	opts = append(opts, option.WithAPIKey(p.apiKey))
-	if p.baseURL != "" {
-		opts = append(opts, option.WithBaseURL(p.baseURL))
-	}
-
-	cl := openai.NewClient(opts...)
-	oaiReq := p.buildRequest(req)
-
-	resp, err := cl.Chat.Completions.New(ctx, oaiReq)
-	if err != nil {
-		return provider.Response{}, fmt.Errorf("openai completion error: %w", err)
-	}
-
-	return p.convertResponse(resp), nil
-}
-
-// Stream performs a streaming completion.
-func (p *Provider) Stream(ctx context.Context, req provider.Request, events chan<- provider.StreamEvent) error {
-	var opts []option.RequestOption
-	opts = append(opts, option.WithAPIKey(p.apiKey))
-	if p.baseURL != "" {
-		opts = append(opts, option.WithBaseURL(p.baseURL))
-	}
-
-	cl := openai.NewClient(opts...)
-	oaiReq := p.buildRequest(req)
-	oaiReq.StreamOptions = openai.ChatCompletionStreamOptionsParam{
-		IncludeUsage: openai.Bool(true),
-	}
-
-	stream := cl.Chat.Completions.NewStreaming(ctx, oaiReq)
-
-	var fullText strings.Builder
-	var toolCalls []provider.ToolCall
-	toolCallArgs := map[int]*strings.Builder{}
-	var usage *provider.Usage
-
-	for stream.Next() {
-		chunk := stream.Current()
-
-		// Capture usage from the final chunk (present when StreamOptions.IncludeUsage is true)
-		if chunk.Usage.TotalTokens > 0 {
-			usage = &provider.Usage{
-				InputTokens:  int(chunk.Usage.PromptTokens),
-				OutputTokens: int(chunk.Usage.CompletionTokens),
-				TotalTokens:  int(chunk.Usage.TotalTokens),
-				Details:      extractUsageDetails(chunk.Usage),
-			}
-		}
-
-		for _, choice := range chunk.Choices {
-			// Text delta
-			if choice.Delta.Content != "" {
-				fullText.WriteString(choice.Delta.Content)
-				events <- provider.StreamEvent{
-					Type: provider.StreamEventText,
-					Text: choice.Delta.Content,
-				}
-			}
-
-			// Tool call deltas
-			for _, tc := range choice.Delta.ToolCalls {
-				idx := int(tc.Index)
-
-				if tc.ID != "" {
-					// New tool call starting
-					for len(toolCalls) <= idx {
-						toolCalls = append(toolCalls, provider.ToolCall{})
-					}
-					toolCalls[idx].ID = tc.ID
-					toolCalls[idx].Name = tc.Function.Name
-					toolCallArgs[idx] = &strings.Builder{}
-
-					events <- provider.StreamEvent{
-						Type: provider.StreamEventToolStart,
-						ToolCall: &provider.ToolCall{
-							ID:   tc.ID,
-							Name: tc.Function.Name,
-						},
-						ToolIndex: idx,
-					}
-				}
-
-				if tc.Function.Arguments != "" {
-					if b, ok := toolCallArgs[idx]; ok {
-						b.WriteString(tc.Function.Arguments)
-					}
-					events <- provider.StreamEvent{
-						Type:      provider.StreamEventToolDelta,
-						ToolIndex: idx,
-						ToolCall: &provider.ToolCall{
-							Arguments: tc.Function.Arguments,
-						},
-					}
-				}
-			}
-		}
-	}
-
-	if err := stream.Err(); err != nil {
-		return fmt.Errorf("openai stream error: %w", err)
-	}
-
-	// Finalize tool calls
-	for idx := range toolCalls {
-		if b, ok := toolCallArgs[idx]; ok {
-			toolCalls[idx].Arguments = b.String()
-		}
-		events <- provider.StreamEvent{
-			Type:      provider.StreamEventToolEnd,
-			ToolIndex: idx,
-			ToolCall:  &toolCalls[idx],
-		}
-	}
-
-	// Send done event
-	events <- provider.StreamEvent{
-		Type: provider.StreamEventDone,
-		Response: &provider.Response{
-			Text:      fullText.String(),
-			ToolCalls: toolCalls,
-			Usage:     usage,
-		},
-	}
-
-	return nil
-}
-
-func (p *Provider) buildRequest(req provider.Request) openai.ChatCompletionNewParams {
-	oaiReq := openai.ChatCompletionNewParams{
-		Model: req.Model,
-	}
-
-	for _, msg := range req.Messages {
-		oaiReq.Messages = append(oaiReq.Messages, convertMessage(msg, req.Model))
-	}
-
-	for _, tool := range req.Tools {
-		oaiReq.Tools = append(oaiReq.Tools, openai.ChatCompletionToolParam{
-			Type: "function",
-			Function: shared.FunctionDefinitionParam{
-				Name:        tool.Name,
-				Description: openai.String(tool.Description),
-				Parameters:  openai.FunctionParameters(tool.Schema),
-			},
-		})
-	}
-
-	if req.Temperature != nil {
-		// o* and gpt-5* models don't support custom temperatures
-		if !strings.HasPrefix(req.Model, "o") && !strings.HasPrefix(req.Model, "gpt-5") {
-			oaiReq.Temperature = openai.Float(*req.Temperature)
-		}
-	}
-
-	if req.MaxTokens != nil {
-		oaiReq.MaxCompletionTokens = openai.Int(int64(*req.MaxTokens))
-	}
-
-	if req.TopP != nil {
-		oaiReq.TopP = openai.Float(*req.TopP)
-	}
-
-	if len(req.Stop) > 0 {
-		oaiReq.Stop = openai.ChatCompletionNewParamsStopUnion{OfString: openai.String(req.Stop[0])}
-	}
-
-	return oaiReq
-}
-
-func convertMessage(msg provider.Message, model string) openai.ChatCompletionMessageParamUnion {
-	var arrayOfContentParts []openai.ChatCompletionContentPartUnionParam
-	var textContent param.Opt[string]
-
-	for _, img := range msg.Images {
-		var url string
-		if img.Base64 != "" {
-			url = "data:" + img.ContentType + ";base64," + img.Base64
-		} else if img.URL != "" {
-			url = img.URL
-		}
-		if url != "" {
-			arrayOfContentParts = append(arrayOfContentParts,
-				openai.ChatCompletionContentPartUnionParam{
-					OfImageURL: &openai.ChatCompletionContentPartImageParam{
-						ImageURL: openai.ChatCompletionContentPartImageImageURLParam{
-							URL: url,
-						},
-					},
-				},
-			)
-		}
-	}
-
-	for _, aud := range msg.Audio {
-		var b64Data string
-		var format string
-
-		if aud.Base64 != "" {
-			b64Data = aud.Base64
-			format = audioFormat(aud.ContentType)
-		} else if aud.URL != "" {
-			resp, err := http.Get(aud.URL)
-			if err != nil {
-				continue
-			}
-			data, err := io.ReadAll(resp.Body)
-			resp.Body.Close()
-			if err != nil {
-				continue
-			}
-			b64Data = base64.StdEncoding.EncodeToString(data)
-			ct := resp.Header.Get("Content-Type")
-			if ct == "" {
-				ct = aud.ContentType
-			}
-			if ct == "" {
-				ct = audioFormatFromURL(aud.URL)
-			}
-			format = audioFormat(ct)
-		}
-
-		if b64Data != "" && format != "" {
-			arrayOfContentParts = append(arrayOfContentParts,
-				openai.ChatCompletionContentPartUnionParam{
-					OfInputAudio: &openai.ChatCompletionContentPartInputAudioParam{
-						InputAudio: openai.ChatCompletionContentPartInputAudioInputAudioParam{
-							Data:   b64Data,
-							Format: format,
-						},
-					},
-				},
-			)
-		}
-	}
-
-	if msg.Content != "" {
-		if len(arrayOfContentParts) > 0 {
-			arrayOfContentParts = append(arrayOfContentParts,
-				openai.ChatCompletionContentPartUnionParam{
-					OfText: &openai.ChatCompletionContentPartTextParam{
-						Text: msg.Content,
-					},
-				},
-			)
-		} else {
-			textContent = openai.String(msg.Content)
-		}
-	}
-
-	// Determine if this model uses developer messages instead of system
-	useDeveloper := false
-	parts := strings.Split(model, "-")
-	if len(parts) > 1 && len(parts[0]) > 0 && parts[0][0] == 'o' {
-		useDeveloper = true
-	}
-
-	switch msg.Role {
-	case "system":
-		if useDeveloper {
-			return openai.ChatCompletionMessageParamUnion{
-				OfDeveloper: &openai.ChatCompletionDeveloperMessageParam{
-					Content: openai.ChatCompletionDeveloperMessageParamContentUnion{
-						OfString: textContent,
-					},
-				},
-			}
-		}
-		return openai.ChatCompletionMessageParamUnion{
-			OfSystem: &openai.ChatCompletionSystemMessageParam{
-				Content: openai.ChatCompletionSystemMessageParamContentUnion{
-					OfString: textContent,
-				},
-			},
-		}
-
-	case "user":
-		return openai.ChatCompletionMessageParamUnion{
-			OfUser: &openai.ChatCompletionUserMessageParam{
-				Content: openai.ChatCompletionUserMessageParamContentUnion{
-					OfString:              textContent,
-					OfArrayOfContentParts: arrayOfContentParts,
-				},
-			},
-		}
-
-	case "assistant":
-		as := &openai.ChatCompletionAssistantMessageParam{}
-		if msg.Content != "" {
-			as.Content.OfString = openai.String(msg.Content)
-		}
-		for _, tc := range msg.ToolCalls {
-			as.ToolCalls = append(as.ToolCalls, openai.ChatCompletionMessageToolCallParam{
-				ID: tc.ID,
-				Function: openai.ChatCompletionMessageToolCallFunctionParam{
-					Name:      tc.Name,
-					Arguments: tc.Arguments,
-				},
-			})
-		}
-		return openai.ChatCompletionMessageParamUnion{OfAssistant: as}
-
-	case "tool":
-		return openai.ChatCompletionMessageParamUnion{
-			OfTool: &openai.ChatCompletionToolMessageParam{
-				ToolCallID: msg.ToolCallID,
-				Content: openai.ChatCompletionToolMessageParamContentUnion{
-					OfString: openai.String(msg.Content),
-				},
-			},
-		}
-	}
-
-	// Fallback to user message
-	return openai.ChatCompletionMessageParamUnion{
-		OfUser: &openai.ChatCompletionUserMessageParam{
-			Content: openai.ChatCompletionUserMessageParamContentUnion{
-				OfString: textContent,
-			},
-		},
-	}
-}
-
-func (p *Provider) convertResponse(resp *openai.ChatCompletion) provider.Response {
-	var res provider.Response
-
-	if resp == nil || len(resp.Choices) == 0 {
-		return res
-	}
-
-	choice := resp.Choices[0]
-	res.Text = choice.Message.Content
-
-	for _, tc := range choice.Message.ToolCalls {
-		res.ToolCalls = append(res.ToolCalls, provider.ToolCall{
-			ID:        tc.ID,
-			Name:      tc.Function.Name,
-			Arguments: strings.TrimSpace(tc.Function.Arguments),
-		})
-	}
-
-	if resp.Usage.TotalTokens > 0 {
-		res.Usage = &provider.Usage{
-			InputTokens:  int(resp.Usage.PromptTokens),
-			OutputTokens: int(resp.Usage.CompletionTokens),
-			TotalTokens:  int(resp.Usage.TotalTokens),
-		}
-		res.Usage.Details = extractUsageDetails(resp.Usage)
-	}
-
-	return res
-}
-
-// audioFormat converts a MIME type to an OpenAI audio format string ("wav" or "mp3").
-func audioFormat(contentType string) string {
-	ct := strings.ToLower(contentType)
-	switch {
-	case strings.Contains(ct, "wav"):
-		return "wav"
-	case strings.Contains(ct, "mp3"), strings.Contains(ct, "mpeg"):
-		return "mp3"
-	default:
-		return "wav"
-	}
-}
-
-// extractUsageDetails extracts provider-specific detail tokens from an OpenAI CompletionUsage.
-func extractUsageDetails(usage openai.CompletionUsage) map[string]int {
-	details := map[string]int{}
-	if usage.CompletionTokensDetails.ReasoningTokens > 0 {
-		details[provider.UsageDetailReasoningTokens] = int(usage.CompletionTokensDetails.ReasoningTokens)
-	}
-	if usage.CompletionTokensDetails.AudioTokens > 0 {
-		details[provider.UsageDetailAudioOutputTokens] = int(usage.CompletionTokensDetails.AudioTokens)
-	}
-	if usage.PromptTokensDetails.CachedTokens > 0 {
-		details[provider.UsageDetailCachedInputTokens] = int(usage.PromptTokensDetails.CachedTokens)
-	}
-	if usage.PromptTokensDetails.AudioTokens > 0 {
-		details[provider.UsageDetailAudioInputTokens] = int(usage.PromptTokensDetails.AudioTokens)
-	}
-	if len(details) == 0 {
-		return nil
-	}
-	return details
-}
-
-// audioFormatFromURL guesses the audio format from a URL's file extension.
-func audioFormatFromURL(u string) string {
-	ext := strings.ToLower(path.Ext(u))
-	switch ext {
-	case ".mp3":
-		return "audio/mp3"
-	case ".wav":
-		return "audio/wav"
-	default:
-		return "audio/wav"
-	}
+// restrictTemperature reports whether OpenAI rejects a user-supplied
+// temperature for this model. o-series reasoning models and gpt-5* both do.
+func restrictTemperature(model string) bool {
+	return strings.HasPrefix(model, "o") || strings.HasPrefix(model, "gpt-5")
 }