refactor: update Kind field to Type in source code

CONTRIBUTING.md

@@ -92,11 +92,11 @@ implementation](https://github.com/googleapis/genai-toolbox/blob/main/internal/s
   `newdb.go`. Create a `Config` struct to include all the necessary parameters
   for connecting to the database (e.g., host, port, username, password, database
   name) and a `Source` struct to store necessary parameters for tools (e.g.,
-  Name, Kind, connection object, additional config).
+  Name, Type, connection object, additional config).
 * **Implement the
   [`SourceConfig`](https://github.com/googleapis/genai-toolbox/blob/fd300dc606d88bf9f7bba689e2cee4e3565537dd/internal/sources/sources.go#L57)
   interface**. This interface requires two methods:
-  * `SourceConfigKind() string`: Returns a unique string identifier for your
+  * `SourceConfigType() string`: Returns a unique string identifier for your
     data source (e.g., `"newdb"`).
   * `Initialize(ctx context.Context, tracer trace.Tracer) (Source, error)`:
     Creates a new instance of your data source and establishes a connection to
@@ -104,7 +104,7 @@ implementation](https://github.com/googleapis/genai-toolbox/blob/main/internal/s
 * **Implement the
   [`Source`](https://github.com/googleapis/genai-toolbox/blob/fd300dc606d88bf9f7bba689e2cee4e3565537dd/internal/sources/sources.go#L63)
   interface**. This interface requires one method:
-  * `SourceKind() string`: Returns the same string identifier as `SourceConfigKind()`.
+  * `SourceType() string`: Returns the same string identifier as `SourceConfigType()`.
 * **Implement `init()`** to register the new Source.
 * **Implement Unit Tests** in a file named `newdb_test.go`.
 
@@ -126,7 +126,7 @@ tools.
 * **Implement the
   [`ToolConfig`](https://github.com/googleapis/genai-toolbox/blob/fd300dc606d88bf9f7bba689e2cee4e3565537dd/internal/tools/tools.go#L61)
   interface**. This interface requires one method:
-  * `ToolConfigKind() string`: Returns a unique string identifier for your tool
+  * `ToolConfigType() string`: Returns a unique string identifier for your tool
     (e.g., `"newdb-tool"`).
   * `Initialize(sources map[string]Source) (Tool, error)`: Creates a new
     instance of your tool and validates that it can connect to the specified
@@ -243,7 +243,7 @@ resources.
   | style           | Update src code, with only formatting and whitespace updates (e.g. code formatter or linter changes). |
 
   Pull requests should always add scope whenever possible. The scope is
-  formatted as `<scope-type>/<scope-kind>` (e.g., `sources/postgres`, or
+  formatted as `<scope-resource>/<scope-type>` (e.g., `sources/postgres`, or
   `tools/mssql-sql`).
   
   Ideally, **each PR covers only one scope**, if this is

README.md

@@ -954,7 +954,7 @@ For more details on configuring different types of sources, see the
 ### Tools
 
 The `tools` section of a `tools.yaml` define the actions an agent can take: what
-kind of tool it is, which source(s) it affects, what parameters it uses, etc.
+type of tool it is, which source(s) it affects, what parameters it uses, etc.
 
 ```yaml
 tools:

cmd/root_test.go

@@ -535,7 +535,7 @@ func TestParseToolFile(t *testing.T) {
 				Sources: server.SourceConfigs{
 					"my-pg-instance": cloudsqlpgsrc.Config{
 						Name:     "my-pg-instance",
-						Kind:     cloudsqlpgsrc.SourceKind,
+						Type:     cloudsqlpgsrc.SourceType,
 						Project:  "my-project",
 						Region:   "my-region",
 						Instance: "my-instance",
@@ -548,7 +548,7 @@ func TestParseToolFile(t *testing.T) {
 				Tools: server.ToolConfigs{
 					"example_tool": postgressql.Config{
 						Name:        "example_tool",
-						Kind:        "postgres-sql",
+						Type:        "postgres-sql",
 						Source:      "my-pg-instance",
 						Description: "some description",
 						Statement:   "SELECT * FROM SQL_STATEMENT;\n",
@@ -689,7 +689,7 @@ func TestParseToolFileWithAuth(t *testing.T) {
 				Sources: server.SourceConfigs{
 					"my-pg-instance": cloudsqlpgsrc.Config{
 						Name:     "my-pg-instance",
-						Kind:     cloudsqlpgsrc.SourceKind,
+						Type:     cloudsqlpgsrc.SourceType,
 						Project:  "my-project",
 						Region:   "my-region",
 						Instance: "my-instance",
@@ -702,19 +702,19 @@ func TestParseToolFileWithAuth(t *testing.T) {
 				AuthServices: server.AuthServiceConfigs{
 					"my-google-service": google.Config{
 						Name:     "my-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "my-client-id",
 					},
 					"other-google-service": google.Config{
 						Name:     "other-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "other-client-id",
 					},
 				},
 				Tools: server.ToolConfigs{
 					"example_tool": postgressql.Config{
 						Name:         "example_tool",
-						Kind:         "postgres-sql",
+						Type:         "postgres-sql",
 						Source:       "my-pg-instance",
 						Description:  "some description",
 						Statement:    "SELECT * FROM SQL_STATEMENT;\n",
@@ -789,7 +789,7 @@ func TestParseToolFileWithAuth(t *testing.T) {
 				Sources: server.SourceConfigs{
 					"my-pg-instance": cloudsqlpgsrc.Config{
 						Name:     "my-pg-instance",
-						Kind:     cloudsqlpgsrc.SourceKind,
+						Type:     cloudsqlpgsrc.SourceType,
 						Project:  "my-project",
 						Region:   "my-region",
 						Instance: "my-instance",
@@ -802,19 +802,19 @@ func TestParseToolFileWithAuth(t *testing.T) {
 				AuthSources: server.AuthServiceConfigs{
 					"my-google-service": google.Config{
 						Name:     "my-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "my-client-id",
 					},
 					"other-google-service": google.Config{
 						Name:     "other-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "other-client-id",
 					},
 				},
 				Tools: server.ToolConfigs{
 					"example_tool": postgressql.Config{
 						Name:         "example_tool",
-						Kind:         "postgres-sql",
+						Type:         "postgres-sql",
 						Source:       "my-pg-instance",
 						Description:  "some description",
 						Statement:    "SELECT * FROM SQL_STATEMENT;\n",
@@ -891,7 +891,7 @@ func TestParseToolFileWithAuth(t *testing.T) {
 				Sources: server.SourceConfigs{
 					"my-pg-instance": cloudsqlpgsrc.Config{
 						Name:     "my-pg-instance",
-						Kind:     cloudsqlpgsrc.SourceKind,
+						Type:     cloudsqlpgsrc.SourceType,
 						Project:  "my-project",
 						Region:   "my-region",
 						Instance: "my-instance",
@@ -904,19 +904,19 @@ func TestParseToolFileWithAuth(t *testing.T) {
 				AuthServices: server.AuthServiceConfigs{
 					"my-google-service": google.Config{
 						Name:     "my-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "my-client-id",
 					},
 					"other-google-service": google.Config{
 						Name:     "other-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "other-client-id",
 					},
 				},
 				Tools: server.ToolConfigs{
 					"example_tool": postgressql.Config{
 						Name:         "example_tool",
-						Kind:         "postgres-sql",
+						Type:         "postgres-sql",
 						Source:       "my-pg-instance",
 						Description:  "some description",
 						Statement:    "SELECT * FROM SQL_STATEMENT;\n",
@@ -1062,7 +1062,7 @@ func TestEnvVarReplacement(t *testing.T) {
 				Sources: server.SourceConfigs{
 					"my-http-instance": httpsrc.Config{
 						Name:           "my-http-instance",
-						Kind:           httpsrc.SourceKind,
+						Type:           httpsrc.SourceType,
 						BaseURL:        "http://test_server/",
 						Timeout:        "10s",
 						DefaultHeaders: map[string]string{"Authorization": "ACTUAL_HEADER"},
@@ -1072,19 +1072,19 @@ func TestEnvVarReplacement(t *testing.T) {
 				AuthServices: server.AuthServiceConfigs{
 					"my-google-service": google.Config{
 						Name:     "my-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "ACTUAL_CLIENT_ID",
 					},
 					"other-google-service": google.Config{
 						Name:     "other-google-service",
-						Kind:     google.AuthServiceKind,
+						Type:     google.AuthServiceType,
 						ClientID: "ACTUAL_CLIENT_ID_2",
 					},
 				},
 				Tools: server.ToolConfigs{
 					"example_tool": http.Config{
 						Name:         "example_tool",
-						Kind:         "http",
+						Type:         "http",
 						Source:       "my-instance",
 						Method:       "GET",
 						Path:         "search?name=alice&pet=cat",

docs/en/how-to/connect_via_mcp.md

@@ -20,7 +20,6 @@ The native SDKs can be combined with MCP clients in many cases.
 
 Toolbox currently supports the following versions of MCP specification:
 
-* [2025-11-25](https://modelcontextprotocol.io/specification/2025-11-25)
 * [2025-06-18](https://modelcontextprotocol.io/specification/2025-06-18)
 * [2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26)
 * [2024-11-05](https://modelcontextprotocol.io/specification/2024-11-05)

docs/en/resources/tools/cloudgda/cloud-gda-query.md

@@ -41,13 +41,13 @@ tools:
 
 ### Usage Flow
 
-When using this tool, a `query` parameter containing a natural language query is provided to the tool (typically by an agent). The tool then interacts with the Gemini Data Analytics API using the context defined in your configuration.
+When using this tool, a `prompt` parameter containing a natural language query is provided to the tool (typically by an agent). The tool then interacts with the Gemini Data Analytics API using the context defined in your configuration.
 
 The structure of the response depends on the `generationOptions` configured in your tool definition (e.g., enabling `generateQueryResult` will include the SQL query results).
 
 See [Data Analytics API REST documentation](https://clouddocs.devsite.corp.google.com/gemini/docs/conversational-analytics-api/reference/rest/v1alpha/projects.locations/queryData?rep_location=global) for details.
 
-**Example Input Query:**
+**Example Input Prompt:**
 
 ```text
 How many accounts who have region in Prague are eligible for loans? A3 contains the data of region.

internal/auth/auth.go

@@ -21,13 +21,13 @@ import (
 
 // AuthServiceConfig is the interface for configuring authentication services.
 type AuthServiceConfig interface {
-	AuthServiceConfigKind() string
+	AuthServiceConfigType() string
 	Initialize() (AuthService, error)
 }
 
 // AuthService is the interface for authentication services.
 type AuthService interface {
-	AuthServiceKind() string
+	AuthServiceType() string
 	GetName() string
 	GetClaimsFromHeader(context.Context, http.Header) (map[string]any, error)
 	ToConfig() AuthServiceConfig

internal/auth/google/google.go

@@ -23,7 +23,7 @@ import (
 	"google.golang.org/api/idtoken"
 )
 
-const AuthServiceKind string = "google"
+const AuthServiceType string = "google"
 
 // validate interface
 var _ auth.AuthServiceConfig = Config{}
@@ -31,13 +31,13 @@ var _ auth.AuthServiceConfig = Config{}
 // Auth service configuration
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	ClientID string `yaml:"clientId" validate:"required"`
 }
 
-// Returns the auth service kind
-func (cfg Config) AuthServiceConfigKind() string {
-	return AuthServiceKind
+// Returns the auth service type
+func (cfg Config) AuthServiceConfigType() string {
+	return AuthServiceType
 }
 
 // Initialize a Google auth service
@@ -55,9 +55,9 @@ type AuthService struct {
 	Config
 }
 
-// Returns the auth service kind
-func (a AuthService) AuthServiceKind() string {
-	return AuthServiceKind
+// Returns the auth service type
+func (a AuthService) AuthServiceType() string {
+	return AuthServiceType
 }
 
 func (a AuthService) ToConfig() auth.AuthServiceConfig {

internal/embeddingmodels/embeddingmodels.go

@@ -22,12 +22,12 @@ import (
 
 // EmbeddingModelConfig is the interface for configuring embedding models.
 type EmbeddingModelConfig interface {
-	EmbeddingModelConfigKind() string
+	EmbeddingModelConfigType() string
 	Initialize(context.Context) (EmbeddingModel, error)
 }
 
 type EmbeddingModel interface {
-	EmbeddingModelKind() string
+	EmbeddingModelType() string
 	ToConfig() EmbeddingModelConfig
 	EmbedParameters(context.Context, []string) ([][]float32, error)
 }

internal/embeddingmodels/gemini/gemini.go

@@ -23,22 +23,22 @@ import (
 	"google.golang.org/genai"
 )
 
-const EmbeddingModelKind string = "gemini"
+const EmbeddingModelType string = "gemini"
 
 // validate interface
 var _ embeddingmodels.EmbeddingModelConfig = Config{}
 
 type Config struct {
 	Name      string `yaml:"name" validate:"required"`
-	Kind      string `yaml:"kind" validate:"required"`
+	Type      string `yaml:"kind" validate:"required"`
 	Model     string `yaml:"model" validate:"required"`
 	ApiKey    string `yaml:"apiKey"`
 	Dimension int32  `yaml:"dimension"`
 }
 
-// Returns the embedding model kind
-func (cfg Config) EmbeddingModelConfigKind() string {
-	return EmbeddingModelKind
+// Returns the embedding model type
+func (cfg Config) EmbeddingModelConfigType() string {
+	return EmbeddingModelType
 }
 
 // Initialize a Gemini embedding model
@@ -69,9 +69,9 @@ type EmbeddingModel struct {
 	Config
 }
 
-// Returns the embedding model kind
-func (m EmbeddingModel) EmbeddingModelKind() string {
-	return EmbeddingModelKind
+// Returns the embedding model type
+func (m EmbeddingModel) EmbeddingModelType() string {
+	return EmbeddingModelType
 }
 
 func (m EmbeddingModel) ToConfig() embeddingmodels.EmbeddingModelConfig {

internal/embeddingmodels/gemini/gemini_test.go

@@ -42,7 +42,7 @@ func TestParseFromYamlGemini(t *testing.T) {
 			want: map[string]embeddingmodels.EmbeddingModelConfig{
 				"my-gemini-model": gemini.Config{
 					Name:  "my-gemini-model",
-					Kind:  gemini.EmbeddingModelKind,
+					Type:  gemini.EmbeddingModelType,
 					Model: "text-embedding-004",
 				},
 			},
@@ -60,7 +60,7 @@ func TestParseFromYamlGemini(t *testing.T) {
 			want: map[string]embeddingmodels.EmbeddingModelConfig{
 				"complex-gemini": gemini.Config{
 					Name:      "complex-gemini",
-					Kind:      gemini.EmbeddingModelKind,
+					Type:      gemini.EmbeddingModelType,
 					Model:     "text-embedding-004",
 					ApiKey:    "test-api-key",
 					Dimension: 768,

internal/prompts/custom/custom.go

@@ -27,10 +27,10 @@ type Message = prompts.Message
 
 const kind = "custom"
 
-// init registers this prompt kind with the prompt framework.
+// init registers this prompt type with the prompt framework.
 func init() {
 	if !prompts.Register(kind, newConfig) {
-		panic(fmt.Sprintf("prompt kind %q already registered", kind))
+		panic(fmt.Sprintf("prompt type %q already registered", kind))
 	}
 }
 
@@ -56,7 +56,7 @@ type Config struct {
 var _ prompts.PromptConfig = Config{}
 var _ prompts.Prompt = Prompt{}
 
-func (c Config) PromptConfigKind() string {
+func (c Config) PromptConfigType() string {
 	return kind
 }
 

internal/prompts/custom/custom_test.go

@@ -50,8 +50,8 @@ func TestConfig(t *testing.T) {
 	if p == nil {
 		t.Fatal("Initialize() returned a nil prompt")
 	}
-	if cfg.PromptConfigKind() != "custom" {
-		t.Errorf("PromptConfigKind() = %q, want %q", cfg.PromptConfigKind(), "custom")
+	if cfg.PromptConfigType() != "custom" {
+		t.Errorf("PromptConfigType() = %q, want %q", cfg.PromptConfigType(), "custom")
 	}
 
 	t.Run("Manifest", func(t *testing.T) {

internal/prompts/prompts.go

@@ -52,7 +52,7 @@ func DecodeConfig(ctx context.Context, kind, name string, decoder *yaml.Decoder)
 	}
 
 	if !found {
-		return nil, fmt.Errorf("unknown prompt kind: %q", kind)
+		return nil, fmt.Errorf("unknown prompt type: %q", kind)
 	}
 
 	promptConfig, err := factory(ctx, name, decoder)
@@ -63,7 +63,7 @@ func DecodeConfig(ctx context.Context, kind, name string, decoder *yaml.Decoder)
 }
 
 type PromptConfig interface {
-	PromptConfigKind() string
+	PromptConfigType() string
 	Initialize() (Prompt, error)
 }
 

internal/prompts/prompts_test.go

@@ -29,16 +29,16 @@ import (
 
 type mockPromptConfig struct {
 	name string
-	kind string
+	Type string
 }
 
-func (m *mockPromptConfig) PromptConfigKind() string            { return m.kind }
+func (m *mockPromptConfig) PromptConfigType() string            { return m.Type }
 func (m *mockPromptConfig) Initialize() (prompts.Prompt, error) { return nil, nil }
 
 var errMockFactory = errors.New("mock factory error")
 
 func mockFactory(ctx context.Context, name string, decoder *yaml.Decoder) (prompts.PromptConfig, error) {
-	return &mockPromptConfig{name: name, kind: "mockKind"}, nil
+	return &mockPromptConfig{name: name, Type: "mockType"}, nil
 }
 
 func mockErrorFactory(ctx context.Context, name string, decoder *yaml.Decoder) (prompts.PromptConfig, error) {
@@ -50,7 +50,7 @@ func TestRegistry(t *testing.T) {
 	ctx := context.Background()
 
 	t.Run("RegisterAndDecodeSuccess", func(t *testing.T) {
-		kind := "testKindSuccess"
+		kind := "testTypeSuccess"
 		if !prompts.Register(kind, mockFactory) {
 			t.Fatal("expected registration to succeed")
 		}
@@ -69,19 +69,19 @@ func TestRegistry(t *testing.T) {
 		}
 	})
 
-	t.Run("DecodeUnknownKind", func(t *testing.T) {
+	t.Run("DecodeUnknownType", func(t *testing.T) {
 		decoder := yaml.NewDecoder(strings.NewReader(""))
-		_, err := prompts.DecodeConfig(ctx, "unregisteredKind", "testPrompt", decoder)
+		_, err := prompts.DecodeConfig(ctx, "unregisteredType", "testPrompt", decoder)
 		if err == nil {
 			t.Fatal("expected an error for unknown kind, but got nil")
 		}
-		if !strings.Contains(err.Error(), "unknown prompt kind") {
-			t.Errorf("expected error to contain 'unknown prompt kind', but got: %v", err)
+		if !strings.Contains(err.Error(), "unknown prompt type") {
+			t.Errorf("expected error to contain 'unknown prompt type', but got: %v", err)
 		}
 	})
 
 	t.Run("FactoryReturnsError", func(t *testing.T) {
-		kind := "testKindError"
+		kind := "testTypeError"
 		if !prompts.Register(kind, mockErrorFactory) {
 			t.Fatal("expected registration to succeed")
 		}
@@ -105,8 +105,8 @@ func TestRegistry(t *testing.T) {
 		if config == nil {
 			t.Fatal("expected a non-nil config for default kind")
 		}
-		if config.PromptConfigKind() != "custom" {
-			t.Errorf("expected default kind to be 'custom', but got %q", config.PromptConfigKind())
+		if config.PromptConfigType() != "custom" {
+			t.Errorf("expected default kind to be 'custom', but got %q", config.PromptConfigType())
 		}
 	})
 }

internal/server/config.go

@@ -198,7 +198,7 @@ func (c *AuthServiceConfigs) UnmarshalYAML(ctx context.Context, unmarshal func(i
 			return fmt.Errorf("error creating decoder: %w", err)
 		}
 		switch kind {
-		case google.AuthServiceKind:
+		case google.AuthServiceType:
 			actual := google.Config{Name: name}
 			if err := dec.DecodeContext(ctx, &actual); err != nil {
 				return fmt.Errorf("unable to parse as %q: %w", kind, err)
@@ -242,7 +242,7 @@ func (c *EmbeddingModelConfigs) UnmarshalYAML(ctx context.Context, unmarshal fun
 			return fmt.Errorf("error creating decoder: %w", err)
 		}
 		switch kind {
-		case gemini.EmbeddingModelKind:
+		case gemini.EmbeddingModelType:
 			actual := gemini.Config{Name: name}
 			if err := dec.DecodeContext(ctx, &actual); err != nil {
 				return fmt.Errorf("unable to parse as %q: %w", kind, err)

internal/server/mcp/mcp.go

@@ -27,21 +27,19 @@ import (
 	v20241105 "github.com/googleapis/genai-toolbox/internal/server/mcp/v20241105"
 	v20250326 "github.com/googleapis/genai-toolbox/internal/server/mcp/v20250326"
 	v20250618 "github.com/googleapis/genai-toolbox/internal/server/mcp/v20250618"
-	v20251125 "github.com/googleapis/genai-toolbox/internal/server/mcp/v20251125"
 	"github.com/googleapis/genai-toolbox/internal/server/resources"
 	"github.com/googleapis/genai-toolbox/internal/tools"
 )
 
 // LATEST_PROTOCOL_VERSION is the latest version of the MCP protocol supported.
 // Update the version used in InitializeResponse when this value is updated.
-const LATEST_PROTOCOL_VERSION = v20251125.PROTOCOL_VERSION
+const LATEST_PROTOCOL_VERSION = v20250618.PROTOCOL_VERSION
 
 // SUPPORTED_PROTOCOL_VERSIONS is the MCP protocol versions that are supported.
 var SUPPORTED_PROTOCOL_VERSIONS = []string{
 	v20241105.PROTOCOL_VERSION,
 	v20250326.PROTOCOL_VERSION,
 	v20250618.PROTOCOL_VERSION,
-	v20251125.PROTOCOL_VERSION,
 }
 
 // InitializeResponse runs capability negotiation and protocol version agreement.
@@ -104,8 +102,6 @@ func NotificationHandler(ctx context.Context, body []byte) error {
 // This is the Operation phase of the lifecycle for MCP client-server connections.
 func ProcessMethod(ctx context.Context, mcpVersion string, id jsonrpc.RequestId, method string, toolset tools.Toolset, promptset prompts.Promptset, resourceMgr *resources.ResourceManager, body []byte, header http.Header) (any, error) {
 	switch mcpVersion {
-	case v20251125.PROTOCOL_VERSION:
-		return v20251125.ProcessMethod(ctx, id, method, toolset, promptset, resourceMgr, body, header)
 	case v20250618.PROTOCOL_VERSION:
 		return v20250618.ProcessMethod(ctx, id, method, toolset, promptset, resourceMgr, body, header)
 	case v20250326.PROTOCOL_VERSION:

internal/server/mcp/v20251125/method.go

@@ -1,326 +0,0 @@
-// Copyright 2026 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package v20251125
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/googleapis/genai-toolbox/internal/prompts"
-	"github.com/googleapis/genai-toolbox/internal/server/mcp/jsonrpc"
-	"github.com/googleapis/genai-toolbox/internal/server/resources"
-	"github.com/googleapis/genai-toolbox/internal/tools"
-	"github.com/googleapis/genai-toolbox/internal/util"
-)
-
-// ProcessMethod returns a response for the request.
-func ProcessMethod(ctx context.Context, id jsonrpc.RequestId, method string, toolset tools.Toolset, promptset prompts.Promptset, resourceMgr *resources.ResourceManager, body []byte, header http.Header) (any, error) {
-	switch method {
-	case PING:
-		return pingHandler(id)
-	case TOOLS_LIST:
-		return toolsListHandler(id, toolset, body)
-	case TOOLS_CALL:
-		return toolsCallHandler(ctx, id, resourceMgr, body, header)
-	case PROMPTS_LIST:
-		return promptsListHandler(ctx, id, promptset, body)
-	case PROMPTS_GET:
-		return promptsGetHandler(ctx, id, resourceMgr, body)
-	default:
-		err := fmt.Errorf("invalid method %s", method)
-		return jsonrpc.NewError(id, jsonrpc.METHOD_NOT_FOUND, err.Error(), nil), err
-	}
-}
-
-// pingHandler handles the "ping" method by returning an empty response.
-func pingHandler(id jsonrpc.RequestId) (any, error) {
-	return jsonrpc.JSONRPCResponse{
-		Jsonrpc: jsonrpc.JSONRPC_VERSION,
-		Id:      id,
-		Result:  struct{}{},
-	}, nil
-}
-
-func toolsListHandler(id jsonrpc.RequestId, toolset tools.Toolset, body []byte) (any, error) {
-	var req ListToolsRequest
-	if err := json.Unmarshal(body, &req); err != nil {
-		err = fmt.Errorf("invalid mcp tools list request: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, err.Error(), nil), err
-	}
-
-	result := ListToolsResult{
-		Tools: toolset.McpManifest,
-	}
-	return jsonrpc.JSONRPCResponse{
-		Jsonrpc: jsonrpc.JSONRPC_VERSION,
-		Id:      id,
-		Result:  result,
-	}, nil
-}
-
-// toolsCallHandler generate a response for tools call.
-func toolsCallHandler(ctx context.Context, id jsonrpc.RequestId, resourceMgr *resources.ResourceManager, body []byte, header http.Header) (any, error) {
-	authServices := resourceMgr.GetAuthServiceMap()
-
-	// retrieve logger from context
-	logger, err := util.LoggerFromContext(ctx)
-	if err != nil {
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-	}
-
-	var req CallToolRequest
-	if err = json.Unmarshal(body, &req); err != nil {
-		err = fmt.Errorf("invalid mcp tools call request: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, err.Error(), nil), err
-	}
-
-	toolName := req.Params.Name
-	toolArgument := req.Params.Arguments
-	logger.DebugContext(ctx, fmt.Sprintf("tool name: %s", toolName))
-	tool, ok := resourceMgr.GetTool(toolName)
-	if !ok {
-		err = fmt.Errorf("invalid tool name: tool with name %q does not exist", toolName)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_PARAMS, err.Error(), nil), err
-	}
-
-	// Get access token
-	authTokenHeadername, err := tool.GetAuthTokenHeaderName(resourceMgr)
-	if err != nil {
-		errMsg := fmt.Errorf("error during invocation: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, errMsg.Error(), nil), errMsg
-	}
-	accessToken := tools.AccessToken(header.Get(authTokenHeadername))
-
-	// Check if this specific tool requires the standard authorization header
-	clientAuth, err := tool.RequiresClientAuthorization(resourceMgr)
-	if err != nil {
-		errMsg := fmt.Errorf("error during invocation: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, errMsg.Error(), nil), errMsg
-	}
-	if clientAuth {
-		if accessToken == "" {
-			return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, "missing access token in the 'Authorization' header", nil), util.ErrUnauthorized
-		}
-	}
-
-	// marshal arguments and decode it using decodeJSON instead to prevent loss between floats/int.
-	aMarshal, err := json.Marshal(toolArgument)
-	if err != nil {
-		err = fmt.Errorf("unable to marshal tools argument: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-	}
-
-	var data map[string]any
-	if err = util.DecodeJSON(bytes.NewBuffer(aMarshal), &data); err != nil {
-		err = fmt.Errorf("unable to decode tools argument: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-	}
-
-	// Tool authentication
-	// claimsFromAuth maps the name of the authservice to the claims retrieved from it.
-	claimsFromAuth := make(map[string]map[string]any)
-
-	// if using stdio, header will be nil and auth will not be supported
-	if header != nil {
-		for _, aS := range authServices {
-			claims, err := aS.GetClaimsFromHeader(ctx, header)
-			if err != nil {
-				logger.DebugContext(ctx, err.Error())
-				continue
-			}
-			if claims == nil {
-				// authService not present in header
-				continue
-			}
-			claimsFromAuth[aS.GetName()] = claims
-		}
-	}
-
-	// Tool authorization check
-	verifiedAuthServices := make([]string, len(claimsFromAuth))
-	i := 0
-	for k := range claimsFromAuth {
-		verifiedAuthServices[i] = k
-		i++
-	}
-
-	// Check if any of the specified auth services is verified
-	isAuthorized := tool.Authorized(verifiedAuthServices)
-	if !isAuthorized {
-		err = fmt.Errorf("unauthorized Tool call: Please make sure your specify correct auth headers: %w", util.ErrUnauthorized)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, err.Error(), nil), err
-	}
-	logger.DebugContext(ctx, "tool invocation authorized")
-
-	params, err := tool.ParseParams(data, claimsFromAuth)
-	if err != nil {
-		err = fmt.Errorf("provided parameters were invalid: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_PARAMS, err.Error(), nil), err
-	}
-	logger.DebugContext(ctx, fmt.Sprintf("invocation params: %s", params))
-
-	// run tool invocation and generate response.
-	results, err := tool.Invoke(ctx, resourceMgr, params, accessToken)
-	if err != nil {
-		errStr := err.Error()
-		// Missing authService tokens.
-		if errors.Is(err, util.ErrUnauthorized) {
-			return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, err.Error(), nil), err
-		}
-		// Upstream auth error
-		if strings.Contains(errStr, "Error 401") || strings.Contains(errStr, "Error 403") {
-			if clientAuth {
-				// Error with client credentials should pass down to the client
-				return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, err.Error(), nil), err
-			}
-			// Auth error with ADC should raise internal 500 error
-			return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-		}
-		text := TextContent{
-			Type: "text",
-			Text: err.Error(),
-		}
-		return jsonrpc.JSONRPCResponse{
-			Jsonrpc: jsonrpc.JSONRPC_VERSION,
-			Id:      id,
-			Result:  CallToolResult{Content: []TextContent{text}, IsError: true},
-		}, nil
-	}
-
-	content := make([]TextContent, 0)
-
-	sliceRes, ok := results.([]any)
-	if !ok {
-		sliceRes = []any{results}
-	}
-
-	for _, d := range sliceRes {
-		text := TextContent{Type: "text"}
-		dM, err := json.Marshal(d)
-		if err != nil {
-			text.Text = fmt.Sprintf("fail to marshal: %s, result: %s", err, d)
-		} else {
-			text.Text = string(dM)
-		}
-		content = append(content, text)
-	}
-
-	return jsonrpc.JSONRPCResponse{
-		Jsonrpc: jsonrpc.JSONRPC_VERSION,
-		Id:      id,
-		Result:  CallToolResult{Content: content},
-	}, nil
-}
-
-// promptsListHandler handles the "prompts/list" method.
-func promptsListHandler(ctx context.Context, id jsonrpc.RequestId, promptset prompts.Promptset, body []byte) (any, error) {
-	// retrieve logger from context
-	logger, err := util.LoggerFromContext(ctx)
-	if err != nil {
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-	}
-	logger.DebugContext(ctx, "handling prompts/list request")
-
-	var req ListPromptsRequest
-	if err := json.Unmarshal(body, &req); err != nil {
-		err = fmt.Errorf("invalid mcp prompts list request: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, err.Error(), nil), err
-	}
-
-	result := ListPromptsResult{
-		Prompts: promptset.McpManifest,
-	}
-	logger.DebugContext(ctx, fmt.Sprintf("returning %d prompts", len(promptset.McpManifest)))
-	return jsonrpc.JSONRPCResponse{
-		Jsonrpc: jsonrpc.JSONRPC_VERSION,
-		Id:      id,
-		Result:  result,
-	}, nil
-}
-
-// promptsGetHandler handles the "prompts/get" method.
-func promptsGetHandler(ctx context.Context, id jsonrpc.RequestId, resourceMgr *resources.ResourceManager, body []byte) (any, error) {
-	// retrieve logger from context
-	logger, err := util.LoggerFromContext(ctx)
-	if err != nil {
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-	}
-	logger.DebugContext(ctx, "handling prompts/get request")
-
-	var req GetPromptRequest
-	if err := json.Unmarshal(body, &req); err != nil {
-		err = fmt.Errorf("invalid mcp prompts/get request: %w", err)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_REQUEST, err.Error(), nil), err
-	}
-
-	promptName := req.Params.Name
-	logger.DebugContext(ctx, fmt.Sprintf("prompt name: %s", promptName))
-	prompt, ok := resourceMgr.GetPrompt(promptName)
-	if !ok {
-		err := fmt.Errorf("prompt with name %q does not exist", promptName)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_PARAMS, err.Error(), nil), err
-	}
-
-	// Parse the arguments provided in the request.
-	argValues, err := prompt.ParseArgs(req.Params.Arguments, nil)
-	if err != nil {
-		err = fmt.Errorf("invalid arguments for prompt %q: %w", promptName, err)
-		return jsonrpc.NewError(id, jsonrpc.INVALID_PARAMS, err.Error(), nil), err
-	}
-	logger.DebugContext(ctx, fmt.Sprintf("parsed args: %v", argValues))
-
-	// Substitute the argument values into the prompt's messages.
-	substituted, err := prompt.SubstituteParams(argValues)
-	if err != nil {
-		err = fmt.Errorf("error substituting params for prompt %q: %w", promptName, err)
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-	}
-
-	// Cast the result to the expected []prompts.Message type.
-	substitutedMessages, ok := substituted.([]prompts.Message)
-	if !ok {
-		err = fmt.Errorf("internal error: SubstituteParams returned unexpected type")
-		return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err
-	}
-	logger.DebugContext(ctx, "substituted params successfully")
-
-	// Format the response messages into the required structure.
-	promptMessages := make([]PromptMessage, len(substitutedMessages))
-	for i, msg := range substitutedMessages {
-		promptMessages[i] = PromptMessage{
-			Role: msg.Role,
-			Content: TextContent{
-				Type: "text",
-				Text: msg.Content,
-			},
-		}
-	}
-
-	result := GetPromptResult{
-		Description: prompt.Manifest().Description,
-		Messages:    promptMessages,
-	}
-
-	return jsonrpc.JSONRPCResponse{
-		Jsonrpc: jsonrpc.JSONRPC_VERSION,
-		Id:      id,
-		Result:  result,
-	}, nil
-}

internal/server/mcp/v20251125/types.go

@@ -1,219 +0,0 @@
-// Copyright 2026 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package v20251125
-
-import (
-	"github.com/googleapis/genai-toolbox/internal/prompts"
-	"github.com/googleapis/genai-toolbox/internal/server/mcp/jsonrpc"
-	"github.com/googleapis/genai-toolbox/internal/tools"
-)
-
-// SERVER_NAME is the server name used in Implementation.
-const SERVER_NAME = "Toolbox"
-
-// PROTOCOL_VERSION is the version of the MCP protocol in this package.
-const PROTOCOL_VERSION = "2025-11-25"
-
-// methods that are supported.
-const (
-	PING         = "ping"
-	TOOLS_LIST   = "tools/list"
-	TOOLS_CALL   = "tools/call"
-	PROMPTS_LIST = "prompts/list"
-	PROMPTS_GET  = "prompts/get"
-)
-
-/* Empty result */
-
-// EmptyResult represents a response that indicates success but carries no data.
-type EmptyResult jsonrpc.Result
-
-/* Pagination */
-
-// Cursor is an opaque token used to represent a cursor for pagination.
-type Cursor string
-
-type PaginatedRequest struct {
-	jsonrpc.Request
-	Params struct {
-		// An opaque token representing the current pagination position.
-		// If provided, the server should return results starting after this cursor.
-		Cursor Cursor `json:"cursor,omitempty"`
-	} `json:"params,omitempty"`
-}
-
-type PaginatedResult struct {
-	jsonrpc.Result
-	// An opaque token representing the pagination position after the last returned result.
-	// If present, there may be more results available.
-	NextCursor Cursor `json:"nextCursor,omitempty"`
-}
-
-/* Tools */
-
-// Sent from the client to request a list of tools the server has.
-type ListToolsRequest struct {
-	PaginatedRequest
-}
-
-// The server's response to a tools/list request from the client.
-type ListToolsResult struct {
-	PaginatedResult
-	Tools []tools.McpManifest `json:"tools"`
-}
-
-// Used by the client to invoke a tool provided by the server.
-type CallToolRequest struct {
-	jsonrpc.Request
-	Params struct {
-		Name      string         `json:"name"`
-		Arguments map[string]any `json:"arguments,omitempty"`
-	} `json:"params,omitempty"`
-}
-
-// The sender or recipient of messages and data in a conversation.
-type Role string
-
-const (
-	RoleUser      Role = "user"
-	RoleAssistant Role = "assistant"
-)
-
-// Base for objects that include optional annotations for the client.
-// The client can use annotations to inform how objects are used or displayed
-type Annotated struct {
-	Annotations *struct {
-		// Describes who the intended customer of this object or data is.
-		// It can include multiple entries to indicate content useful for multiple
-		// audiences (e.g., `["user", "assistant"]`).
-		Audience []Role `json:"audience,omitempty"`
-		// Describes how important this data is for operating the server.
-		//
-		// A value of 1 means "most important," and indicates that the data is
-		// effectively required, while 0 means "least important," and indicates that
-		// the data is entirely optional.
-		//
-		// @TJS-type number
-		// @minimum 0
-		// @maximum 1
-		Priority float64 `json:"priority,omitempty"`
-	} `json:"annotations,omitempty"`
-}
-
-// TextContent represents text provided to or from an LLM.
-type TextContent struct {
-	Annotated
-	Type string `json:"type"`
-	// The text content of the message.
-	Text string `json:"text"`
-}
-
-// The server's response to a tool call.
-//
-// Any errors that originate from the tool SHOULD be reported inside the result
-// object, with `isError` set to true, _not_ as an MCP protocol-level error
-// response. Otherwise, the LLM would not be able to see that an error occurred
-// and self-correct.
-//
-// However, any errors in _finding_ the tool, an error indicating that the
-// server does not support tool calls, or any other exceptional conditions,
-// should be reported as an MCP error response.
-type CallToolResult struct {
-	jsonrpc.Result
-	// Could be either a TextContent, ImageContent, or EmbeddedResources
-	// For Toolbox, we will only be sending TextContent
-	Content []TextContent `json:"content"`
-	// Whether the tool call ended in an error.
-	// If not set, this is assumed to be false (the call was successful).
-	//
-	// Any errors that originate from the tool SHOULD be reported inside the result
-	// object, with `isError` set to true, _not_ as an MCP protocol-level error
-	// response. Otherwise, the LLM would not be able to see that an error occurred
-	// and self-correct.
-	//
-	// However, any errors in _finding_ the tool, an error indicating that the
-	// server does not support tool calls, or any other exceptional conditions,
-	// should be reported as an MCP error response.
-	IsError bool `json:"isError,omitempty"`
-	// An optional JSON object that represents the structured result of the tool call.
-	StructuredContent map[string]any `json:"structuredContent,omitempty"`
-}
-
-// 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 {
-	// A human-readable title for the tool.
-	Title string `json:"title,omitempty"`
-	// If true, the tool does not modify its environment.
-	// Default: false
-	ReadOnlyHint bool `json:"readOnlyHint,omitempty"`
-	// 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 == false`)
-	// Default: true
-	DestructiveHint bool `json:"destructiveHint,omitempty"`
-	// If true, calling the tool repeatedly with the same arguments
-	// will have no additional effect on the its environment.
-	// (This property is meaningful only when `readOnlyHint == false`)
-	// Default: false
-	IdempotentHint bool `json:"idempotentHint,omitempty"`
-	// 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.
-	// Default: true
-	OpenWorldHint bool `json:"openWorldHint,omitempty"`
-}
-
-/* Prompts */
-
-// Sent from the client to request a list of prompts the server has.
-type ListPromptsRequest struct {
-	PaginatedRequest
-}
-
-// The server's response to a prompts/list request from the client.
-type ListPromptsResult struct {
-	PaginatedResult
-	Prompts []prompts.McpManifest `json:"prompts"`
-}
-
-// Used by the client to get a prompt provided by the server.
-type GetPromptRequest struct {
-	jsonrpc.Request
-	Params struct {
-		Name      string         `json:"name"`
-		Arguments map[string]any `json:"arguments,omitempty"`
-	} `json:"params"`
-}
-
-// The server's response to a prompts/get request from the client.
-type GetPromptResult struct {
-	jsonrpc.Result
-	Description string          `json:"description,omitempty"`
-	Messages    []PromptMessage `json:"messages"`
-}
-
-// Describes a message returned as part of a prompt.
-type PromptMessage struct {
-	Role    string      `json:"role"`
-	Content TextContent `json:"content"`
-}

internal/server/mcp_test.go

@@ -37,7 +37,6 @@ const jsonrpcVersion = "2.0"
 const protocolVersion20241105 = "2024-11-05"
 const protocolVersion20250326 = "2025-03-26"
 const protocolVersion20250618 = "2025-06-18"
-const protocolVersion20251125 = "2025-11-25"
 const serverName = "Toolbox"
 
 var basicInputSchema = map[string]any{
@@ -486,23 +485,6 @@ func TestMcpEndpoint(t *testing.T) {
 				},
 			},
 		},
-		{
-			name:     "version 2025-11-25",
-			protocol: protocolVersion20251125,
-			idHeader: false,
-			initWant: map[string]any{
-				"jsonrpc": "2.0",
-				"id":      "mcp-initialize",
-				"result": map[string]any{
-					"protocolVersion": "2025-11-25",
-					"capabilities": map[string]any{
-						"tools":   map[string]any{"listChanged": false},
-						"prompts": map[string]any{"listChanged": false},
-					},
-					"serverInfo": map[string]any{"name": serverName, "version": fakeVersionString},
-				},
-			},
-		},
 	}
 	for _, vtc := range versTestCases {
 		t.Run(vtc.name, func(t *testing.T) {
@@ -512,7 +494,8 @@ func TestMcpEndpoint(t *testing.T) {
 			if sessionId != "" {
 				header["Mcp-Session-Id"] = sessionId
 			}
-			if vtc.protocol != protocolVersion20241105 && vtc.protocol != protocolVersion20250326 {
+
+			if vtc.protocol == protocolVersion20250618 {
 				header["MCP-Protocol-Version"] = vtc.protocol
 			}
 

internal/server/resources/resources_test.go

@@ -32,7 +32,7 @@ func TestUpdateServer(t *testing.T) {
 		"example-source": &alloydbpg.Source{
 			Config: alloydbpg.Config{
 				Name: "example-alloydb-source",
-				Kind: "alloydb-postgres",
+				Type: "alloydb-postgres",
 			},
 		},
 	}
@@ -92,7 +92,7 @@ func TestUpdateServer(t *testing.T) {
 		"example-source2": &alloydbpg.Source{
 			Config: alloydbpg.Config{
 				Name: "example-alloydb-source2",
-				Kind: "alloydb-postgres",
+				Type: "alloydb-postgres",
 			},
 		},
 	}

internal/server/server.go

@@ -82,7 +82,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) (
 			childCtx, span := instrumentation.Tracer.Start(
 				ctx,
 				"toolbox/server/source/init",
-				trace.WithAttributes(attribute.String("source_kind", sc.SourceConfigKind())),
+				trace.WithAttributes(attribute.String("source_type", sc.SourceConfigType())),
 				trace.WithAttributes(attribute.String("source_name", name)),
 			)
 			defer span.End()
@@ -110,7 +110,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) (
 			_, span := instrumentation.Tracer.Start(
 				ctx,
 				"toolbox/server/auth/init",
-				trace.WithAttributes(attribute.String("auth_kind", sc.AuthServiceConfigKind())),
+				trace.WithAttributes(attribute.String("auth_type", sc.AuthServiceConfigType())),
 				trace.WithAttributes(attribute.String("auth_name", name)),
 			)
 			defer span.End()
@@ -138,7 +138,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) (
 			_, span := instrumentation.Tracer.Start(
 				ctx,
 				"toolbox/server/embeddingmodel/init",
-				trace.WithAttributes(attribute.String("model_kind", ec.EmbeddingModelConfigKind())),
+				trace.WithAttributes(attribute.String("model_type", ec.EmbeddingModelConfigType())),
 				trace.WithAttributes(attribute.String("model_name", name)),
 			)
 			defer span.End()
@@ -166,7 +166,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) (
 			_, span := instrumentation.Tracer.Start(
 				ctx,
 				"toolbox/server/tool/init",
-				trace.WithAttributes(attribute.String("tool_kind", tc.ToolConfigKind())),
+				trace.WithAttributes(attribute.String("tool_type", tc.ToolConfigType())),
 				trace.WithAttributes(attribute.String("tool_name", name)),
 			)
 			defer span.End()
@@ -235,7 +235,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) (
 			_, span := instrumentation.Tracer.Start(
 				ctx,
 				"toolbox/server/prompt/init",
-				trace.WithAttributes(attribute.String("prompt_kind", pc.PromptConfigKind())),
+				trace.WithAttributes(attribute.String("prompt_type", pc.PromptConfigType())),
 				trace.WithAttributes(attribute.String("prompt_name", name)),
 			)
 			defer span.End()
@@ -304,14 +304,10 @@ func hostCheck(allowedHosts map[string]struct{}) func(http.Handler) http.Handler
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			_, hasWildcard := allowedHosts["*"]
-			hostname := r.Host
-			if host, _, err := net.SplitHostPort(r.Host); err == nil {
-				hostname = host
-			}
-			_, hostIsAllowed := allowedHosts[hostname]
+			_, hostIsAllowed := allowedHosts[r.Host]
 			if !hasWildcard && !hostIsAllowed {
-				// Return 403 Forbidden to block the attack
-				http.Error(w, "Invalid Host header", http.StatusForbidden)
+				// Return 400 Bad Request or 403 Forbidden to block the attack
+				http.Error(w, "Invalid Host header", http.StatusBadRequest)
 				return
 			}
 			next.ServeHTTP(w, r)
@@ -410,11 +406,7 @@ func NewServer(ctx context.Context, cfg ServerConfig) (*Server, error) {
 	}
 	allowedHostsMap := make(map[string]struct{}, len(cfg.AllowedHosts))
 	for _, h := range cfg.AllowedHosts {
-		hostname := h
-		if host, _, err := net.SplitHostPort(h); err == nil {
-			hostname = host
-		}
-		allowedHostsMap[hostname] = struct{}{}
+		allowedHostsMap[h] = struct{}{}
 	}
 	r.Use(hostCheck(allowedHostsMap))
 

internal/server/server_test.go

@@ -141,7 +141,7 @@ func TestUpdateServer(t *testing.T) {
 		"example-source": &alloydbpg.Source{
 			Config: alloydbpg.Config{
 				Name: "example-alloydb-source",
-				Kind: "alloydb-postgres",
+				Type: "alloydb-postgres",
 			},
 		},
 	}

internal/sources/alloydbadmin/alloydbadmin.go

@@ -32,14 +32,14 @@ import (
 	"google.golang.org/api/option"
 )
 
-const SourceKind string = "alloydb-admin"
+const SourceType string = "alloydb-admin"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -53,13 +53,13 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name           string `yaml:"name" validate:"required"`
-	Kind           string `yaml:"kind" validate:"required"`
+	Type           string `yaml:"kind" validate:"required"`
 	DefaultProject string `yaml:"defaultProject"`
 	UseClientOAuth bool   `yaml:"useClientOAuth"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -106,8 +106,8 @@ type Source struct {
 	Service *alloydbrestapi.Service
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/alloydbadmin/alloydbadmin_test.go

@@ -41,7 +41,7 @@ func TestParseFromYamlAlloyDBAdmin(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-alloydb-admin-instance": alloydbadmin.Config{
 					Name:           "my-alloydb-admin-instance",
-					Kind:           alloydbadmin.SourceKind,
+					Type:           alloydbadmin.SourceType,
 					UseClientOAuth: false,
 				},
 			},
@@ -57,7 +57,7 @@ func TestParseFromYamlAlloyDBAdmin(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-alloydb-admin-instance": alloydbadmin.Config{
 					Name:           "my-alloydb-admin-instance",
-					Kind:           alloydbadmin.SourceKind,
+					Type:           alloydbadmin.SourceType,
 					UseClientOAuth: true,
 				},
 			},

internal/sources/alloydbpg/alloydb_pg.go

@@ -29,14 +29,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "alloydb-postgres"
+const SourceType string = "alloydb-postgres"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -50,7 +50,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string         `yaml:"name" validate:"required"`
-	Kind     string         `yaml:"kind" validate:"required"`
+	Type     string         `yaml:"kind" validate:"required"`
 	Project  string         `yaml:"project" validate:"required"`
 	Region   string         `yaml:"region" validate:"required"`
 	Cluster  string         `yaml:"cluster" validate:"required"`
@@ -61,8 +61,8 @@ type Config struct {
 	Database string         `yaml:"database" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -90,8 +90,8 @@ type Source struct {
 	Pool *pgxpool.Pool
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -183,7 +183,7 @@ func getConnectionConfig(ctx context.Context, user, pass, dbname string) (string
 
 func initAlloyDBPgConnectionPool(ctx context.Context, tracer trace.Tracer, name, project, region, cluster, instance, ipType, user, pass, dbname string) (*pgxpool.Pool, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	dsn, useIAM, err := getConnectionConfig(ctx, user, pass, dbname)

internal/sources/alloydbpg/alloydb_pg_test.go

@@ -48,7 +48,7 @@ func TestParseFromYamlAlloyDBPg(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-pg-instance": alloydbpg.Config{
 					Name:     "my-pg-instance",
-					Kind:     alloydbpg.SourceKind,
+					Type:     alloydbpg.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Cluster:  "my-cluster",
@@ -78,7 +78,7 @@ func TestParseFromYamlAlloyDBPg(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-pg-instance": alloydbpg.Config{
 					Name:     "my-pg-instance",
-					Kind:     alloydbpg.SourceKind,
+					Type:     alloydbpg.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Cluster:  "my-cluster",
@@ -108,7 +108,7 @@ func TestParseFromYamlAlloyDBPg(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-pg-instance": alloydbpg.Config{
 					Name:     "my-pg-instance",
-					Kind:     alloydbpg.SourceKind,
+					Type:     alloydbpg.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Cluster:  "my-cluster",

internal/sources/bigquery/bigquery.go

@@ -41,7 +41,7 @@ import (
 	"google.golang.org/api/option"
 )
 
-const SourceKind string = "bigquery"
+const SourceType string = "bigquery"
 
 // CloudPlatformScope is a broad scope for Google Cloud Platform services.
 const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
@@ -65,8 +65,8 @@ type BigQuerySessionProvider func(ctx context.Context) (*Session, error)
 type DataplexClientCreator func(tokenString string) (*dataplexapi.CatalogClient, error)
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -81,7 +81,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 type Config struct {
 	// BigQuery configs
 	Name                      string              `yaml:"name" validate:"required"`
-	Kind                      string              `yaml:"kind" validate:"required"`
+	Type                      string              `yaml:"kind" validate:"required"`
 	Project                   string              `yaml:"project" validate:"required"`
 	Location                  string              `yaml:"location"`
 	WriteMode                 string              `yaml:"writeMode"`
@@ -119,9 +119,9 @@ func (s *StringOrStringSlice) UnmarshalYAML(unmarshal func(any) error) error {
 	return fmt.Errorf("cannot unmarshal %T into StringOrStringSlice", v)
 }
 
-func (r Config) SourceConfigKind() string {
+func (r Config) SourceConfigType() string {
 	// Returns BigQuery source kind
-	return SourceKind
+	return SourceType
 }
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
 	if r.WriteMode == "" {
@@ -302,9 +302,9 @@ type Session struct {
 	LastUsed     time.Time
 }
 
-func (s *Source) SourceKind() string {
+func (s *Source) SourceType() string {
 	// Returns BigQuery Google SQL source kind
-	return SourceKind
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -665,7 +665,7 @@ func initBigQueryConnection(
 	impersonateServiceAccount string,
 	scopes []string,
 ) (*bigqueryapi.Client, *bigqueryrestapi.Service, oauth2.TokenSource, error) {
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	userAgent, err := util.UserAgentFromContext(ctx)
@@ -741,7 +741,7 @@ func initBigQueryConnectionWithOAuthToken(
 	tokenString string,
 	wantRestService bool,
 ) (*bigqueryapi.Client, *bigqueryrestapi.Service, error) {
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 	// Construct token source
 	token := &oauth2.Token{
@@ -801,7 +801,7 @@ func initDataplexConnection(
 	var clientCreator DataplexClientCreator
 	var err error
 
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	userAgent, err := util.UserAgentFromContext(ctx)

internal/sources/bigquery/bigquery_test.go

@@ -46,7 +46,7 @@ func TestParseFromYamlBigQuery(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": bigquery.Config{
 					Name:      "my-instance",
-					Kind:      bigquery.SourceKind,
+					Type:      bigquery.SourceType,
 					Project:   "my-project",
 					Location:  "",
 					WriteMode: "",
@@ -66,7 +66,7 @@ func TestParseFromYamlBigQuery(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": bigquery.Config{
 					Name:           "my-instance",
-					Kind:           bigquery.SourceKind,
+					Type:           bigquery.SourceType,
 					Project:        "my-project",
 					Location:       "asia",
 					WriteMode:      "blocked",
@@ -87,7 +87,7 @@ func TestParseFromYamlBigQuery(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": bigquery.Config{
 					Name:           "my-instance",
-					Kind:           bigquery.SourceKind,
+					Type:           bigquery.SourceType,
 					Project:        "my-project",
 					Location:       "us",
 					UseClientOAuth: true,
@@ -108,7 +108,7 @@ func TestParseFromYamlBigQuery(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": bigquery.Config{
 					Name:            "my-instance",
-					Kind:            bigquery.SourceKind,
+					Type:            bigquery.SourceType,
 					Project:         "my-project",
 					Location:        "us",
 					AllowedDatasets: []string{"my_dataset"},
@@ -128,7 +128,7 @@ func TestParseFromYamlBigQuery(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": bigquery.Config{
 					Name:                      "my-instance",
-					Kind:                      bigquery.SourceKind,
+					Type:                      bigquery.SourceType,
 					Project:                   "my-project",
 					Location:                  "us",
 					ImpersonateServiceAccount: "service-account@my-project.iam.gserviceaccount.com",
@@ -150,7 +150,7 @@ func TestParseFromYamlBigQuery(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": bigquery.Config{
 					Name:     "my-instance",
-					Kind:     bigquery.SourceKind,
+					Type:     bigquery.SourceType,
 					Project:  "my-project",
 					Location: "us",
 					Scopes:   []string{"https://www.googleapis.com/auth/bigquery", "https://www.googleapis.com/auth/cloud-platform"},
@@ -170,7 +170,7 @@ func TestParseFromYamlBigQuery(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": bigquery.Config{
 					Name:               "my-instance",
-					Kind:               bigquery.SourceKind,
+					Type:               bigquery.SourceType,
 					Project:            "my-project",
 					Location:           "us",
 					MaxQueryResultRows: 10,
@@ -260,7 +260,7 @@ func TestInitialize_MaxQueryResultRows(t *testing.T) {
 			desc: "default value",
 			cfg: bigquery.Config{
 				Name:           "test-default",
-				Kind:           bigquery.SourceKind,
+				Type:           bigquery.SourceType,
 				Project:        "test-project",
 				UseClientOAuth: true,
 			},
@@ -270,7 +270,7 @@ func TestInitialize_MaxQueryResultRows(t *testing.T) {
 			desc: "configured value",
 			cfg: bigquery.Config{
 				Name:               "test-configured",
-				Kind:               bigquery.SourceKind,
+				Type:               bigquery.SourceType,
 				Project:            "test-project",
 				UseClientOAuth:     true,
 				MaxQueryResultRows: 100,

internal/sources/bigtable/bigtable.go

@@ -27,14 +27,14 @@ import (
 	"google.golang.org/api/option"
 )
 
-const SourceKind string = "bigtable"
+const SourceType string = "bigtable"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -48,13 +48,13 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Project  string `yaml:"project" validate:"required"`
 	Instance string `yaml:"instance" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -77,8 +77,8 @@ type Source struct {
 	Client *bigtable.Client
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -179,7 +179,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, configParam param
 
 func initBigtableClient(ctx context.Context, tracer trace.Tracer, name, project, instance string) (*bigtable.Client, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Set up Bigtable data operations client.

internal/sources/bigtable/bigtable_test.go

@@ -43,7 +43,7 @@ func TestParseFromYamlBigtableDb(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-bigtable-instance": bigtable.Config{
 					Name:     "my-bigtable-instance",
-					Kind:     bigtable.SourceKind,
+					Type:     bigtable.SourceType,
 					Project:  "my-project",
 					Instance: "my-instance",
 				},

internal/sources/cassandra/cassandra.go

@@ -25,11 +25,11 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "cassandra"
+const SourceType string = "cassandra"
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -43,7 +43,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name                   string   `yaml:"name" validate:"required"`
-	Kind                   string   `yaml:"kind" validate:"required"`
+	Type                   string   `yaml:"kind" validate:"required"`
 	Hosts                  []string `yaml:"hosts" validate:"required"`
 	Keyspace               string   `yaml:"keyspace"`
 	ProtoVersion           int      `yaml:"protoVersion"`
@@ -68,9 +68,9 @@ func (c Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.So
 	return s, nil
 }
 
-// SourceConfigKind implements sources.SourceConfig.
-func (c Config) SourceConfigKind() string {
-	return SourceKind
+// SourceConfigType implements sources.SourceConfig.
+func (c Config) SourceConfigType() string {
+	return SourceType
 }
 
 var _ sources.SourceConfig = Config{}
@@ -89,9 +89,9 @@ func (s *Source) ToConfig() sources.SourceConfig {
 	return s.Config
 }
 
-// SourceKind implements sources.Source.
-func (s *Source) SourceKind() string {
-	return SourceKind
+// SourceType implements sources.Source.
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) RunSQL(ctx context.Context, statement string, params parameters.ParamValues) (any, error) {
@@ -120,7 +120,7 @@ var _ sources.Source = &Source{}
 
 func initCassandraSession(ctx context.Context, tracer trace.Tracer, c Config) (*gocql.Session, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, c.Name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, c.Name)
 	defer span.End()
 
 	// Validate authentication configuration

internal/sources/cassandra/cassandra_test.go

@@ -43,7 +43,7 @@ func TestParseFromYamlCassandra(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-cassandra-instance": cassandra.Config{
 					Name:                   "my-cassandra-instance",
-					Kind:                   cassandra.SourceKind,
+					Type:                   cassandra.SourceType,
 					Hosts:                  []string{"my-host1", "my-host2"},
 					Username:               "",
 					Password:               "",
@@ -77,7 +77,7 @@ func TestParseFromYamlCassandra(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-cassandra-instance": cassandra.Config{
 					Name:                   "my-cassandra-instance",
-					Kind:                   cassandra.SourceKind,
+					Type:                   cassandra.SourceType,
 					Hosts:                  []string{"my-host1", "my-host2"},
 					Username:               "user",
 					Password:               "pass",

internal/sources/clickhouse/clickhouse.go

@@ -28,14 +28,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "clickhouse"
+const SourceType string = "clickhouse"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -49,7 +49,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Host     string `yaml:"host" validate:"required"`
 	Port     string `yaml:"port" validate:"required"`
 	Database string `yaml:"database" validate:"required"`
@@ -59,8 +59,8 @@ type Config struct {
 	Secure   bool   `yaml:"secure"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -88,8 +88,8 @@ type Source struct {
 	Pool *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -174,7 +174,7 @@ func validateConfig(protocol string) error {
 
 func initClickHouseConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname, protocol string, secure bool) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	if protocol == "" {

internal/sources/clickhouse/clickhouse_test.go

@@ -25,10 +25,10 @@ import (
 	"go.opentelemetry.io/otel"
 )
 
-func TestConfigSourceConfigKind(t *testing.T) {
+func TestConfigSourceConfigType(t *testing.T) {
 	config := Config{}
-	if config.SourceConfigKind() != SourceKind {
-		t.Errorf("Expected %s, got %s", SourceKind, config.SourceConfigKind())
+	if config.SourceConfigType() != SourceType {
+		t.Errorf("Expected %s, got %s", SourceType, config.SourceConfigType())
 	}
 }
 
@@ -53,7 +53,7 @@ func TestNewConfig(t *testing.T) {
 			`,
 			expected: Config{
 				Name:     "test-clickhouse",
-				Kind:     "clickhouse",
+				Type:     "clickhouse",
 				Host:     "localhost",
 				Port:     "8443",
 				User:     "default",
@@ -75,7 +75,7 @@ func TestNewConfig(t *testing.T) {
 			`,
 			expected: Config{
 				Name:     "minimal-clickhouse",
-				Kind:     "clickhouse",
+				Type:     "clickhouse",
 				Host:     "127.0.0.1",
 				Port:     "8123",
 				User:     "testuser",
@@ -100,7 +100,7 @@ func TestNewConfig(t *testing.T) {
 			`,
 			expected: Config{
 				Name:     "http-clickhouse",
-				Kind:     "clickhouse",
+				Type:     "clickhouse",
 				Host:     "clickhouse.example.com",
 				Port:     "8123",
 				User:     "analytics",
@@ -125,7 +125,7 @@ func TestNewConfig(t *testing.T) {
 			`,
 			expected: Config{
 				Name:     "secure-clickhouse",
-				Kind:     "clickhouse",
+				Type:     "clickhouse",
 				Host:     "secure.clickhouse.io",
 				Port:     "8443",
 				User:     "secureuser",
@@ -196,10 +196,10 @@ func TestNewConfigInvalidYAML(t *testing.T) {
 	}
 }
 
-func TestSource_SourceKind(t *testing.T) {
+func TestSource_SourceType(t *testing.T) {
 	source := &Source{}
-	if source.SourceKind() != SourceKind {
-		t.Errorf("Expected %s, got %s", SourceKind, source.SourceKind())
+	if source.SourceType() != SourceType {
+		t.Errorf("Expected %s, got %s", SourceType, source.SourceType())
 	}
 }
 

internal/sources/cloudgda/cloud_gda.go

@@ -29,15 +29,15 @@ import (
 	"golang.org/x/oauth2/google"
 )
 
-const SourceKind string = "cloud-gemini-data-analytics"
+const SourceType string = "cloud-gemini-data-analytics"
 const Endpoint string = "https://geminidataanalytics.googleapis.com"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -51,13 +51,13 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name           string `yaml:"name" validate:"required"`
-	Kind           string `yaml:"kind" validate:"required"`
+	Type           string `yaml:"kind" validate:"required"`
 	ProjectID      string `yaml:"projectId" validate:"required"`
 	UseClientOAuth bool   `yaml:"useClientOAuth"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 // Initialize initializes a Gemini Data Analytics Source instance.
@@ -102,8 +102,8 @@ type Source struct {
 	userAgent string
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/cloudgda/cloud_gda_test.go

@@ -47,7 +47,7 @@ func TestParseFromYamlCloudGDA(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-gda-instance": cloudgda.Config{
 					Name:           "my-gda-instance",
-					Kind:           cloudgda.SourceKind,
+					Type:           cloudgda.SourceType,
 					ProjectID:      "test-project-id",
 					UseClientOAuth: false,
 				},
@@ -65,7 +65,7 @@ func TestParseFromYamlCloudGDA(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-gda-instance": cloudgda.Config{
 					Name:           "my-gda-instance",
-					Kind:           cloudgda.SourceKind,
+					Type:           cloudgda.SourceType,
 					ProjectID:      "another-project",
 					UseClientOAuth: true,
 				},
@@ -153,12 +153,12 @@ func TestInitialize(t *testing.T) {
 	}{
 		{
 			desc:            "initialize with ADC",
-			cfg:             cloudgda.Config{Name: "test-gda", Kind: cloudgda.SourceKind, ProjectID: "test-proj"},
+			cfg:             cloudgda.Config{Name: "test-gda", Type: cloudgda.SourceType, ProjectID: "test-proj"},
 			wantClientOAuth: false,
 		},
 		{
 			desc:            "initialize with client OAuth",
-			cfg:             cloudgda.Config{Name: "test-gda-oauth", Kind: cloudgda.SourceKind, ProjectID: "test-proj", UseClientOAuth: true},
+			cfg:             cloudgda.Config{Name: "test-gda-oauth", Type: cloudgda.SourceType, ProjectID: "test-proj", UseClientOAuth: true},
 			wantClientOAuth: true,
 		},
 	}

internal/sources/cloudhealthcare/cloud_healthcare.go

@@ -34,7 +34,7 @@ import (
 	"google.golang.org/api/option"
 )
 
-const SourceKind string = "cloud-healthcare"
+const SourceType string = "cloud-healthcare"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
@@ -42,8 +42,8 @@ var _ sources.SourceConfig = Config{}
 type HealthcareServiceCreator func(tokenString string) (*healthcare.Service, error)
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -58,7 +58,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 type Config struct {
 	// Healthcare configs
 	Name               string   `yaml:"name" validate:"required"`
-	Kind               string   `yaml:"kind" validate:"required"`
+	Type               string   `yaml:"kind" validate:"required"`
 	Project            string   `yaml:"project" validate:"required"`
 	Region             string   `yaml:"region" validate:"required"`
 	Dataset            string   `yaml:"dataset" validate:"required"`
@@ -67,8 +67,8 @@ type Config struct {
 	UseClientOAuth     bool     `yaml:"useClientOAuth"`
 }
 
-func (c Config) SourceConfigKind() string {
-	return SourceKind
+func (c Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (c Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -144,7 +144,7 @@ func newHealthcareServiceCreator(ctx context.Context, tracer trace.Tracer, name
 }
 
 func initHealthcareConnectionWithOAuthToken(ctx context.Context, tracer trace.Tracer, name string, userAgent string, tokenString string) (*healthcare.Service, error) {
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 	// Construct token source
 	token := &oauth2.Token{
@@ -162,7 +162,7 @@ func initHealthcareConnectionWithOAuthToken(ctx context.Context, tracer trace.Tr
 }
 
 func initHealthcareConnection(ctx context.Context, tracer trace.Tracer, name string) (*healthcare.Service, oauth2.TokenSource, error) {
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	cred, err := google.FindDefaultCredentials(ctx, healthcare.CloudHealthcareScope)
@@ -194,8 +194,8 @@ type Source struct {
 	allowedDICOMStores map[string]struct{}
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -517,14 +517,14 @@ func (s *Source) RetrieveRenderedDICOMInstance(storeID, study, series, sop strin
 	return base64String, nil
 }
 
-func (s *Source) SearchDICOM(toolKind, storeID, dicomWebPath, tokenStr string, opts []googleapi.CallOption) (any, error) {
+func (s *Source) SearchDICOM(toolType, storeID, dicomWebPath, tokenStr string, opts []googleapi.CallOption) (any, error) {
 	svc, err := s.getService(tokenStr)
 	if err != nil {
 		return nil, err
 	}
 	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", s.Project(), s.Region(), s.DatasetID(), storeID)
 	var resp *http.Response
-	switch toolKind {
+	switch toolType {
 	case "cloud-healthcare-search-dicom-instances":
 		resp, err = svc.Projects.Locations.Datasets.DicomStores.SearchForInstances(name, dicomWebPath).Do(opts...)
 	case "cloud-healthcare-search-dicom-series":
@@ -532,7 +532,7 @@ func (s *Source) SearchDICOM(toolKind, storeID, dicomWebPath, tokenStr string, o
 	case "cloud-healthcare-search-dicom-studies":
 		resp, err = svc.Projects.Locations.Datasets.DicomStores.SearchForStudies(name, dicomWebPath).Do(opts...)
 	default:
-		return nil, fmt.Errorf("incompatible tool kind: %s", toolKind)
+		return nil, fmt.Errorf("incompatible tool type: %s", toolType)
 	}
 	if err != nil {
 		return nil, fmt.Errorf("failed to search dicom series: %w", err)

internal/sources/cloudhealthcare/cloud_healthcare_test.go

@@ -43,7 +43,7 @@ func TestParseFromYamlCloudHealthcare(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": cloudhealthcare.Config{
 					Name:           "my-instance",
-					Kind:           cloudhealthcare.SourceKind,
+					Type:           cloudhealthcare.SourceType,
 					Project:        "my-project",
 					Region:         "us-central1",
 					Dataset:        "my-dataset",
@@ -65,7 +65,7 @@ func TestParseFromYamlCloudHealthcare(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": cloudhealthcare.Config{
 					Name:           "my-instance",
-					Kind:           cloudhealthcare.SourceKind,
+					Type:           cloudhealthcare.SourceType,
 					Project:        "my-project",
 					Region:         "us",
 					Dataset:        "my-dataset",
@@ -91,7 +91,7 @@ func TestParseFromYamlCloudHealthcare(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": cloudhealthcare.Config{
 					Name:               "my-instance",
-					Kind:               cloudhealthcare.SourceKind,
+					Type:               cloudhealthcare.SourceType,
 					Project:            "my-project",
 					Region:             "us",
 					Dataset:            "my-dataset",

internal/sources/cloudmonitoring/cloud_monitoring.go

@@ -29,14 +29,14 @@ import (
 	monitoring "google.golang.org/api/monitoring/v3"
 )
 
-const SourceKind string = "cloud-monitoring"
+const SourceType string = "cloud-monitoring"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -50,12 +50,12 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name           string `yaml:"name" validate:"required"`
-	Kind           string `yaml:"kind" validate:"required"`
+	Type           string `yaml:"kind" validate:"required"`
 	UseClientOAuth bool   `yaml:"useClientOAuth"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 // Initialize initializes a Cloud Monitoring Source instance.
@@ -99,8 +99,8 @@ type Source struct {
 	userAgent string
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/cloudmonitoring/cloud_monitoring_test.go

@@ -42,7 +42,7 @@ func TestParseFromYamlCloudMonitoring(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-cloud-monitoring-instance": cloudmonitoring.Config{
 					Name:           "my-cloud-monitoring-instance",
-					Kind:           cloudmonitoring.SourceKind,
+					Type:           cloudmonitoring.SourceType,
 					UseClientOAuth: false,
 				},
 			},
@@ -58,7 +58,7 @@ func TestParseFromYamlCloudMonitoring(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-cloud-monitoring-instance": cloudmonitoring.Config{
 					Name:           "my-cloud-monitoring-instance",
-					Kind:           cloudmonitoring.SourceKind,
+					Type:           cloudmonitoring.SourceType,
 					UseClientOAuth: true,
 				},
 			},

internal/sources/cloudsqladmin/cloud_sql_admin.go

@@ -34,7 +34,7 @@ import (
 	sqladmin "google.golang.org/api/sqladmin/v1"
 )
 
-const SourceKind string = "cloud-sql-admin"
+const SourceType string = "cloud-sql-admin"
 
 var targetLinkRegex = regexp.MustCompile(`/projects/([^/]+)/instances/([^/]+)/databases/([^/]+)`)
 
@@ -42,8 +42,8 @@ var targetLinkRegex = regexp.MustCompile(`/projects/([^/]+)/instances/([^/]+)/da
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -57,13 +57,13 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name           string `yaml:"name" validate:"required"`
-	Kind           string `yaml:"kind" validate:"required"`
+	Type           string `yaml:"kind" validate:"required"`
 	DefaultProject string `yaml:"defaultProject"`
 	UseClientOAuth bool   `yaml:"useClientOAuth"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 // Initialize initializes a CloudSQL Admin Source instance.
@@ -110,8 +110,8 @@ type Source struct {
 	Service *sqladmin.Service
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/cloudsqladmin/cloud_sql_admin_test.go

@@ -42,7 +42,7 @@ func TestParseFromYamlCloudSQLAdmin(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-cloud-sql-admin-instance": cloudsqladmin.Config{
 					Name:           "my-cloud-sql-admin-instance",
-					Kind:           cloudsqladmin.SourceKind,
+					Type:           cloudsqladmin.SourceType,
 					UseClientOAuth: false,
 				},
 			},
@@ -58,7 +58,7 @@ func TestParseFromYamlCloudSQLAdmin(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-cloud-sql-admin-instance": cloudsqladmin.Config{
 					Name:           "my-cloud-sql-admin-instance",
-					Kind:           cloudsqladmin.SourceKind,
+					Type:           cloudsqladmin.SourceType,
 					UseClientOAuth: true,
 				},
 			},

internal/sources/cloudsqlmssql/cloud_sql_mssql.go

@@ -29,14 +29,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "cloud-sql-mssql"
+const SourceType string = "cloud-sql-mssql"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -51,7 +51,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 type Config struct {
 	// Cloud SQL MSSQL configs
 	Name      string         `yaml:"name" validate:"required"`
-	Kind      string         `yaml:"kind" validate:"required"`
+	Type      string         `yaml:"kind" validate:"required"`
 	Project   string         `yaml:"project" validate:"required"`
 	Region    string         `yaml:"region" validate:"required"`
 	Instance  string         `yaml:"instance" validate:"required"`
@@ -62,9 +62,9 @@ type Config struct {
 	Database  string         `yaml:"database" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
+func (r Config) SourceConfigType() string {
 	// Returns Cloud SQL MSSQL source kind
-	return SourceKind
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -94,9 +94,9 @@ type Source struct {
 	Db *sql.DB
 }
 
-func (s *Source) SourceKind() string {
+func (s *Source) SourceType() string {
 	// Returns Cloud SQL MSSQL source kind
-	return SourceKind
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -152,7 +152,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initCloudSQLMssqlConnection(ctx context.Context, tracer trace.Tracer, name, project, region, instance, ipType, user, pass, dbname string) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	userAgent, err := util.UserAgentFromContext(ctx)

internal/sources/cloudsqlmssql/cloud_sql_mssql_test.go

@@ -46,7 +46,7 @@ func TestParseFromYamlCloudSQLMssql(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": cloudsqlmssql.Config{
 					Name:     "my-instance",
-					Kind:     cloudsqlmssql.SourceKind,
+					Type:     cloudsqlmssql.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -74,7 +74,7 @@ func TestParseFromYamlCloudSQLMssql(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": cloudsqlmssql.Config{
 					Name:     "my-instance",
-					Kind:     cloudsqlmssql.SourceKind,
+					Type:     cloudsqlmssql.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -102,7 +102,7 @@ func TestParseFromYamlCloudSQLMssql(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": cloudsqlmssql.Config{
 					Name:      "my-instance",
-					Kind:      cloudsqlmssql.SourceKind,
+					Type:      cloudsqlmssql.SourceType,
 					Project:   "my-project",
 					Region:    "my-region",
 					Instance:  "my-instance",

internal/sources/cloudsqlmysql/cloud_sql_mysql.go

@@ -30,14 +30,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "cloud-sql-mysql"
+const SourceType string = "cloud-sql-mysql"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -51,7 +51,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string         `yaml:"name" validate:"required"`
-	Kind     string         `yaml:"kind" validate:"required"`
+	Type     string         `yaml:"kind" validate:"required"`
 	Project  string         `yaml:"project" validate:"required"`
 	Region   string         `yaml:"region" validate:"required"`
 	Instance string         `yaml:"instance" validate:"required"`
@@ -61,8 +61,8 @@ type Config struct {
 	Database string         `yaml:"database" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -90,8 +90,8 @@ type Source struct {
 	Pool *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -184,7 +184,7 @@ func getConnectionConfig(ctx context.Context, user, pass string) (string, string
 
 func initCloudSQLMySQLConnectionPool(ctx context.Context, tracer trace.Tracer, name, project, region, instance, ipType, user, pass, dbname string) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Configure the driver to connect to the database

internal/sources/cloudsqlmysql/cloud_sql_mysql_test.go

@@ -46,7 +46,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mysql-instance": cloudsqlmysql.Config{
 					Name:     "my-mysql-instance",
-					Kind:     cloudsqlmysql.SourceKind,
+					Type:     cloudsqlmysql.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -74,7 +74,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mysql-instance": cloudsqlmysql.Config{
 					Name:     "my-mysql-instance",
-					Kind:     cloudsqlmysql.SourceKind,
+					Type:     cloudsqlmysql.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -102,7 +102,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mysql-instance": cloudsqlmysql.Config{
 					Name:     "my-mysql-instance",
-					Kind:     cloudsqlmysql.SourceKind,
+					Type:     cloudsqlmysql.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -130,7 +130,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mysql-instance": cloudsqlmysql.Config{
 					Name:     "my-mysql-instance",
-					Kind:     cloudsqlmysql.SourceKind,
+					Type:     cloudsqlmysql.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",

internal/sources/cloudsqlpg/cloud_sql_pg.go

@@ -28,14 +28,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "cloud-sql-postgres"
+const SourceType string = "cloud-sql-postgres"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -49,7 +49,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string         `yaml:"name" validate:"required"`
-	Kind     string         `yaml:"kind" validate:"required"`
+	Type     string         `yaml:"kind" validate:"required"`
 	Project  string         `yaml:"project" validate:"required"`
 	Region   string         `yaml:"region" validate:"required"`
 	Instance string         `yaml:"instance" validate:"required"`
@@ -59,8 +59,8 @@ type Config struct {
 	Password string         `yaml:"password"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -88,8 +88,8 @@ type Source struct {
 	Pool *pgxpool.Pool
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -162,7 +162,7 @@ func getConnectionConfig(ctx context.Context, user, pass, dbname string) (string
 
 func initCloudSQLPgConnectionPool(ctx context.Context, tracer trace.Tracer, name, project, region, instance, ipType, user, pass, dbname string) (*pgxpool.Pool, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Configure the driver to connect to the database

internal/sources/cloudsqlpg/cloud_sql_pg_test.go

@@ -46,7 +46,7 @@ func TestParseFromYamlCloudSQLPg(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-pg-instance": cloudsqlpg.Config{
 					Name:     "my-pg-instance",
-					Kind:     cloudsqlpg.SourceKind,
+					Type:     cloudsqlpg.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -74,7 +74,7 @@ func TestParseFromYamlCloudSQLPg(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-pg-instance": cloudsqlpg.Config{
 					Name:     "my-pg-instance",
-					Kind:     cloudsqlpg.SourceKind,
+					Type:     cloudsqlpg.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -102,7 +102,7 @@ func TestParseFromYamlCloudSQLPg(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-pg-instance": cloudsqlpg.Config{
 					Name:     "my-pg-instance",
-					Kind:     cloudsqlpg.SourceKind,
+					Type:     cloudsqlpg.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",
@@ -130,7 +130,7 @@ func TestParseFromYamlCloudSQLPg(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-pg-instance": cloudsqlpg.Config{
 					Name:     "my-pg-instance",
-					Kind:     cloudsqlpg.SourceKind,
+					Type:     cloudsqlpg.SourceType,
 					Project:  "my-project",
 					Region:   "my-region",
 					Instance: "my-instance",

internal/sources/couchbase/couchbase.go

@@ -29,14 +29,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "couchbase"
+const SourceType string = "couchbase"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -50,7 +50,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name                 string `yaml:"name" validate:"required"`
-	Kind                 string `yaml:"kind" validate:"required"`
+	Type                 string `yaml:"kind" validate:"required"`
 	ConnectionString     string `yaml:"connectionString" validate:"required"`
 	Bucket               string `yaml:"bucket" validate:"required"`
 	Scope                string `yaml:"scope" validate:"required"`
@@ -66,8 +66,8 @@ type Config struct {
 	QueryScanConsistency uint   `yaml:"queryScanConsistency"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -96,8 +96,8 @@ type Source struct {
 	Scope *gocb.Scope
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/couchbase/couchbase_test.go

@@ -45,7 +45,7 @@ func TestParseFromYamlCouchbase(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-couchbase-instance": couchbase.Config{
 					Name:             "my-couchbase-instance",
-					Kind:             couchbase.SourceKind,
+					Type:             couchbase.SourceType,
 					ConnectionString: "localhost",
 					Username:         "Administrator",
 					Password:         "password",
@@ -74,7 +74,7 @@ func TestParseFromYamlCouchbase(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-couchbase-instance": couchbase.Config{
 					Name:                 "my-couchbase-instance",
-					Kind:                 couchbase.SourceKind,
+					Type:                 couchbase.SourceType,
 					ConnectionString:     "couchbases://localhost",
 					Bucket:               "travel-sample",
 					Scope:                "inventory",

internal/sources/dataplex/dataplex.go

@@ -29,14 +29,14 @@ import (
 	"google.golang.org/api/option"
 )
 
-const SourceKind string = "dataplex"
+const SourceType string = "dataplex"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -51,13 +51,13 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 type Config struct {
 	// Dataplex configs
 	Name    string `yaml:"name" validate:"required"`
-	Kind    string `yaml:"kind" validate:"required"`
+	Type    string `yaml:"kind" validate:"required"`
 	Project string `yaml:"project" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
+func (r Config) SourceConfigType() string {
 	// Returns Dataplex source kind
-	return SourceKind
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -81,9 +81,9 @@ type Source struct {
 	Client *dataplexapi.CatalogClient
 }
 
-func (s *Source) SourceKind() string {
+func (s *Source) SourceType() string {
 	// Returns Dataplex source kind
-	return SourceKind
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -104,7 +104,7 @@ func initDataplexConnection(
 	name string,
 	project string,
 ) (*dataplexapi.CatalogClient, error) {
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	cred, err := google.FindDefaultCredentials(ctx)

internal/sources/dataplex/dataplex_test.go

@@ -41,7 +41,7 @@ func TestParseFromYamlDataplex(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": dataplex.Config{
 					Name:    "my-instance",
-					Kind:    dataplex.SourceKind,
+					Type:    dataplex.SourceType,
 					Project: "my-project",
 				},
 			},

internal/sources/dgraph/dgraph.go

@@ -30,14 +30,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "dgraph"
+const SourceType string = "dgraph"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -67,7 +67,7 @@ type DgraphClient struct {
 
 type Config struct {
 	Name      string `yaml:"name" validate:"required"`
-	Kind      string `yaml:"kind" validate:"required"`
+	Type      string `yaml:"kind" validate:"required"`
 	DgraphUrl string `yaml:"dgraphUrl" validate:"required"`
 	User      string `yaml:"user"`
 	Password  string `yaml:"password"`
@@ -75,8 +75,8 @@ type Config struct {
 	ApiKey    string `yaml:"apiKey"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -103,8 +103,8 @@ type Source struct {
 	Client *DgraphClient `yaml:"client"`
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -139,7 +139,7 @@ func (s *Source) RunSQL(statement string, params parameters.ParamValues, isQuery
 
 func initDgraphHttpClient(ctx context.Context, tracer trace.Tracer, r Config) (*DgraphClient, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, r.Name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, r.Name)
 	defer span.End()
 
 	if r.DgraphUrl == "" {

internal/sources/dgraph/dgraph_test.go

@@ -45,7 +45,7 @@ func TestParseFromYamlDgraph(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-dgraph-instance": dgraph.Config{
 					Name:      "my-dgraph-instance",
-					Kind:      dgraph.SourceKind,
+					Type:      dgraph.SourceType,
 					DgraphUrl: "https://localhost:8080",
 					ApiKey:    "abc123",
 					Password:  "pass@123",
@@ -65,7 +65,7 @@ func TestParseFromYamlDgraph(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-dgraph-instance": dgraph.Config{
 					Name:      "my-dgraph-instance",
-					Kind:      dgraph.SourceKind,
+					Type:      dgraph.SourceType,
 					DgraphUrl: "https://localhost:8080",
 				},
 			},

internal/sources/elasticsearch/elasticsearch.go

@@ -30,14 +30,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "elasticsearch"
+const SourceType string = "elasticsearch"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -51,15 +51,15 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name      string   `yaml:"name" validate:"required"`
-	Kind      string   `yaml:"kind" validate:"required"`
+	Type      string   `yaml:"kind" validate:"required"`
 	Addresses []string `yaml:"addresses" validate:"required"`
 	Username  string   `yaml:"username"`
 	Password  string   `yaml:"password"`
 	APIKey    string   `yaml:"apikey"`
 }
 
-func (c Config) SourceConfigKind() string {
-	return SourceKind
+func (c Config) SourceConfigType() string {
+	return SourceType
 }
 
 type EsClient interface {
@@ -139,9 +139,9 @@ func (c Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.So
 	return s, nil
 }
 
-// SourceKind returns the kind string for this source.
-func (s *Source) SourceKind() string {
-	return SourceKind
+// SourceType returns the kind string for this source.
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/elasticsearch/elasticsearch_test.go

@@ -43,7 +43,7 @@ func TestParseFromYamlElasticsearch(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-es-instance": elasticsearch.Config{
 					Name:      "my-es-instance",
-					Kind:      elasticsearch.SourceKind,
+					Type:      elasticsearch.SourceType,
 					Addresses: []string{"http://localhost:9200"},
 					APIKey:    "somekey",
 				},

internal/sources/firebird/firebird.go

@@ -27,13 +27,13 @@ import (
 	"github.com/googleapis/genai-toolbox/internal/sources"
 )
 
-const SourceKind string = "firebird"
+const SourceType string = "firebird"
 
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -47,7 +47,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Host     string `yaml:"host" validate:"required"`
 	Port     string `yaml:"port" validate:"required"`
 	User     string `yaml:"user" validate:"required"`
@@ -55,8 +55,8 @@ type Config struct {
 	Database string `yaml:"database" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -84,8 +84,8 @@ type Source struct {
 	Db *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -144,7 +144,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 }
 
 func initFirebirdConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname string) (*sql.DB, error) {
-	_, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	_, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// urlExample := "user:password@host:port/path/to/database.fdb"

internal/sources/firebird/firebird_test.go

@@ -45,7 +45,7 @@ func TestParseFromYamlFirebird(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-fdb-instance": firebird.Config{
 					Name:     "my-fdb-instance",
-					Kind:     firebird.SourceKind,
+					Type:     firebird.SourceType,
 					Host:     "my-host",
 					Port:     "my-port",
 					Database: "my_db",

internal/sources/firestore/firestore.go

@@ -31,14 +31,14 @@ import (
 	"google.golang.org/genproto/googleapis/type/latlng"
 )
 
-const SourceKind string = "firestore"
+const SourceType string = "firestore"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -53,14 +53,14 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 type Config struct {
 	// Firestore configs
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Project  string `yaml:"project" validate:"required"`
 	Database string `yaml:"database"` // Optional, defaults to "(default)"
 }
 
-func (r Config) SourceConfigKind() string {
+func (r Config) SourceConfigType() string {
 	// Returns Firestore source kind
-	return SourceKind
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -92,9 +92,9 @@ type Source struct {
 	RulesClient *firebaserules.Service
 }
 
-func (s *Source) SourceKind() string {
+func (s *Source) SourceType() string {
 	// Returns Firestore source kind
-	return SourceKind
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -594,7 +594,7 @@ func initFirestoreConnection(
 	project string,
 	database string,
 ) (*firestore.Client, error) {
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	userAgent, err := util.UserAgentFromContext(ctx)

internal/sources/firestore/firestore_test.go

@@ -42,7 +42,7 @@ func TestParseFromYamlFirestore(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-firestore": firestore.Config{
 					Name:     "my-firestore",
-					Kind:     firestore.SourceKind,
+					Type:     firestore.SourceType,
 					Project:  "my-project",
 					Database: "",
 				},
@@ -60,7 +60,7 @@ func TestParseFromYamlFirestore(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-firestore": firestore.Config{
 					Name:     "my-firestore",
-					Kind:     firestore.SourceKind,
+					Type:     firestore.SourceType,
 					Project:  "my-project",
 					Database: "my-database",
 				},

internal/sources/http/http.go

@@ -29,14 +29,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "http"
+const SourceType string = "http"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -50,7 +50,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name                   string            `yaml:"name" validate:"required"`
-	Kind                   string            `yaml:"kind" validate:"required"`
+	Type                   string            `yaml:"kind" validate:"required"`
 	BaseURL                string            `yaml:"baseUrl"`
 	Timeout                string            `yaml:"timeout"`
 	DefaultHeaders         map[string]string `yaml:"headers"`
@@ -58,8 +58,8 @@ type Config struct {
 	DisableSslVerification bool              `yaml:"disableSslVerification"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 // Initialize initializes an HTTP Source instance.
@@ -122,8 +122,8 @@ type Source struct {
 	client *http.Client
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/http/http_test.go

@@ -42,7 +42,7 @@ func TestParseFromYamlHttp(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-http-instance": http.Config{
 					Name:                   "my-http-instance",
-					Kind:                   http.SourceKind,
+					Type:                   http.SourceType,
 					BaseURL:                "http://test_server/",
 					Timeout:                "30s",
 					DisableSslVerification: false,
@@ -68,7 +68,7 @@ func TestParseFromYamlHttp(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-http-instance": http.Config{
 					Name:                   "my-http-instance",
-					Kind:                   http.SourceKind,
+					Type:                   http.SourceType,
 					BaseURL:                "http://test_server/",
 					Timeout:                "10s",
 					DefaultHeaders:         map[string]string{"Authorization": "test_header", "Custom-Header": "custom"},

internal/sources/looker/looker.go

@@ -33,14 +33,14 @@ import (
 	v4 "github.com/looker-open-source/sdk-codegen/go/sdk/v4"
 )
 
-const SourceKind string = "looker"
+const SourceType string = "looker"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -64,7 +64,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name               string `yaml:"name" validate:"required"`
-	Kind               string `yaml:"kind" validate:"required"`
+	Type               string `yaml:"kind" validate:"required"`
 	BaseURL            string `yaml:"base_url" validate:"required"`
 	ClientId           string `yaml:"client_id"`
 	ClientSecret       string `yaml:"client_secret"`
@@ -79,8 +79,8 @@ type Config struct {
 	SessionLength      int64  `yaml:"sessionLength"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 // Initialize initializes a Looker Source instance.
@@ -154,8 +154,8 @@ type Source struct {
 	AuthTokenHeaderName string
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/looker/looker_test.go

@@ -44,7 +44,7 @@ func TestParseFromYamlLooker(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-looker-instance": looker.Config{
 					Name:               "my-looker-instance",
-					Kind:               looker.SourceKind,
+					Type:               looker.SourceType,
 					BaseURL:            "http://example.looker.com/",
 					ClientId:           "jasdl;k;tjl",
 					ClientSecret:       "sdakl;jgflkasdfkfg",

internal/sources/mindsdb/mindsdb.go

@@ -27,14 +27,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "mindsdb"
+const SourceType string = "mindsdb"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -48,7 +48,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name         string `yaml:"name" validate:"required"`
-	Kind         string `yaml:"kind" validate:"required"`
+	Type         string `yaml:"kind" validate:"required"`
 	Host         string `yaml:"host" validate:"required"`
 	Port         string `yaml:"port" validate:"required"`
 	User         string `yaml:"user" validate:"required"`
@@ -57,8 +57,8 @@ type Config struct {
 	QueryTimeout string `yaml:"queryTimeout"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -86,8 +86,8 @@ type Source struct {
 	Pool *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -159,7 +159,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initMindsDBConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname, queryTimeout string) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Configure the driver to connect to the database

internal/sources/mindsdb/mindsdb_test.go

@@ -45,7 +45,7 @@ func TestParseFromYamlMindsDB(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mindsdb-instance": mindsdb.Config{
 					Name:     "my-mindsdb-instance",
-					Kind:     mindsdb.SourceKind,
+					Type:     mindsdb.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "my-port",
 					Database: "my_db",
@@ -70,7 +70,7 @@ func TestParseFromYamlMindsDB(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mindsdb-instance": mindsdb.Config{
 					Name:         "my-mindsdb-instance",
-					Kind:         mindsdb.SourceKind,
+					Type:         mindsdb.SourceType,
 					Host:         "0.0.0.0",
 					Port:         "my-port",
 					Database:     "my_db",

internal/sources/mongodb/mongodb.go

@@ -29,14 +29,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "mongodb"
+const SourceType string = "mongodb"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -50,12 +50,12 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name string `yaml:"name" validate:"required"`
-	Kind string `yaml:"kind" validate:"required"`
+	Type string `yaml:"kind" validate:"required"`
 	Uri  string `yaml:"uri" validate:"required"` // MongoDB Atlas connection URI
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -84,8 +84,8 @@ type Source struct {
 	Client *mongo.Client
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -293,7 +293,7 @@ func (s *Source) DeleteOne(ctx context.Context, filterString, database, collecti
 
 func initMongoDBClient(ctx context.Context, tracer trace.Tracer, name, uri string) (*mongo.Client, error) {
 	// Start a tracing span
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	userAgent, err := util.UserAgentFromContext(ctx)

internal/sources/mongodb/mongodb_test.go

@@ -41,7 +41,7 @@ func TestParseFromYamlMongoDB(t *testing.T) {
 			want: server.SourceConfigs{
 				"mongo-db": mongodb.Config{
 					Name: "mongo-db",
-					Kind: mongodb.SourceKind,
+					Type: mongodb.SourceType,
 					Uri:  "mongodb+srv://username:password@host/dbname",
 				},
 			},

internal/sources/mssql/mssql.go

@@ -28,14 +28,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "mssql"
+const SourceType string = "mssql"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -50,7 +50,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 type Config struct {
 	// Cloud SQL MSSQL configs
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Host     string `yaml:"host" validate:"required"`
 	Port     string `yaml:"port" validate:"required"`
 	User     string `yaml:"user" validate:"required"`
@@ -59,9 +59,9 @@ type Config struct {
 	Encrypt  string `yaml:"encrypt"`
 }
 
-func (r Config) SourceConfigKind() string {
+func (r Config) SourceConfigType() string {
 	// Returns Cloud SQL MSSQL source kind
-	return SourceKind
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -91,9 +91,9 @@ type Source struct {
 	Db *sql.DB
 }
 
-func (s *Source) SourceKind() string {
+func (s *Source) SourceType() string {
 	// Returns Cloud SQL MSSQL source kind
-	return SourceKind
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -156,7 +156,7 @@ func initMssqlConnection(
 	error,
 ) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	userAgent, err := util.UserAgentFromContext(ctx)

internal/sources/mssql/mssql_test.go

@@ -45,7 +45,7 @@ func TestParseFromYamlMssql(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mssql-instance": mssql.Config{
 					Name:     "my-mssql-instance",
-					Kind:     mssql.SourceKind,
+					Type:     mssql.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "my-port",
 					Database: "my_db",
@@ -70,7 +70,7 @@ func TestParseFromYamlMssql(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mssql-instance": mssql.Config{
 					Name:     "my-mssql-instance",
-					Kind:     mssql.SourceKind,
+					Type:     mssql.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "my-port",
 					Database: "my_db",

internal/sources/mysql/mysql.go

@@ -30,14 +30,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "mysql"
+const SourceType string = "mysql"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -51,7 +51,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name         string            `yaml:"name" validate:"required"`
-	Kind         string            `yaml:"kind" validate:"required"`
+	Type         string            `yaml:"kind" validate:"required"`
 	Host         string            `yaml:"host" validate:"required"`
 	Port         string            `yaml:"port" validate:"required"`
 	User         string            `yaml:"user" validate:"required"`
@@ -61,8 +61,8 @@ type Config struct {
 	QueryParams  map[string]string `yaml:"queryParams"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -90,8 +90,8 @@ type Source struct {
 	Pool *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -158,7 +158,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initMySQLConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname, queryTimeout string, queryParams map[string]string) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Build query parameters via url.Values for deterministic order and proper escaping.

internal/sources/mysql/mysql_test.go

@@ -50,7 +50,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mysql-instance": mysql.Config{
 					Name:     "my-mysql-instance",
-					Kind:     mysql.SourceKind,
+					Type:     mysql.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "my-port",
 					Database: "my_db",
@@ -75,7 +75,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mysql-instance": mysql.Config{
 					Name:         "my-mysql-instance",
-					Kind:         mysql.SourceKind,
+					Type:         mysql.SourceType,
 					Host:         "0.0.0.0",
 					Port:         "my-port",
 					Database:     "my_db",
@@ -103,7 +103,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-mysql-instance": mysql.Config{
 					Name:     "my-mysql-instance",
-					Kind:     mysql.SourceKind,
+					Type:     mysql.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "my-port",
 					Database: "my_db",
@@ -211,7 +211,7 @@ func TestFailInitialization(t *testing.T) {
 
 	cfg := mysql.Config{
 		Name:         "instance",
-		Kind:         "mysql",
+		Type:         "mysql",
 		Host:         "localhost",
 		Port:         "3306",
 		Database:     "db",

internal/sources/neo4j/neo4j.go

@@ -29,7 +29,7 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "neo4j"
+const SourceType string = "neo4j"
 
 var sourceClassifier *classifier.QueryClassifier = classifier.NewQueryClassifier()
 
@@ -37,8 +37,8 @@ var sourceClassifier *classifier.QueryClassifier = classifier.NewQueryClassifier
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -52,15 +52,15 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Uri      string `yaml:"uri" validate:"required"`
 	User     string `yaml:"user" validate:"required"`
 	Password string `yaml:"password" validate:"required"`
 	Database string `yaml:"database" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -91,8 +91,8 @@ type Source struct {
 	Driver neo4j.DriverWithContext
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -182,7 +182,7 @@ func addPlanChildren(p neo4j.Plan) []map[string]any {
 
 func initNeo4jDriver(ctx context.Context, tracer trace.Tracer, uri, user, password, name string) (neo4j.DriverWithContext, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	auth := neo4j.BasicAuth(user, password, "")

internal/sources/neo4j/neo4j_test.go

@@ -44,7 +44,7 @@ func TestParseFromYamlNeo4j(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-neo4j-instance": neo4j.Config{
 					Name:     "my-neo4j-instance",
-					Kind:     neo4j.SourceKind,
+					Type:     neo4j.SourceType,
 					Uri:      "neo4j+s://my-host:7687",
 					Database: "my_db",
 					User:     "my_user",

internal/sources/oceanbase/oceanbase.go

@@ -27,14 +27,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "oceanbase"
+const SourceType string = "oceanbase"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -48,7 +48,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name         string `yaml:"name" validate:"required"`
-	Kind         string `yaml:"kind" validate:"required"`
+	Type         string `yaml:"kind" validate:"required"`
 	Host         string `yaml:"host" validate:"required"`
 	Port         string `yaml:"port" validate:"required"`
 	User         string `yaml:"user" validate:"required"`
@@ -57,8 +57,8 @@ type Config struct {
 	QueryTimeout string `yaml:"queryTimeout"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -86,8 +86,8 @@ type Source struct {
 	Pool *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -153,7 +153,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 }
 
 func initOceanBaseConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname, queryTimeout string) (*sql.DB, error) {
-	_, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	_, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true", user, pass, host, port, dbname)

internal/sources/oceanbase/oceanbase_test.go

@@ -46,7 +46,7 @@ func TestParseFromYamlOceanBase(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-oceanbase-instance": oceanbase.Config{
 					Name:     "my-oceanbase-instance",
-					Kind:     oceanbase.SourceKind,
+					Type:     oceanbase.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "2881",
 					Database: "ob_db",
@@ -71,7 +71,7 @@ func TestParseFromYamlOceanBase(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-oceanbase-instance": oceanbase.Config{
 					Name:         "my-oceanbase-instance",
-					Kind:         oceanbase.SourceKind,
+					Type:         oceanbase.SourceType,
 					Host:         "0.0.0.0",
 					Port:         "2881",
 					Database:     "ob_db",

internal/sources/oracle/oracle.go

@@ -18,14 +18,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "oracle"
+const SourceType string = "oracle"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -45,7 +45,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name             string `yaml:"name" validate:"required"`
-	Kind             string `yaml:"kind" validate:"required"`
+	Type             string `yaml:"kind" validate:"required"`
 	ConnectionString string `yaml:"connectionString,omitempty"`
 	TnsAlias         string `yaml:"tnsAlias,omitempty"`
 	TnsAdmin         string `yaml:"tnsAdmin,omitempty"`
@@ -95,8 +95,8 @@ func (c Config) validate() error {
 	return nil
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -124,8 +124,8 @@ type Source struct {
 	DB *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -239,7 +239,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initOracleConnection(ctx context.Context, tracer trace.Tracer, config Config) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, config.Name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, config.Name)
 	defer span.End()
 
 	logger, err := util.LoggerFromContext(ctx)

internal/sources/oracle/oracle_test.go

@@ -33,7 +33,7 @@ func TestParseFromYamlOracle(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-oracle-cs": oracle.Config{
 					Name:             "my-oracle-cs",
-					Kind:             oracle.SourceKind,
+					Type:             oracle.SourceType,
 					ConnectionString: "my-host:1521/XEPDB1",
 					User:             "my_user",
 					Password:         "my_pass",
@@ -56,7 +56,7 @@ func TestParseFromYamlOracle(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-oracle-host": oracle.Config{
 					Name:        "my-oracle-host",
-					Kind:        oracle.SourceKind,
+					Type:        oracle.SourceType,
 					Host:        "my-host",
 					Port:        1521,
 					ServiceName: "ORCLPDB",
@@ -81,7 +81,7 @@ func TestParseFromYamlOracle(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-oracle-tns-oci": oracle.Config{
 					Name:     "my-oracle-tns-oci",
-					Kind:     oracle.SourceKind,
+					Type:     oracle.SourceType,
 					TnsAlias: "FINANCE_DB",
 					TnsAdmin: "/opt/oracle/network/admin",
 					User:     "my_user",

internal/sources/postgres/postgres.go

@@ -28,14 +28,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "postgres"
+const SourceType string = "postgres"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -49,7 +49,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name        string            `yaml:"name" validate:"required"`
-	Kind        string            `yaml:"kind" validate:"required"`
+	Type        string            `yaml:"kind" validate:"required"`
 	Host        string            `yaml:"host" validate:"required"`
 	Port        string            `yaml:"port" validate:"required"`
 	User        string            `yaml:"user" validate:"required"`
@@ -58,8 +58,8 @@ type Config struct {
 	QueryParams map[string]string `yaml:"queryParams"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -87,8 +87,8 @@ type Source struct {
 	Pool *pgxpool.Pool
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -128,7 +128,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initPostgresConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname string, queryParams map[string]string) (*pgxpool.Pool, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 	userAgent, err := util.UserAgentFromContext(ctx)
 	if err != nil {

internal/sources/postgres/postgres_test.go

@@ -47,7 +47,7 @@ func TestParseFromYamlPostgres(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-pg-instance": postgres.Config{
 					Name:     "my-pg-instance",
-					Kind:     postgres.SourceKind,
+					Type:     postgres.SourceType,
 					Host:     "my-host",
 					Port:     "my-port",
 					Database: "my_db",
@@ -74,7 +74,7 @@ func TestParseFromYamlPostgres(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-pg-instance": postgres.Config{
 					Name:     "my-pg-instance",
-					Kind:     postgres.SourceKind,
+					Type:     postgres.SourceType,
 					Host:     "my-host",
 					Port:     "my-port",
 					Database: "my_db",

internal/sources/redis/redis.go

@@ -24,14 +24,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "redis"
+const SourceType string = "redis"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -45,7 +45,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name           string   `yaml:"name" validate:"required"`
-	Kind           string   `yaml:"kind" validate:"required"`
+	Type           string   `yaml:"kind" validate:"required"`
 	Address        []string `yaml:"address" validate:"required"`
 	Username       string   `yaml:"username"`
 	Password       string   `yaml:"password"`
@@ -54,8 +54,8 @@ type Config struct {
 	ClusterEnabled bool     `yaml:"clusterEnabled"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 // RedisClient is an interface for `redis.Client` and `redis.ClusterClient
@@ -141,8 +141,8 @@ type Source struct {
 	Client RedisClient
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/redis/redis_test.go

@@ -43,7 +43,7 @@ func TestParseFromYamlRedis(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-redis-instance": redis.Config{
 					Name:           "my-redis-instance",
-					Kind:           redis.SourceKind,
+					Type:           redis.SourceType,
 					Address:        []string{"127.0.0.1"},
 					ClusterEnabled: false,
 					UseGCPIAM:      false,
@@ -66,7 +66,7 @@ func TestParseFromYamlRedis(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-redis-instance": redis.Config{
 					Name:           "my-redis-instance",
-					Kind:           redis.SourceKind,
+					Type:           redis.SourceType,
 					Address:        []string{"127.0.0.1"},
 					Password:       "my-pass",
 					Database:       1,

internal/sources/serverlessspark/serverlessspark.go

@@ -33,14 +33,14 @@ import (
 	"google.golang.org/protobuf/encoding/protojson"
 )
 
-const SourceKind string = "serverless-spark"
+const SourceType string = "serverless-spark"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -54,13 +54,13 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Project  string `yaml:"project" validate:"required"`
 	Location string `yaml:"location" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -94,8 +94,8 @@ type Source struct {
 	OpsClient *longrunning.OperationsClient
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/serverlessspark/serverlessspark_test.go

@@ -42,7 +42,7 @@ func TestParseFromYamlServerlessSpark(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-instance": serverlessspark.Config{
 					Name:     "my-instance",
-					Kind:     serverlessspark.SourceKind,
+					Type:     serverlessspark.SourceType,
 					Project:  "my-project",
 					Location: "my-location",
 				},

internal/sources/singlestore/singlestore.go

@@ -29,15 +29,15 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-// SourceKind for SingleStore source
-const SourceKind string = "singlestore"
+// SourceType for SingleStore source
+const SourceType string = "singlestore"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -52,7 +52,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 // Config holds the configuration parameters for connecting to a SingleStore database.
 type Config struct {
 	Name         string `yaml:"name" validate:"required"`
-	Kind         string `yaml:"kind" validate:"required"`
+	Type         string `yaml:"kind" validate:"required"`
 	Host         string `yaml:"host" validate:"required"`
 	Port         string `yaml:"port" validate:"required"`
 	User         string `yaml:"user" validate:"required"`
@@ -61,9 +61,9 @@ type Config struct {
 	QueryTimeout string `yaml:"queryTimeout"`
 }
 
-// SourceConfigKind returns the kind of the source configuration.
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+// SourceConfigType returns the kind of the source configuration.
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 // Initialize sets up the SingleStore connection pool and returns a Source.
@@ -93,9 +93,9 @@ type Source struct {
 	Pool *sql.DB
 }
 
-// SourceKind returns the kind of the source configuration.
-func (s *Source) SourceKind() string {
-	return SourceKind
+// SourceType returns the kind of the source configuration.
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -162,7 +162,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initSingleStoreConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname, queryTimeout string) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Configure the driver to connect to the database

internal/sources/singlestore/singlestore_test.go

@@ -45,7 +45,7 @@ func TestParseFromYaml(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-s2-instance": singlestore.Config{
 					Name:     "my-s2-instance",
-					Kind:     singlestore.SourceKind,
+					Type:     singlestore.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "my-port",
 					Database: "my_db",
@@ -70,7 +70,7 @@ func TestParseFromYaml(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-s2-instance": singlestore.Config{
 					Name:         "my-s2-instance",
-					Kind:         singlestore.SourceKind,
+					Type:         singlestore.SourceType,
 					Host:         "0.0.0.0",
 					Port:         "my-port",
 					Database:     "my_db",

internal/sources/snowflake/snowflake.go

@@ -25,14 +25,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "snowflake"
+const SourceType string = "snowflake"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -46,7 +46,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name      string `yaml:"name" validate:"required"`
-	Kind      string `yaml:"kind" validate:"required"`
+	Type      string `yaml:"kind" validate:"required"`
 	Account   string `yaml:"account" validate:"required"`
 	User      string `yaml:"user" validate:"required"`
 	Password  string `yaml:"password" validate:"required"`
@@ -56,8 +56,8 @@ type Config struct {
 	Role      string `yaml:"role"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -85,8 +85,8 @@ type Source struct {
 	DB *sqlx.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -137,7 +137,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initSnowflakeConnection(ctx context.Context, tracer trace.Tracer, name, account, user, password, database, schema, warehouse, role string) (*sqlx.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Set defaults for optional parameters

internal/sources/snowflake/snowflake_test.go

@@ -45,7 +45,7 @@ func TestParseFromYamlSnowflake(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-snowflake-instance": snowflake.Config{
 					Name:      "my-snowflake-instance",
-					Kind:      snowflake.SourceKind,
+					Type:      snowflake.SourceType,
 					Account:   "my-account",
 					User:      "my_user",
 					Password:  "my_pass",

internal/sources/sources.go

@@ -31,46 +31,46 @@ var sourceRegistry = make(map[string]SourceConfigFactory)
 
 // Register registers a new source kind with its factory.
 // It returns false if the kind is already registered.
-func Register(kind string, factory SourceConfigFactory) bool {
-	if _, exists := sourceRegistry[kind]; exists {
+func Register(sourceType string, factory SourceConfigFactory) bool {
+	if _, exists := sourceRegistry[sourceType]; exists {
 		// Source with this kind already exists, do not overwrite.
 		return false
 	}
-	sourceRegistry[kind] = factory
+	sourceRegistry[sourceType] = factory
 	return true
 }
 
 // DecodeConfig decodes a source configuration using the registered factory for the given kind.
-func DecodeConfig(ctx context.Context, kind string, name string, decoder *yaml.Decoder) (SourceConfig, error) {
-	factory, found := sourceRegistry[kind]
+func DecodeConfig(ctx context.Context, sourceType string, name string, decoder *yaml.Decoder) (SourceConfig, error) {
+	factory, found := sourceRegistry[sourceType]
 	if !found {
-		return nil, fmt.Errorf("unknown source kind: %q", kind)
+		return nil, fmt.Errorf("unknown source kind: %q", sourceType)
 	}
 	sourceConfig, err := factory(ctx, name, decoder)
 	if err != nil {
-		return nil, fmt.Errorf("unable to parse source %q as %q: %w", name, kind, err)
+		return nil, fmt.Errorf("unable to parse source %q as %q: %w", name, sourceType, err)
 	}
 	return sourceConfig, err
 }
 
 // SourceConfig is the interface for configuring a source.
 type SourceConfig interface {
-	SourceConfigKind() string
+	SourceConfigType() string
 	Initialize(ctx context.Context, tracer trace.Tracer) (Source, error)
 }
 
 // Source is the interface for the source itself.
 type Source interface {
-	SourceKind() string
+	SourceType() string
 	ToConfig() SourceConfig
 }
 
 // InitConnectionSpan adds a span for database pool connection initialization
-func InitConnectionSpan(ctx context.Context, tracer trace.Tracer, sourceKind, sourceName string) (context.Context, trace.Span) {
+func InitConnectionSpan(ctx context.Context, tracer trace.Tracer, sourceType, sourceName string) (context.Context, trace.Span) {
 	ctx, span := tracer.Start(
 		ctx,
 		"toolbox/server/source/connect",
-		trace.WithAttributes(attribute.String("source_kind", sourceKind)),
+		trace.WithAttributes(attribute.String("source_type", sourceType)),
 		trace.WithAttributes(attribute.String("source_name", sourceName)),
 	)
 	return ctx, span

internal/sources/spanner/spanner.go

@@ -28,14 +28,14 @@ import (
 	"google.golang.org/api/iterator"
 )
 
-const SourceKind string = "spanner"
+const SourceType string = "spanner"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -49,15 +49,15 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string          `yaml:"name" validate:"required"`
-	Kind     string          `yaml:"kind" validate:"required"`
+	Type     string          `yaml:"kind" validate:"required"`
 	Project  string          `yaml:"project" validate:"required"`
 	Instance string          `yaml:"instance" validate:"required"`
 	Dialect  sources.Dialect `yaml:"dialect" validate:"required"`
 	Database string          `yaml:"database" validate:"required"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -80,8 +80,8 @@ type Source struct {
 	Client *spanner.Client
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -171,7 +171,7 @@ func (s *Source) RunSQL(ctx context.Context, readOnly bool, statement string, pa
 
 func initSpannerClient(ctx context.Context, tracer trace.Tracer, name, project, instance, dbname string) (*spanner.Client, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Configure the connection to the database

internal/sources/spanner/spanner_test.go

@@ -44,7 +44,7 @@ func TestParseFromYamlSpannerDb(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-spanner-instance": spanner.Config{
 					Name:     "my-spanner-instance",
-					Kind:     spanner.SourceKind,
+					Type:     spanner.SourceType,
 					Project:  "my-project",
 					Instance: "my-instance",
 					Dialect:  "googlesql",
@@ -66,7 +66,7 @@ func TestParseFromYamlSpannerDb(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-spanner-instance": spanner.Config{
 					Name:     "my-spanner-instance",
-					Kind:     spanner.SourceKind,
+					Type:     spanner.SourceType,
 					Project:  "my-project",
 					Instance: "my-instance",
 					Dialect:  "googlesql",
@@ -88,7 +88,7 @@ func TestParseFromYamlSpannerDb(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-spanner-instance": spanner.Config{
 					Name:     "my-spanner-instance",
-					Kind:     spanner.SourceKind,
+					Type:     spanner.SourceType,
 					Project:  "my-project",
 					Instance: "my-instance",
 					Dialect:  "postgresql",

internal/sources/sqlite/sqlite.go

@@ -27,14 +27,14 @@ import (
 	_ "modernc.org/sqlite" // Pure Go SQLite driver
 )
 
-const SourceKind string = "sqlite"
+const SourceType string = "sqlite"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -48,12 +48,12 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Database string `yaml:"database" validate:"required"` // Path to SQLite database file
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -81,8 +81,8 @@ type Source struct {
 	Db *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -155,7 +155,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initSQLiteConnection(ctx context.Context, tracer trace.Tracer, name, dbPath string) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Open database connection

internal/sources/sqlite/sqlite_test.go

@@ -42,7 +42,7 @@ func TestParseFromYamlSQLite(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-sqlite-db": sqlite.Config{
 					Name:     "my-sqlite-db",
-					Kind:     sqlite.SourceKind,
+					Type:     sqlite.SourceType,
 					Database: "/path/to/database.db",
 				},
 			},

internal/sources/tidb/tidb.go

@@ -27,15 +27,15 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "tidb"
+const SourceType string = "tidb"
 const TiDBCloudHostPattern string = `gateway\d{2}\.(.+)\.(prod|dev|staging)\.(.+)\.tidbcloud\.com`
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -55,7 +55,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name     string `yaml:"name" validate:"required"`
-	Kind     string `yaml:"kind" validate:"required"`
+	Type     string `yaml:"kind" validate:"required"`
 	Host     string `yaml:"host" validate:"required"`
 	Port     string `yaml:"port" validate:"required"`
 	User     string `yaml:"user" validate:"required"`
@@ -64,8 +64,8 @@ type Config struct {
 	UseSSL   bool   `yaml:"ssl"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -93,8 +93,8 @@ type Source struct {
 	Pool *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -189,7 +189,7 @@ func IsTiDBCloudHost(host string) bool {
 
 func initTiDBConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname string, useSSL bool) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Configure the driver to connect to the database

internal/sources/tidb/tidb_test.go

@@ -45,7 +45,7 @@ func TestParseFromYamlTiDB(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-tidb-instance": tidb.Config{
 					Name:     "my-tidb-instance",
-					Kind:     tidb.SourceKind,
+					Type:     tidb.SourceType,
 					Host:     "0.0.0.0",
 					Port:     "my-port",
 					Database: "my_db",
@@ -71,7 +71,7 @@ func TestParseFromYamlTiDB(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-tidb-cloud": tidb.Config{
 					Name:     "my-tidb-cloud",
-					Kind:     tidb.SourceKind,
+					Type:     tidb.SourceType,
 					Host:     "gateway01.us-west-2.prod.aws.tidbcloud.com",
 					Port:     "4000",
 					Database: "test_db",
@@ -96,7 +96,7 @@ func TestParseFromYamlTiDB(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-tidb-cloud": tidb.Config{
 					Name:     "my-tidb-cloud",
-					Kind:     tidb.SourceKind,
+					Type:     tidb.SourceType,
 					Host:     "gateway01.us-west-2.prod.aws.tidbcloud.com",
 					Port:     "4000",
 					Database: "test_db",

internal/sources/trino/trino.go

@@ -30,14 +30,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "trino"
+const SourceType string = "trino"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -51,7 +51,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name                   string `yaml:"name" validate:"required"`
-	Kind                   string `yaml:"kind" validate:"required"`
+	Type                   string `yaml:"kind" validate:"required"`
 	Host                   string `yaml:"host" validate:"required"`
 	Port                   string `yaml:"port" validate:"required"`
 	User                   string `yaml:"user"`
@@ -67,8 +67,8 @@ type Config struct {
 	DisableSslVerification bool   `yaml:"disableSslVerification"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -96,8 +96,8 @@ type Source struct {
 	Pool *sql.DB
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -160,7 +160,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initTrinoConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, password, catalog, schema, queryTimeout, accessToken string, kerberosEnabled, sslEnabled bool, sslCertPath, sslCert string, disableSslVerification bool) (*sql.DB, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 
 	// Build Trino DSN

internal/sources/trino/trino_test.go

@@ -165,7 +165,7 @@ func TestParseFromYamlTrino(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-trino-instance": Config{
 					Name:    "my-trino-instance",
-					Kind:    SourceKind,
+					Type:    SourceType,
 					Host:    "localhost",
 					Port:    "8080",
 					User:    "testuser",
@@ -194,7 +194,7 @@ func TestParseFromYamlTrino(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-trino-instance": Config{
 					Name:            "my-trino-instance",
-					Kind:            SourceKind,
+					Type:            SourceType,
 					Host:            "localhost",
 					Port:            "8443",
 					User:            "testuser",
@@ -222,7 +222,7 @@ func TestParseFromYamlTrino(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-trino-anonymous": Config{
 					Name:    "my-trino-anonymous",
-					Kind:    SourceKind,
+					Type:    SourceType,
 					Host:    "localhost",
 					Port:    "8080",
 					Catalog: "hive",
@@ -252,7 +252,7 @@ func TestParseFromYamlTrino(t *testing.T) {
 			want: server.SourceConfigs{
 				"my-trino-ssl-cert": Config{
 					Name:                   "my-trino-ssl-cert",
-					Kind:                   SourceKind,
+					Type:                   SourceType,
 					Host:                   "localhost",
 					Port:                   "8443",
 					User:                   "testuser",

internal/sources/valkey/valkey.go

@@ -24,14 +24,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "valkey"
+const SourceType string = "valkey"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -45,7 +45,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name         string   `yaml:"name" validate:"required"`
-	Kind         string   `yaml:"kind" validate:"required"`
+	Type         string   `yaml:"kind" validate:"required"`
 	Address      []string `yaml:"address" validate:"required"`
 	Username     string   `yaml:"username"`
 	Password     string   `yaml:"password"`
@@ -54,8 +54,8 @@ type Config struct {
 	DisableCache bool     `yaml:"disableCache"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -114,8 +114,8 @@ type Source struct {
 	Client valkey.Client
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {

internal/sources/valkey/valkey_test.go

@@ -44,7 +44,7 @@ func TestParseFromYamlValkey(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-valkey-instance": valkey.Config{
 					Name:         "my-valkey-instance",
-					Kind:         valkey.SourceKind,
+					Type:         valkey.SourceType,
 					Address:      []string{"127.0.0.1"},
 					Username:     "",
 					Password:     "",
@@ -71,7 +71,7 @@ func TestParseFromYamlValkey(t *testing.T) {
 			want: map[string]sources.SourceConfig{
 				"my-valkey-instance": valkey.Config{
 					Name:         "my-valkey-instance",
-					Kind:         valkey.SourceKind,
+					Type:         valkey.SourceType,
 					Address:      []string{"127.0.0.1"},
 					Username:     "user",
 					Password:     "pass",

internal/sources/yugabytedb/yugabytedb.go

@@ -24,14 +24,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 )
 
-const SourceKind string = "yugabytedb"
+const SourceType string = "yugabytedb"
 
 // validate interface
 var _ sources.SourceConfig = Config{}
 
 func init() {
-	if !sources.Register(SourceKind, newConfig) {
-		panic(fmt.Sprintf("source kind %q already registered", SourceKind))
+	if !sources.Register(SourceType, newConfig) {
+		panic(fmt.Sprintf("source type %q already registered", SourceType))
 	}
 }
 
@@ -45,7 +45,7 @@ func newConfig(ctx context.Context, name string, decoder *yaml.Decoder) (sources
 
 type Config struct {
 	Name                            string `yaml:"name" validate:"required"`
-	Kind                            string `yaml:"kind" validate:"required"`
+	Type                            string `yaml:"kind" validate:"required"`
 	Host                            string `yaml:"host" validate:"required"`
 	Port                            string `yaml:"port" validate:"required"`
 	User                            string `yaml:"user" validate:"required"`
@@ -58,8 +58,8 @@ type Config struct {
 	FailedHostReconnectDelaySeconds string `yaml:"failedHostReconnectDelaySecs"`
 }
 
-func (r Config) SourceConfigKind() string {
-	return SourceKind
+func (r Config) SourceConfigType() string {
+	return SourceType
 }
 
 func (r Config) Initialize(ctx context.Context, tracer trace.Tracer) (sources.Source, error) {
@@ -87,8 +87,8 @@ type Source struct {
 	Pool *pgxpool.Pool
 }
 
-func (s *Source) SourceKind() string {
-	return SourceKind
+func (s *Source) SourceType() string {
+	return SourceType
 }
 
 func (s *Source) ToConfig() sources.SourceConfig {
@@ -130,7 +130,7 @@ func (s *Source) RunSQL(ctx context.Context, statement string, params []any) (an
 
 func initYugabyteDBConnectionPool(ctx context.Context, tracer trace.Tracer, name, host, port, user, pass, dbname, loadBalance, topologyKeys, refreshInterval, explicitFallback, failedHostTTL string) (*pgxpool.Pool, error) {
 	//nolint:all // Reassigned ctx
-	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceKind, name)
+	ctx, span := sources.InitConnectionSpan(ctx, tracer, SourceType, name)
 	defer span.End()
 	// urlExample := "postgres://username:password@localhost:5433/database_name"
 	i := fmt.Sprintf("postgres://%s:%s@%s:%s/%s", user, pass, host, port, dbname)