GenAI interface (#2790)

* genai interface

* x

* x

* text to speech

* Re-add events package (#2761)

* Re-add events package

* run redis as a dep

* remove redis events

* fix: data race on event subscriber

* fix: data race in tests

* fix: store errors

* fix: lint issues

* feat: default stream

* Update file.go

---------

Co-authored-by: Brian Ketelsen <bketelsen@gmail.com>

* .

* copilot couldn't make it compile so I did

* copilot couldn't make it compile so I did

* x

---------

Co-authored-by: Brian Ketelsen <bketelsen@gmail.com>

Author: asim

broker/http_test.go

@@ -362,7 +362,6 @@ func BenchmarkSub32(b *testing.B) {
 	sub(b, 32)
 }
 
-
 func BenchmarkPub1(b *testing.B) {
 	pub(b, 1)
 }

broker/rabbitmq/rabbitmq.go

@@ -45,8 +45,6 @@ type publication struct {
 	err error
 }
 
-
-
 func (p *publication) Ack() error {
 	return p.d.Ack(false)
 }

cmd/cmd.go

@@ -4,17 +4,12 @@ package cmd
 import (
 	"fmt"
 	"math/rand"
-	"os"
 	"sort"
+	"os"
 	"strings"
 	"time"
 
 	"github.com/urfave/cli/v2"
-	"go-micro.dev/v5/auth"
-	nbroker "go-micro.dev/v5/broker/nats"
-	rabbit "go-micro.dev/v5/broker/rabbitmq"
-
-	"go-micro.dev/v5/broker"
 	"go-micro.dev/v5/cache"
 	"go-micro.dev/v5/cache/redis"
 	"go-micro.dev/v5/client"
@@ -26,6 +21,13 @@ import (
 	"go-micro.dev/v5/events"
 	"go-micro.dev/v5/logger"
 	mprofile "go-micro.dev/v5/profile"
+	"go-micro.dev/v5/auth"
+	"go-micro.dev/v5/broker"
+	nbroker "go-micro.dev/v5/broker/nats"
+	rabbit "go-micro.dev/v5/broker/rabbitmq"
+	"go-micro.dev/v5/genai"
+	"go-micro.dev/v5/genai/gemini"
+	"go-micro.dev/v5/genai/openai"
 	"go-micro.dev/v5/registry"
 	"go-micro.dev/v5/registry/consul"
 	"go-micro.dev/v5/registry/etcd"
@@ -246,6 +248,21 @@ var (
 			EnvVars: []string{"MICRO_CONFIG"},
 			Usage:   "The source of the config to be used to get configuration",
 		},
+		&cli.StringFlag{
+			Name:    "genai",
+			EnvVars: []string{"MICRO_GENAI"},
+			Usage:   "GenAI provider to use (e.g. openai, gemini, noop)",
+		},
+		&cli.StringFlag{
+			Name:    "genai_key",
+			EnvVars: []string{"MICRO_GENAI_KEY"},
+			Usage:   "GenAI API key",
+		},
+		&cli.StringFlag{
+			Name:    "genai_model",
+			EnvVars: []string{"MICRO_GENAI_MODEL"},
+			Usage:   "GenAI model to use (optional)",
+		},
 	}
 
 	DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
@@ -295,6 +312,11 @@ var (
 		"redis": redis.NewRedisCache,
 	}
 	DefaultStreams = map[string]func(...events.Option) (events.Stream, error){}
+
+	DefaultGenAI = map[string]func(...genai.Option) genai.GenAI{
+		"openai": openai.New,
+		"gemini": gemini.New,
+	}
 )
 
 func init() {
@@ -367,6 +389,8 @@ func (c *cmd) Options() Options {
 }
 
 func (c *cmd) Before(ctx *cli.Context) error {
+	// Set GenAI provider from flags/env
+	setGenAIFromFlags(ctx)
 	// If flags are set then use them otherwise do nothing
 	var serverOpts []server.Option
 	var clientOpts []client.Option
@@ -799,3 +823,24 @@ func Register(cmds ...*cli.Command) {
 		return app.Commands[i].Name < app.Commands[j].Name
 	})
 }
+
+func setGenAIFromFlags(ctx *cli.Context) {
+	provider := ctx.String("genai")
+	key := ctx.String("genai_key")
+	model := ctx.String("genai_model")
+
+	switch provider {
+	case "openai":
+		if key == "" {
+			key = os.Getenv("OPENAI_API_KEY")
+		}
+		genai.DefaultGenAI = openai.New(genai.WithAPIKey(key), genai.WithModel(model))
+	case "gemini":
+		if key == "" {
+			key = os.Getenv("GEMINI_API_KEY")
+		}
+		genai.DefaultGenAI = gemini.New(genai.WithAPIKey(key), genai.WithModel(model))
+	default:
+		genai.DefaultGenAI = genai.Default
+	}
+}

events/natsjs/nats_test.go

@@ -8,11 +8,11 @@ import (
 	"testing"
 	"time"
 
-	"go-micro.dev/v5/events/natsjs"
 	nserver "github.com/nats-io/nats-server/v2/server"
 	"github.com/stretchr/testify/assert"
 	"github.com/test-go/testify/require"
 	"go-micro.dev/v5/events"
+	"go-micro.dev/v5/events/natsjs"
 )
 
 type Payload struct {

genai/default.go

@@ -0,0 +1,16 @@
+package genai
+
+import (
+	"sync"
+)
+
+var (
+	DefaultGenAI GenAI = &noopGenAI{}
+	defaultOnce  sync.Once
+)
+
+func SetDefault(g GenAI) {
+	defaultOnce.Do(func() {
+		DefaultGenAI = g
+	})
+}

genai/gemini/gemini.go

@@ -0,0 +1,161 @@
+package gemini
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+
+	"go-micro.dev/v5/genai"
+)
+
+// gemini implements the GenAI interface using Google Gemini 2.5 API.
+type gemini struct {
+	options genai.Options
+}
+
+func New(opts ...genai.Option) genai.GenAI {
+	var options genai.Options
+	for _, o := range opts {
+		o(&options)
+	}
+	if options.APIKey == "" {
+		options.APIKey = os.Getenv("GEMINI_API_KEY")
+	}
+	return &gemini{options: options}
+}
+
+func (g *gemini) Generate(prompt string, opts ...genai.Option) (*genai.Result, error) {
+	options := g.options
+	for _, o := range opts {
+		o(&options)
+	}
+	ctx := context.Background()
+
+	res := &genai.Result{Prompt: prompt, Type: options.Type}
+
+	endpoint := options.Endpoint
+	if endpoint == "" {
+		endpoint = "https://generativelanguage.googleapis.com/v1beta/models/"
+	}
+
+	var url string
+	var body map[string]interface{}
+
+	// Determine model to use
+	var model string
+	switch options.Type {
+	case "image":
+		if options.Model != "" {
+			model = options.Model
+		} else {
+			model = "gemini-2.5-pro-vision"
+		}
+		url = endpoint + model + ":generateContent?key=" + options.APIKey
+		body = map[string]interface{}{
+			"contents": []map[string]interface{}{
+				{"parts": []map[string]string{{"text": prompt}}},
+			},
+		}
+	case "audio":
+		if options.Model != "" {
+			model = options.Model
+		} else {
+			model = "gemini-2.5-pro"
+		}
+		url = endpoint + model + ":generateContent?key=" + options.APIKey
+		body = map[string]interface{}{
+			"contents": []map[string]interface{}{
+				{"parts": []map[string]string{{"text": prompt}}},
+			},
+			"response_mime_type": "audio/wav",
+		}
+	case "text":
+		fallthrough
+	default:
+		if options.Model != "" {
+			model = options.Model
+		} else {
+			model = "gemini-2.5-pro"
+		}
+		url = endpoint + model + ":generateContent?key=" + options.APIKey
+		body = map[string]interface{}{
+			"contents": []map[string]interface{}{
+				{"parts": []map[string]string{{"text": prompt}}},
+			},
+		}
+	}
+
+	b, _ := json.Marshal(body)
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if options.Type == "audio" {
+		var result struct {
+			Candidates []struct {
+				Content struct {
+					Parts []struct {
+						InlineData struct {
+							Data []byte `json:"data"`
+						} `json:"inline_data"`
+					} `json:"parts"`
+				} `json:"content"`
+			} `json:"candidates"`
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			return nil, err
+		}
+		if len(result.Candidates) == 0 || len(result.Candidates[0].Content.Parts) == 0 {
+			return nil, fmt.Errorf("no audio returned")
+		}
+		res.Data = result.Candidates[0].Content.Parts[0].InlineData.Data
+		return res, nil
+	}
+
+	var result struct {
+		Candidates []struct {
+			Content struct {
+				Parts []struct {
+					Text string `json:"text"`
+				} `json:"parts"`
+			} `json:"content"`
+		} `json:"candidates"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+	if len(result.Candidates) == 0 || len(result.Candidates[0].Content.Parts) == 0 {
+		return nil, fmt.Errorf("no candidates returned")
+	}
+	res.Text = result.Candidates[0].Content.Parts[0].Text
+	return res, nil
+}
+
+func (g *gemini) Stream(prompt string, opts ...genai.Option) (*genai.Stream, error) {
+	results := make(chan *genai.Result)
+	go func() {
+		defer close(results)
+		res, err := g.Generate(prompt, opts...)
+		if err != nil {
+			// Send error via Stream.Err, not channel
+			return
+		}
+		results <- res
+	}()
+	return &genai.Stream{Results: results}, nil
+}
+
+func init() {
+	genai.Register("gemini", New())
+}

genai/genai.go

@@ -0,0 +1,53 @@
+// Package genai provides a generic interface for generative AI providers.
+package genai
+
+// Result is the unified response from GenAI providers.
+type Result struct {
+	Prompt string
+	Type   string
+	Data   []byte // for audio/image binary data
+	Text   string // for text or image URL
+}
+
+// Stream represents a streaming response from a GenAI provider.
+type Stream struct {
+	Results <-chan *Result
+	Err     error
+	// You can add fields for cancellation, errors, etc. if needed
+}
+
+// GenAI is the generic interface for generative AI providers.
+type GenAI interface {
+	Generate(prompt string, opts ...Option) (*Result, error)
+	Stream(prompt string, opts ...Option) (*Stream, error)
+}
+
+// Option is a functional option for configuring providers.
+type Option func(*Options)
+
+// Options holds configuration for providers.
+type Options struct {
+	APIKey   string
+	Endpoint string
+	Type     string // "text", "image", "audio", etc.
+	Model    string // model name, e.g. "gemini-2.5-pro"
+	// Add more fields as needed
+}
+
+// Option functions for generation type
+func Text(o *Options)  { o.Type = "text" }
+func Image(o *Options) { o.Type = "image" }
+func Audio(o *Options) { o.Type = "audio" }
+
+// Provider registry
+var providers = make(map[string]GenAI)
+
+// Register a GenAI provider by name.
+func Register(name string, provider GenAI) {
+	providers[name] = provider
+}
+
+// Get a GenAI provider by name.
+func Get(name string) GenAI {
+	return providers[name]
+}

genai/noop.go

@@ -0,0 +1,16 @@
+package genai
+
+type noopGenAI struct{}
+
+func (n *noopGenAI) Generate(prompt string, opts ...Option) (*Result, error) {
+	return &Result{Prompt: prompt, Type: "noop", Text: "noop response"}, nil
+}
+
+func (n *noopGenAI) Stream(prompt string, opts ...Option) (*Stream, error) {
+	results := make(chan *Result, 1)
+	results <- &Result{Prompt: prompt, Type: "noop", Text: "noop response"}
+	close(results)
+	return &Stream{Results: results}, nil
+}
+
+var Default = &noopGenAI{}