Updated

Author: djthorpe

pkg/internal/impl/cache.go

@@ -0,0 +1,66 @@
+package impl
+
+import (
+	// Packages
+	"sync"
+
+	llm "github.com/mutablelogic/go-llm"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type ModelCache struct {
+	sync.RWMutex
+	cache map[string]llm.Model
+}
+
+type ModelLoadFunc func() ([]llm.Model, error)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func NewModelCache() *ModelCache {
+	cache := new(ModelCache)
+	cache.cache = make(map[string]llm.Model, 20)
+	return cache
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// METHODS
+
+// Load models and return them
+func (c *ModelCache) Load(fn ModelLoadFunc) ([]llm.Model, error) {
+	c.Lock()
+	defer c.Unlock()
+
+	// Load models
+	if len(c.cache) == 0 {
+		if models, err := fn(); err != nil {
+			return nil, err
+		} else {
+			for _, m := range models {
+				c.cache[m.Name()] = m
+			}
+		}
+	}
+
+	// Return models
+	result := make([]llm.Model, 0, len(c.cache))
+	for _, model := range c.cache {
+		result = append(result, model)
+	}
+	return result, nil
+}
+
+// Return a model by name
+func (c *ModelCache) Get(fn ModelLoadFunc, name string) (llm.Model, error) {
+	if len(c.cache) == 0 {
+		if _, err := c.Load(fn); err != nil {
+			return nil, err
+		}
+	}
+	c.RLock()
+	defer c.RUnlock()
+	return c.cache[name], nil
+}

pkg/session/session.go renamed to pkg/internal/impl/session.go

@@ -1,4 +1,4 @@
-package session
+package impl
 
 import (
 	"context"

pkg/mistral/client.go

@@ -1,22 +1,22 @@
 /*
-mistral implements an API client for mistral (https://docs.mistral.ai/api/)
+mistral implements an API client for mistral
+https://docs.mistral.ai/api/
 */
 package mistral
 
 import (
-	"context"
-
 	// Packages
 	client "github.com/mutablelogic/go-client"
 	llm "github.com/mutablelogic/go-llm"
+	impl "github.com/mutablelogic/go-llm/pkg/internal/impl"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
 type Client struct {
 	*client.Client
-	cache map[string]llm.Model
+	*impl.ModelCache
 }
 
 var _ llm.Agent = (*Client)(nil)
@@ -46,7 +46,7 @@ func New(ApiKey string, opts ...client.ClientOpt) (*Client, error) {
 	}
 
 	// Return the client
-	return &Client{client, nil}, nil
+	return &Client{client, impl.NewModelCache()}, nil
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -56,36 +56,3 @@ func New(ApiKey string, opts ...client.ClientOpt) (*Client, error) {
 func (Client) Name() string {
 	return defaultName
 }
-
-// Return the models
-func (c *Client) Models(ctx context.Context) ([]llm.Model, error) {
-	// Cache models
-	if c.cache == nil {
-		models, err := c.ListModels(ctx)
-		if err != nil {
-			return nil, err
-		}
-		c.cache = make(map[string]llm.Model, len(models))
-		for _, model := range models {
-			c.cache[model.Name()] = model
-		}
-	}
-
-	// Return models
-	result := make([]llm.Model, 0, len(c.cache))
-	for _, model := range c.cache {
-		result = append(result, model)
-	}
-	return result, nil
-}
-
-// Return a model by name, or nil if not found.
-// Panics on error.
-func (c *Client) Model(ctx context.Context, name string) llm.Model {
-	if c.cache == nil {
-		if _, err := c.Models(ctx); err != nil {
-			panic(err)
-		}
-	}
-	return c.cache[name]
-}

pkg/mistral/completion.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"strings"
 
+	// Packages
 	"github.com/mutablelogic/go-client"
 	"github.com/mutablelogic/go-llm"
 )
@@ -22,6 +23,17 @@ type Response struct {
 	Metrics     `json:"usage,omitempty"`
 }
 
+// Possible completions
+type Completions []Completion
+
+// Completion Variation
+type Completion struct {
+	Index   uint64   `json:"index"`
+	Message *Message `json:"message"`
+	Delta   *Message `json:"delta,omitempty"` // For streaming
+	Reason  string   `json:"finish_reason,omitempty"`
+}
+
 // Metrics
 type Metrics struct {
 	InputTokens  uint64 `json:"prompt_tokens,omitempty"`
@@ -203,3 +215,45 @@ func appendCompletion(response *Response, c *Completion) {
 		}
 	}
 }
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS - COMPLETIONS
+
+// Return the number of completions
+func (c Completions) Num() int {
+	return len(c)
+}
+
+// Return message for a specific completion
+func (c Completions) Message(index int) *Message {
+	if index < 0 || index >= len(c) {
+		return nil
+	}
+	return c[index].Message
+}
+
+// Return the role of the completion
+func (c Completions) Role() string {
+	// The role should be the same for all completions, let's use the first one
+	if len(c) == 0 {
+		return ""
+	}
+	return c[0].Message.Role()
+}
+
+// Return the text content for a specific completion
+func (c Completions) Text(index int) string {
+	if index < 0 || index >= len(c) {
+		return ""
+	}
+	return c[index].Message.Text(0)
+}
+
+// Return the current session tool calls given the completion index.
+// Will return nil if no tool calls were returned.
+func (c Completions) ToolCalls(index int) []llm.ToolCall {
+	if index < 0 || index >= len(c) {
+		return nil
+	}
+	return c[index].Message.ToolCalls(0)
+}

pkg/mistral/content.go

@@ -0,0 +1,47 @@
+package mistral
+
+import (
+	"net/url"
+
+	"github.com/mutablelogic/go-llm"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Content struct {
+	Type        string                       `json:"type"` // text or content
+	*Text       `json:"text,omitempty"`      // text content
+	*Prediction `json:"content,omitempty"`   // prediction
+	*Image      `json:"image_url,omitempty"` // image_url
+}
+
+// text content
+type Text string
+
+// text content
+type Prediction string
+
+// either a URL or "data:image/png;base64," followed by the base64 encoded image
+type Image string
+
+///////////////////////////////////////////////////////////////////////////////
+// LICECYCLE
+
+func NewPrediction(content Prediction) *Content {
+	return &Content{Type: "content", Prediction: &content}
+}
+
+func NewTextContext(text Text) *Content {
+	return &Content{Type: "text", Text: &text}
+}
+
+func NewImageData(image *llm.Attachment) *Content {
+	url := Image(image.Url())
+	return &Content{Type: "image_url", Image: &url}
+}
+
+func NewImageUrl(u *url.URL) *Content {
+	url := Image(u.String())
+	return &Content{Type: "image_url", Image: &url}
+}