client.go

package goai

import (
	"context"
	"fmt"
	"sync"
)

// Client is the main entry point for interacting with LLM providers
type Client struct {
	provider Provider
	options  Options
}

// Response represents a response from an LLM provider
type Response struct {
	Content    string                 // The response text
	TokensUsed int                    // Number of tokens used (if available)
	LatencyMs  int64                  // Response latency in milliseconds
	Model      string                 // Model identifier
	Provider   string                 // Provider name
	Metadata   map[string]interface{} // Additional metadata
}

// Provider is the internal interface that all providers must implement
type Provider interface {
	// chat sends a prompt to the LLM and returns the response
	chat(ctx context.Context, prompt string, opts Options) (*Response, error)
	
	// name returns the provider name
	name() string
	
	// model returns the model identifier
	model() string
}

// ProviderFactory creates a new provider instance
type ProviderFactory func(model string, opts Options) (Provider, error)

var (
	mu        sync.RWMutex
	providers = make(map[string]ProviderFactory)
)

// register registers a provider factory
func register(name string, factory ProviderFactory) {
	mu.Lock()
	defer mu.Unlock()
	providers[name] = factory
}

// New creates a new LLM client
//
// Example:
//   client := goai.New("openai", "gpt-4o",
//       goai.WithAPIKey(os.Getenv("OPENAI_API_KEY")),
//   )
func New(providerName, model string, opts ...Option) (*Client, error) {
	mu.RLock()
	factory, exists := providers[providerName]
	mu.RUnlock()
	
	if !exists {
		return nil, fmt.Errorf("%w: %s", ErrProviderNotFound, providerName)
	}
	
	// Build options
	options := defaultOptions()
	for _, opt := range opts {
		opt(&options)
	}
	
	// Create provider
	provider, err := factory(model, options)
	if err != nil {
		return nil, err
	}
	
	return &Client{
		provider: provider,
		options:  options,
	}, nil
}

// Chat sends a prompt to the LLM and returns the response
//
// The context can be used to set timeouts or cancel the request.
//
// Example:
//   ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
//   defer cancel()
//
//   response, err := client.Chat(ctx, "Hello, how are you?")
//   if err != nil {
//       log.Fatal(err)
//   }
//   fmt.Println(response.Content)
func (c *Client) Chat(ctx context.Context, prompt string) (*Response, error) {
	if prompt == "" {
		return nil, fmt.Errorf("prompt cannot be empty")
	}
	
	return c.provider.chat(ctx, prompt, c.options)
}

// ListProviders returns a list of all registered provider names
func ListProviders() []string {
	mu.RLock()
	defer mu.RUnlock()
	
	names := make([]string, 0, len(providers))
	for name := range providers {
		names = append(names, name)
	}
	return names
}