majordomo/builtin.go

package majordomo

import (
	"context"
	"fmt"
	"net/http"

	"gitea.stevedudenhoeffer.com/steve/majordomo/llm"
	"gitea.stevedudenhoeffer.com/steve/majordomo/provider/anthropic"
	"gitea.stevedudenhoeffer.com/steve/majordomo/provider/ollama"
	"gitea.stevedudenhoeffer.com/steve/majordomo/provider/openai"
)

// Built-in provider names. Real client implementations land per-phase
// (see progress.md); until a provider's phase ships, its registration is a
// stub that resolves (so specs parse and env DSNs load) but errors on use.
const (
	ProviderOpenAI      = "openai"
	ProviderAnthropic   = "anthropic"
	ProviderGoogle      = "google"
	ProviderOllama      = "ollama"
	ProviderOllamaCloud = "ollama-cloud"
	ProviderForeman     = "foreman"
)

// registerBuiltins installs the built-in providers and env-DSN scheme
// factories into a fresh registry. httpClient, when non-nil, is used by
// every provider and factory the registry itself constructs.
func registerBuiltins(r *Registry, httpClient *http.Client) {
	ollamaOpts := func(extra ...ollama.Option) []ollama.Option {
		if httpClient != nil {
			extra = append(extra, ollama.WithHTTPClient(httpClient))
		}
		return extra
	}

	// Native-Ollama family: three names over one client with presets.
	r.providers[ProviderOllama] = ollama.Local(ollamaOpts()...)
	r.providers[ProviderOllamaCloud] = ollama.Cloud(ollamaOpts()...)
	// foreman has no default URL; the no-DSN registration resolves but
	// errors on use with a clear message (use an LLM_* DSN or
	// ollama.Foreman(...) + RegisterProvider).
	r.providers[ProviderForeman] = ollama.New(ollamaOpts(ollama.WithName(ProviderForeman))...)

	ollamaScheme := func(name string, dsn DSN) (llm.Provider, error) {
		return ollama.New(ollamaOpts(
			ollama.WithName(name),
			ollama.WithBaseURL(dsn.BaseURL()),
			ollama.WithToken(dsn.Token),
		)...), nil
	}
	r.schemes[ProviderOllama] = ollamaScheme
	r.schemes[ProviderOllamaCloud] = ollamaScheme
	r.schemes[ProviderForeman] = ollamaScheme

	// OpenAI and OpenAI-compatible endpoints.
	openaiOpts := func(extra ...openai.Option) []openai.Option {
		if httpClient != nil {
			extra = append(extra, openai.WithHTTPClient(httpClient))
		}
		return extra
	}
	r.providers[ProviderOpenAI] = openai.New(openaiOpts()...)
	r.schemes[ProviderOpenAI] = func(name string, dsn DSN) (llm.Provider, error) {
		return openai.New(openaiOpts(
			openai.WithName(name),
			openai.WithBaseURL(dsn.BaseURL()),
			openai.WithAPIKey(dsn.Token),
		)...), nil
	}

	// Anthropic and Anthropic-compatible endpoints.
	anthropicOpts := func(extra ...anthropic.Option) []anthropic.Option {
		if httpClient != nil {
			extra = append(extra, anthropic.WithHTTPClient(httpClient))
		}
		return extra
	}
	r.providers[ProviderAnthropic] = anthropic.New(anthropicOpts()...)
	r.schemes[ProviderAnthropic] = func(name string, dsn DSN) (llm.Provider, error) {
		return anthropic.New(anthropicOpts(
			anthropic.WithName(name),
			anthropic.WithBaseURL(dsn.BaseURL()),
			anthropic.WithAPIKey(dsn.Token),
		)...), nil
	}

	// Google lands in its own phase; stub until then.
	r.providers[ProviderGoogle] = &stubProvider{name: ProviderGoogle, kind: ProviderGoogle}
	r.schemes[ProviderGoogle] = stubScheme(ProviderGoogle)
	// "gemini" is an alternate scheme for the Google provider.
	r.schemes["gemini"] = stubScheme(ProviderGoogle)
}

func stubScheme(kind string) SchemeFactory {
	return func(name string, dsn DSN) (llm.Provider, error) {
		return &stubProvider{name: name, kind: kind, baseURL: dsn.BaseURL(), token: dsn.Token}, nil
	}
}

// stubProvider stands in for a provider implementation that lands in a
// later phase. It resolves and carries its connection details (so Parse,
// chains, and env loading are fully functional) but errors on use.
type stubProvider struct {
	name    string
	kind    string
	baseURL string
	token   string
}

func (s *stubProvider) Name() string { return s.name }

func (s *stubProvider) Model(id string, opts ...llm.ModelOption) (llm.Model, error) {
	cfg := llm.ApplyModelOptions(opts)
	return &stubModel{provider: s, id: id, cfg: cfg}, nil
}

type stubModel struct {
	provider *stubProvider
	id       string
	cfg      llm.ModelConfig
}

func (m *stubModel) err() error {
	return fmt.Errorf("majordomo: provider %q (%s) is not implemented yet", m.provider.name, m.provider.kind)
}

func (m *stubModel) Generate(context.Context, llm.Request, ...llm.Option) (*llm.Response, error) {
	return nil, m.err()
}

func (m *stubModel) Stream(context.Context, llm.Request, ...llm.Option) (llm.Stream, error) {
	return nil, m.err()
}

func (m *stubModel) Capabilities() llm.Capabilities {
	if m.cfg.Capabilities != nil {
		return *m.cfg.Capabilities
	}
	return llm.Capabilities{}
}