Registry: add Mozilla AI registry provider with embedded data (#132)

* Registry: add Mozilla AI registry provider with embedded data
* Add mozilla-ai provider with complete registry implementation
* Generated JSON schema for registry validation
* Integration with basecmd to add mozilla-ai as primary registry (for add/resolve)
* MCPM: drop manually setting version to latest (leave that for the caller - e.g. add)
* Update API tools model
* Registry JSON: add sqllite
* Update Models
* Drop args/env from Package.Installations
* Drop args.env from Mozilla-ai's Server.Installations
* Drop args/env from MCPM registry server installations
* Update tests
* Improve logger line for startup validation failure

Author: peteski22

internal/api/tools.go

@@ -21,39 +21,100 @@ type ToolCallResponse struct {
 
 // Tool represents a callable tool, following the MCP spec.
 type Tool struct {
-	Name        string          `json:"name"`
-	Description string          `json:"description,omitempty"`
-	InputSchema ToolInputSchema `json:"inputSchema"`
-	Annotations ToolAnnotation  `json:"annotations"`
+	// Name of the tool.
+	// Display name precedence order for a tool is: title, annotations.title, then name.
+	Name string `json:"name"`
+
+	// Title is a human-readable and easily understood title for the tool.
+	Title string `json:"title,omitempty"`
+
+	// Description is a human-readable description of the tool.
+	// This can be used by clients to improve the LLM's understanding of available tools.
+	// It can be thought of like a "hint" to the model.
+	Description string `json:"description"`
+
+	// InputSchema is JSONSchema defining the expected parameters for the tool.
+	InputSchema *JSONSchema `json:"inputSchema,omitempty"`
+
+	// OutputSchema is an optional JSONSchema defining the structure of the tool's
+	// output returned in the structured content field of a tool call result.
+	OutputSchema *JSONSchema `json:"outputSchema,omitempty"`
+
+	// Annotations provide optional additional tool information.
+	// Display name precedence order is: title, annotations.title when present, then tool name.
+	Annotations *ToolAnnotations `json:"annotations,omitempty"`
+
+	// Meta is reserved by MCP to allow clients and servers to attach additional metadata to their interactions.
+	// See https://modelcontextprotocol.io/specification/2025-06-18/basic#general-fields for notes on _meta usage.
+	Meta map[string]any `json:"_meta,omitempty"` //nolint:tagliatelle
 }
 
 // ToolResponse represents the wrapped API response for a Tool.
 type ToolResponse struct {
 	Body Tool
 }
 
-// ToolInputSchema defines input params using JSON Schema
-type ToolInputSchema struct {
-	Type       string         `json:"type"`
+// JSONSchema defines the structure for a JSON schema object.
+type JSONSchema struct {
+	// Type defines the type for this schema, e.g. "object".
+	Type string `json:"type"`
+
+	// Properties represents a property name and associated object definition.
 	Properties map[string]any `json:"properties,omitempty"`
-	Required   []string       `json:"required,omitempty"`
+
+	// Required lists the (keys of) Properties that are required.
+	Required []string `json:"required,omitempty"`
 }
 
-// ToolAnnotation defines behavioral hints for a tool
-type ToolAnnotation struct {
-	Title           string `json:"title,omitempty"`
-	ReadOnlyHint    *bool  `json:"readOnlyHint,omitempty"`
-	DestructiveHint *bool  `json:"destructiveHint,omitempty"`
-	IdempotentHint  *bool  `json:"idempotentHint,omitempty"`
-	OpenWorldHint   *bool  `json:"openWorldHint,omitempty"`
+// ToolAnnotations provides additional properties describing a Tool to clients.
+// NOTE: all properties in ToolAnnotations are **hints**.
+// They are not guaranteed to provide a faithful description of tool behavior
+// (including descriptive properties like `title`).
+// Clients should never make tool use decisions based on ToolAnnotations received from untrusted servers.
+type ToolAnnotations struct {
+	// Title is a human-readable title for the tool.
+	Title *string `json:"title,omitempty"`
+
+	// ReadOnlyHint if true, the tool should not modify its environment.
+	ReadOnlyHint *bool `json:"readOnlyHint,omitempty"`
+
+	// DestructiveHint if true, the tool may perform destructive updates to its environment.
+	// If false, the tool performs only additive updates.
+	// (This property is meaningful only when ReadOnlyHint is false)
+	DestructiveHint *bool `json:"destructiveHint,omitempty"`
+
+	// IdempotentHint if true, calling the tool repeatedly with the same arguments
+	// will have no additional effect on its environment.
+	// (This property is meaningful only when ReadOnlyHint is false)
+	IdempotentHint *bool `json:"idempotentHint,omitempty"`
+
+	// OpenWorldHint if true, this tool may interact with an "open world" of external
+	// entities. If false, the tool's domain of interaction is closed.
+	// For example, the world of a web search tool is open, whereas that
+	// of a memory tool is not.
+	OpenWorldHint *bool `json:"openWorldHint,omitempty"`
 }
 
 // ToAPIType can be used to convert a wrapped domain type to an API-safe type.
 func (d DomainTool) ToAPIType() (Tool, error) {
+	schema := &JSONSchema{
+		Type:       d.InputSchema.Type,
+		Properties: d.InputSchema.Properties,
+		Required:   d.InputSchema.Required,
+	}
+
+	annotations := &ToolAnnotations{
+		Title:           &d.Annotations.Title,
+		ReadOnlyHint:    d.Annotations.ReadOnlyHint,
+		DestructiveHint: d.Annotations.DestructiveHint,
+		OpenWorldHint:   d.Annotations.OpenWorldHint,
+		IdempotentHint:  d.Annotations.IdempotentHint,
+	}
+
 	return Tool{
 		Name:        d.Name,
 		Description: d.Description,
-		InputSchema: ToolInputSchema(d.InputSchema),
-		Annotations: ToolAnnotation(d.Annotations),
+		InputSchema: schema,
+		Annotations: annotations,
 	}, nil
 }

internal/cmd/basecmd.go

@@ -10,6 +10,7 @@ import (
 	"github.com/mozilla-ai/mcpd/v2/internal/cmd/output"
 	"github.com/mozilla-ai/mcpd/v2/internal/flags"
 	"github.com/mozilla-ai/mcpd/v2/internal/provider/mcpm"
+	"github.com/mozilla-ai/mcpd/v2/internal/provider/mozilla_ai"
 	"github.com/mozilla-ai/mcpd/v2/internal/registry"
 	"github.com/mozilla-ai/mcpd/v2/internal/runtime"
 )
@@ -82,14 +83,20 @@ func (c *BaseCmd) Build() (registry.PackageProvider, error) {
 	opts := runtime.WithSupportedRuntimes(supportedRuntimes...)
 	l := logger.Named("registry")
 
-	mcpmRegistry, err := mcpm.NewRegistry(l, mcpm.ManifestURL, opts)
+	mozillaRegistry, err := mozilla_ai.NewRegistry(l, "", opts)
 	if err != nil {
 		// TODO: Handle tolerating some failed registries, as long as we can meet a minimum requirement.
 		return nil, err
 	}
 
+	mcpmRegistry, err := mcpm.NewRegistry(l, mcpm.ManifestURL, opts)
+	if err != nil {
+		return nil, err
+	}
+
 	// NOTE: The order the registries are added here determines their precedence when searching and resolving packages.
 	registries := []registry.PackageProvider{
+		mozillaRegistry,
 		mcpmRegistry,
 	}
 

internal/daemon/daemon.go

@@ -77,7 +77,10 @@ func NewDaemon(apiAddr string, opts *Opts) (*Daemon, error) {
 		serverNames = append(serverNames, srv.Name())
 		// Validate the config since the daemon will be required to start MCP servers using it.
 		if err := srv.Validate(); err != nil {
-			validateErrs = errors.Join(validateErrs, err)
+			validateErrs = errors.Join(
+				validateErrs,
+				fmt.Errorf("invalid server configuration '%s': %w", srv.Name(), err),
+			)
 		}
 	}
 	if validateErrs != nil {
@@ -110,6 +113,7 @@ func (d *Daemon) StartAndManage(ctx context.Context) error {
 		d.logger.Info("Shutting down MCP servers and client connections")
 		for _, n := range d.clientManager.List() {
 			if c, ok := d.clientManager.Client(n); ok {
+				d.logger.Info(fmt.Sprintf("Closing client %s", n))
 				_ = c.Close()
 			}
 		}

internal/packages/argument.go

@@ -18,8 +18,8 @@ const (
 	// VariableTypeArgBool represents a command line argument that is a boolean flag (doesn't have a value).
 	VariableTypeArgBool VariableType = "argument_bool"
 
-	// VariableTypePositionalArg represents a positional command line argument.
-	VariableTypePositionalArg VariableType = "positional_argument"
+	// VariableTypeArgPositional represents a positional command line argument.
+	VariableTypeArgPositional VariableType = "argument_positional"
 )
 
 // EnvVarPlaceholderRegex is used to find environment variable placeholders like ${VAR_NAME}.
@@ -61,7 +61,7 @@ func (a Arguments) Ordered() []ArgumentMetadata {
 		// Ensure name is set in the metadata
 		meta.Name = name
 
-		if meta.VariableType == VariableTypePositionalArg && meta.Position != nil {
+		if meta.VariableType == VariableTypeArgPositional && meta.Position != nil {
 			positional = append(positional, meta)
 		} else {
 			others = append(others, meta)
@@ -129,7 +129,7 @@ func BoolArgument(_ string, data ArgumentMetadata) bool {
 
 // PositionalArgument is a predicate that requires the argument is a positional command line argument.
 func PositionalArgument(_ string, data ArgumentMetadata) bool {
-	return data.VariableType == VariableTypePositionalArg
+	return data.VariableType == VariableTypeArgPositional
 }
 
 // NonPositionalArgument is a predicate that requires the argument is not a positional command line argument.

internal/packages/argument_test.go

@@ -521,15 +521,15 @@ func TestArgumentMetadata_NameAndExample(t *testing.T) {
 				Description:  "Positional argument",
 				Required:     true,
 				Example:      "/path/to/file",
-				VariableType: VariableTypePositionalArg,
+				VariableType: VariableTypeArgPositional,
 				Position:     &[]int{1}[0],
 			},
 			expected: ArgumentMetadata{
 				Name:         "POS_ARG",
 				Description:  "Positional argument",
 				Required:     true,
 				Example:      "/path/to/file",
-				VariableType: VariableTypePositionalArg,
+				VariableType: VariableTypeArgPositional,
 				Position:     &[]int{1}[0],
 			},
 		},
@@ -568,7 +568,7 @@ func TestArguments_Ordered_NameSetting(t *testing.T) {
 			Description:  "Positional argument",
 			Required:     true,
 			Example:      "pos_example",
-			VariableType: VariableTypePositionalArg,
+			VariableType: VariableTypeArgPositional,
 			Position:     &[]int{1}[0],
 		},
 		"--flag": {
@@ -588,7 +588,7 @@ func TestArguments_Ordered_NameSetting(t *testing.T) {
 		switch arg.Name {
 		case "POS_ARG":
 			require.Equal(t, "pos_example", arg.Example)
-			require.Equal(t, VariableTypePositionalArg, arg.VariableType)
+			require.Equal(t, VariableTypeArgPositional, arg.VariableType)
 			require.NotNil(t, arg.Position)
 			require.Equal(t, 1, *arg.Position)
 		case "ENV_VAR":

internal/packages/installation.go

@@ -5,15 +5,13 @@ import "github.com/mozilla-ai/mcpd/v2/internal/runtime"
 type Installations map[runtime.Runtime]Installation
 
 type Installation struct {
-	Command     string            `json:"command"`
-	Args        []string          `json:"args"`
-	Package     string            `json:"package,omitempty"`
-	Version     string            `json:"version,omitempty"`
-	Env         map[string]string `json:"env,omitempty"`
-	Description string            `json:"description,omitempty"`
-	Recommended bool              `json:"recommended,omitempty"`
-	Deprecated  bool              `json:"deprecated,omitempty"`
-	Transports  []Transport       `json:"transports,omitempty"`
+	Command     string      `json:"command"`
+	Package     string      `json:"package,omitempty"`
+	Version     string      `json:"version,omitempty"`
+	Description string      `json:"description,omitempty"`
+	Recommended bool        `json:"recommended,omitempty"`
+	Deprecated  bool        `json:"deprecated,omitempty"`
+	Transports  []Transport `json:"transports,omitempty"`
 }
 
 // AnyDeprecated can be used to determine if any of the installations are deprecated.

internal/packages/tools.go

@@ -20,13 +20,6 @@ type Tool struct {
 	// It can be thought of like a "hint" to the model.
 	Description string `json:"description,omitempty"`
 
-	// InputSchema is JSONSchema defining the expected parameters for the tool.
-	InputSchema JSONSchema `json:"inputSchema"`
-
-	// OutputSchema is an optional JSONSchema defining the structure of the tool's
-	// output returned in the structured content field of a tool call result.
-	OutputSchema *JSONSchema `json:"outputSchema,omitempty"`
-
 	// Annotations provide optional additional tool information.
 	// Display name precedence order is: title, annotations.title when present, then tool name.
 	Annotations *ToolAnnotations `json:"annotations,omitempty"`
@@ -36,18 +29,6 @@ type Tool struct {
 	Meta map[string]any `json:"_meta,omitempty"`
 }
 
-// JSONSchema defines the structure for a JSON schema object.
-type JSONSchema struct {
-	// Type defines the type for this schema, e.g. "object".
-	Type string `json:"type"`
-
-	// Properties represents a property name and associated object definition.
-	Properties map[string]any `json:"properties,omitempty"`
-
-	// Required lists the (keys of) Properties that are required.
-	Required []string `json:"required,omitempty"`
-}
-
 // ToolAnnotations provides additional properties describing a Tool to clients.
 // NOTE: all properties in ToolAnnotations are **hints**.
 // They are not guaranteed to provide a faithful description of tool behavior

internal/provider/mcpm/cli_arg_parser.go

@@ -53,7 +53,7 @@ func (p *CLIArgParser) parsePositional(arg string, position int) {
 
 	// Store as positional argument with logical position information
 	if metadata, exists := p.schema[placeholder]; exists {
-		p.storeResultWithPosition(placeholder, packages.VariableTypePositionalArg, metadata, p.positionalCount)
+		p.storeResultWithPosition(placeholder, packages.VariableTypeArgPositional, metadata, p.positionalCount)
 	}
 }
 

internal/provider/mcpm/registry.go

@@ -423,10 +423,7 @@ func convertInstallations(
 
 		details[rt] = packages.Installation{
 			Command:     install.Command,
-			Args:        slices.Clone(install.Args),
 			Package:     pkg,
-			Version:     "latest", // MCPM doesn't support versions, so everything is 'latest'
-			Env:         maps.Clone(install.Env),
 			Description: install.Description,
 			Recommended: install.Recommended,
 			Deprecated:  false,                        // MCPM doesn't support deprecated installations
@@ -443,11 +440,6 @@ func (t Tool) ToDomainType() (packages.Tool, error) {
 		Name:        t.Name,
 		Title:       t.Title,
 		Description: t.Description,
-		InputSchema: packages.JSONSchema{
-			Type:       t.InputSchema.Type,
-			Properties: t.InputSchema.Properties,
-			Required:   t.InputSchema.Required,
-		},
 	}, nil
 }