diff --git a/‎cmd/internal/flags.go‎
Lines changed: 0 additions & 1 deletion b/‎cmd/internal/flags.go‎
Lines changed: 0 additions & 1 deletion
diff --git a/‎cmd/root_test.go‎
Lines changed: 0 additions & 7 deletions b/‎cmd/root_test.go‎
Lines changed: 0 additions & 7 deletions
diff --git a/‎docs/en/reference/cli.md‎
Lines changed: 0 additions & 32 deletions b/‎docs/en/reference/cli.md‎
Lines changed: 0 additions & 32 deletions
diff --git a/‎internal/server/config.go‎
Lines changed: 0 additions & 2 deletions b/‎internal/server/config.go‎
Lines changed: 0 additions & 2 deletions
diff --git a/‎internal/server/primitives/primitives_test.go‎
Lines changed: 9 additions & 8 deletions b/‎internal/server/primitives/primitives_test.go‎
Lines changed: 9 additions & 8 deletions
diff --git a/‎internal/server/server.go‎
Lines changed: 1 addition & 4 deletions b/‎internal/server/server.go‎
Lines changed: 1 addition & 4 deletions
diff --git a/‎internal/server/server_test.go‎
Lines changed: 6 additions & 166 deletions b/‎internal/server/server_test.go‎
Lines changed: 6 additions & 166 deletions
@@ -79,5 +79,4 @@ func ServeFlags(flags *pflag.FlagSet, opts *ToolboxOptions) {
 	flags.BoolVar(&opts.Cfg.EnableDraftSpecs, "enable-draft-specs", false, "Opt-in and test upcoming draft MCP specifications.")
 	flags.StringSliceVar(&opts.Cfg.DisableExt, "disable-ext", []string{}, "Specifies MCP extension URIs disabled on this server.")
 	flags.StringVar(&opts.Cfg.OpenAIAppsChallengeFile, "openai-apps-challenge-file", "", "Path to a file containing the OpenAI verification challenge token to serve at /.well-known/openai-apps-challenge.")
-	flags.BoolVar(&opts.Cfg.DeferSourceConnect, "defer-source-connect", false, "Connect to each source on first use instead of at startup. Tools can be listed without any source being reachable.")
 }
@@ -304,13 +304,6 @@ func TestServerConfigFlags(t *testing.T) {
 				OpenAIAppsChallengeFile: "openai-token.txt",
 			}),
 		},
-		{
-			desc: "defer source connect",
-			args: []string{"--defer-source-connect"},
-			want: withDefaults(server.ServerConfig{
-				DeferSourceConnect: true,
-			}),
-		},
 	}
 	for _, tc := range tcs {
 		t.Run(tc.desc, func(t *testing.T) {
 
@@ -11,7 +11,6 @@ description: >
 | Flag (Short) | Flag (Long)                | Description                                                                                                                                                               | Default     |
 |--------------|----------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------|
 | `-a`         | `--address`                | Address of the interface the server will listen on.                                                                                                                       | `127.0.0.1` |
-|              | `--defer-source-connect`   | Connect to each source on first use instead of at startup.                                                                                                                | `false`     |
 |              | `--disable-ext`            | Specifies MCP extension URIs disabled on this server.                                                                                                                     |             |
 |              | `--disable-reload`         | Disables dynamic reloading config.                                                                                                                                        |             |
 | `-h`         | `--help`                   | help for toolbox                                                                                                                                                          |             |
@@ -246,37 +245,6 @@ To launch Toolbox's interactive UI, use the `--ui` flag. This allows you to test
 tools and toolsets with features such as authorized parameters. To learn more,
 visit [Toolbox UI](../documentation/configuration/toolbox-ui/index.md).
 
-### Deferring Source Connections
-
-By default Toolbox connects to every configured source at startup and fails to
-start if any connection fails. Pass `--defer-source-connect` to defer each
-connection until the first tool call that needs it.
-
-```bash
-./toolbox --tools-file tools.yaml --defer-source-connect
-```
-
-This is useful when you want to inspect a tool catalog without provisioning
-databases, when cold start time matters, or when you would rather a broken
-source surface as a tool error the agent can read than as a server that never
-comes up. With the flag set:
-
-* Toolbox starts even when no source is reachable, and `tools/list` and
-  `/api/toolset` return the full catalog with complete schemas.
-* The first call to a tool connects its source. If that fails, the call returns
-  a tool error containing the connection failure and the server stays up. Only
-  successful connections are kept, so a source that comes up later starts
-  working without a restart.
-* A tool naming a source that does not exist, or one whose type it cannot use,
-  is still rejected at startup.
-
-Configuration is still validated at startup. A malformed value — an unparseable
-`queryTimeout`, an invalid `writeMode` — fails immediately, because detecting it
-takes no network.
-
-Environment variables are still required, since a source cannot connect without
-them, and an unset one fails startup as it does today.
-
 ### Disabling MCP Extensions
 
 By default, Toolbox advertises support for its own custom MCP extensions (e.g., `com.google.cloud/toolbox.v1`) during the client discovery phase. This extension signals to clients that they can leverage Toolbox-specific features that fall outside the official MCP specification (see the [Extension README](https://github.com/googleapis/mcp-toolbox/blob/main/extensions/2026-07-28/README.md) for a list of currently supported capabilities).
 
@@ -114,8 +114,6 @@ type ServerConfig struct {
 	DisableVersionCheck bool
 	// OpenAIAppsChallengeFile specifies the path to a file containing the OpenAI verification challenge token to serve at /.well-known/openai-apps-challenge.
 	OpenAIAppsChallengeFile string
-	// DeferSourceConnect connects each source on first use instead of at startup.
-	DeferSourceConnect bool
 }
 
 type logFormat string
 
@@ -25,16 +25,17 @@ import (
 	"github.com/googleapis/mcp-toolbox/internal/resources"
 	"github.com/googleapis/mcp-toolbox/internal/server/primitives"
 	"github.com/googleapis/mcp-toolbox/internal/sources"
+	"github.com/googleapis/mcp-toolbox/internal/sources/alloydbpg"
 	"github.com/googleapis/mcp-toolbox/internal/testutils"
 	"github.com/googleapis/mcp-toolbox/internal/tools"
 )
 
 func TestUpdateServer(t *testing.T) {
 	newSources := map[string]sources.Source{
-		"example-source": testutils.MockSource{
-			MockSourceConfig: testutils.MockSourceConfig{
-				Name: "example-source",
-				Type: "mock-source",
+		"example-source": &alloydbpg.Source{
+			Config: alloydbpg.Config{
+				Name: "example-alloydb-source",
+				Type: "alloydb-postgres",
 			},
 		},
 	}
@@ -88,10 +89,10 @@ func TestUpdateServer(t *testing.T) {
 		t.Errorf("error updating server, resource templates (-want +got):\n%s", diff)
 	}
 	updateSource := map[string]sources.Source{
-		"example-source2": testutils.MockSource{
-			MockSourceConfig: testutils.MockSourceConfig{
-				Name: "example-source2",
-				Type: "mock-source",
+		"example-source2": &alloydbpg.Source{
+			Config: alloydbpg.Config{
+				Name: "example-alloydb-source2",
+				Type: "alloydb-postgres",
 			},
 		},
 	}
 
@@ -117,7 +117,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) (
 				trace.WithAttributes(attribute.String("source_name", name)),
 			)
 			defer span.End()
-			s, err := sc.Initialize(childCtx, instrumentation.Tracer, cfg.DeferSourceConnect)
+			s, err := sc.Initialize(childCtx, instrumentation.Tracer)
 			if err != nil {
 				return nil, fmt.Errorf("unable to initialize source %q: %w", name, err)
 			}
@@ -133,9 +133,6 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) (
 		sourceNames = append(sourceNames, name)
 	}
 	l.InfoContext(ctx, fmt.Sprintf("Initialized %d sources: %s", len(sourcesMap), strings.Join(sourceNames, ", ")))
-	if cfg.DeferSourceConnect {
-		l.InfoContext(ctx, "Source connections are deferred; each source connects on first use.")
-	}
 
 	// initialize and validate the auth services from configs
 	authServicesMap := make(map[string]auth.AuthService)
 
@@ -24,7 +24,6 @@ import (
 	"crypto/x509/pkix"
 	"encoding/json"
 	"encoding/pem"
-	"errors"
 	"fmt"
 	"io"
 	"math/big"
@@ -35,7 +34,6 @@ import (
 	"reflect"
 	"slices"
 	"strings"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -54,7 +52,7 @@ import (
 	"github.com/googleapis/mcp-toolbox/internal/server"
 	v20260728 "github.com/googleapis/mcp-toolbox/internal/server/mcp/v20260728"
 	"github.com/googleapis/mcp-toolbox/internal/sources"
-	_ "github.com/googleapis/mcp-toolbox/internal/sources/alloydbpg"
+	"github.com/googleapis/mcp-toolbox/internal/sources/alloydbpg"
 	_ "github.com/googleapis/mcp-toolbox/internal/sources/postgres"
 	_ "github.com/googleapis/mcp-toolbox/internal/sources/sqlite"
 	"github.com/googleapis/mcp-toolbox/internal/telemetry"
@@ -64,7 +62,6 @@ import (
 	"github.com/googleapis/mcp-toolbox/internal/tools/mysql/mysqlexecutesql"
 	"github.com/googleapis/mcp-toolbox/internal/tools/postgres/postgresexecutesql"
 	"github.com/googleapis/mcp-toolbox/internal/util"
-	"go.opentelemetry.io/otel/trace"
 )
 
 // Helper function to create temporary self-signed certs for the test
@@ -418,10 +415,10 @@ func TestUpdateServer(t *testing.T) {
 	}
 
 	newSources := map[string]sources.Source{
-		"example-source": testutils.MockSource{
-			MockSourceConfig: testutils.MockSourceConfig{
-				Name: "example-source",
-				Type: "mock-source",
+		"example-source": &alloydbpg.Source{
+			Config: alloydbpg.Config{
+				Name: "example-alloydb-source",
+				Type: "alloydb-postgres",
 			},
 		},
 	}
@@ -1515,7 +1512,7 @@ func TestInitializeConfigs(t *testing.T) {
 	ctx = util.WithInstrumentation(ctx, instrumentation)
 	t.Run("valid initialization", func(t *testing.T) {
 		sourceConfig1 := testutils.MockSourceConfig{Name: "my-source", Type: "mock-source"}
-		source1, _ := sourceConfig1.Initialize(ctx, nil, false)
+		source1, _ := sourceConfig1.Initialize(ctx, nil)
 		tools1 := testutils.NewMockTool("my-tool", "mock tool for offline config", "my-source", nil, false, false)
 		validCfg := server.ServerConfig{
 			Version: "0.0.0",
@@ -2275,160 +2272,3 @@ func TestOpenAIAppsChallenge(t *testing.T) {
 		}
 	})
 }
-
-var errSourceUnreachable = errors.New("source is unreachable")
-
-// countingSourceConfig mirrors the shape every real source implements: it
-// returns its Source without connecting when deferConnect is set, and resolves
-// the handle through sources.ConnectOnce on first use.
-type countingSourceConfig struct {
-	name       string
-	connectErr error
-	connects   *atomic.Int32
-}
-
-func (c countingSourceConfig) SourceConfigType() string { return "counting-source" }
-
-func (c countingSourceConfig) Initialize(ctx context.Context, tracer trace.Tracer, deferConnect bool) (sources.Source, error) {
-	s := &countingSource{
-		cfg:  c,
-		conn: sources.NewConnectOnce[*int](ctx, c.name, "counting-source", tracer),
-	}
-	if deferConnect {
-		return s, nil
-	}
-	if _, err := s.handle(ctx); err != nil {
-		return nil, err
-	}
-	return s, nil
-}
-
-type countingSource struct {
-	cfg  countingSourceConfig
-	conn *sources.ConnectOnce[*int]
-}
-
-func (s *countingSource) handle(ctx context.Context) (*int, error) {
-	return s.conn.Do(ctx, func(ctx context.Context) (*int, error) {
-		s.cfg.connects.Add(1)
-		if s.cfg.connectErr != nil {
-			return nil, s.cfg.connectErr
-		}
-		return new(int), nil
-	})
-}
-
-func (s *countingSource) SourceType() string             { return "counting-source" }
-func (s *countingSource) ToConfig() sources.SourceConfig { return s.cfg }
-func (s *countingSource) IsReadOnly() bool               { return false }
-
-func TestInitializeConfigsDeferSourceConnect(t *testing.T) {
-	ctx, err := testutils.ContextWithNewLogger()
-	if err != nil {
-		t.Fatalf("error setting up logger: %s", err)
-	}
-	instrumentation, err := telemetry.CreateTelemetryInstrumentation("0.0.0")
-	if err != nil {
-		t.Fatalf("unexpected error: %s", err)
-	}
-	ctx = util.WithInstrumentation(ctx, instrumentation)
-
-	newCfg := func(deferConnect bool, connects *atomic.Int32, connectErr error) server.ServerConfig {
-		return server.ServerConfig{
-			Version: "0.0.0",
-			SourceConfigs: server.SourceConfigs{
-				"my-source": countingSourceConfig{name: "my-source", connectErr: connectErr, connects: connects},
-			},
-			DeferSourceConnect:   deferConnect,
-			SkipSourceValidation: true,
-		}
-	}
-
-	tcs := []struct {
-		desc         string
-		deferConnect bool
-		connectErr   error
-		wantErr      bool
-		wantConnects int32
-	}{
-		{
-			desc:         "flag off connects at startup",
-			deferConnect: false,
-			wantConnects: 1,
-		},
-		{
-			desc:         "flag off fails startup when the source is unreachable",
-			deferConnect: false,
-			connectErr:   errSourceUnreachable,
-			wantErr:      true,
-			wantConnects: 1,
-		},
-		{
-			desc:         "flag on skips connecting at startup",
-			deferConnect: true,
-			wantConnects: 0,
-		},
-		{
-			desc:         "flag on starts up even when the source is unreachable",
-			deferConnect: true,
-			connectErr:   errSourceUnreachable,
-			wantConnects: 0,
-		},
-	}
-	for _, tc := range tcs {
-		t.Run(tc.desc, func(t *testing.T) {
-			var connects atomic.Int32
-			sourcesMap, _, _, _, _, _, _, _, err := server.InitializeConfigs(ctx, newCfg(tc.deferConnect, &connects, tc.connectErr))
-			switch {
-			case tc.wantErr && err == nil:
-				t.Fatalf("expected an error but got nil")
-			case tc.wantErr && !errors.Is(err, tc.connectErr):
-				t.Fatalf("expected the connect failure to surface, got %q", err)
-			case !tc.wantErr && err != nil:
-				t.Fatalf("unexpected error: %s", err)
-			}
-			if got := connects.Load(); got != tc.wantConnects {
-				t.Fatalf("connect attempts during startup: got %d, want %d", got, tc.wantConnects)
-			}
-			if tc.wantErr {
-				return
-			}
-			// A deferred source is still listed, so its tools stay invocable.
-			if _, ok := sourcesMap["my-source"]; !ok {
-				t.Fatalf("expected %q in the sources map, got %v", "my-source", sourcesMap)
-			}
-		})
-	}
-
-	t.Run("flag on connects once on first use", func(t *testing.T) {
-		var connects atomic.Int32
-		sourcesMap, _, _, _, _, _, _, _, err := server.InitializeConfigs(ctx, newCfg(true, &connects, nil))
-		if err != nil {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		s := sourcesMap["my-source"].(*countingSource)
-		for i := range 3 {
-			if _, err := s.handle(ctx); err != nil {
-				t.Fatalf("use %d failed: %s", i, err)
-			}
-		}
-		if got := connects.Load(); got != 1 {
-			t.Fatalf("connect attempts across three uses: got %d, want 1", got)
-		}
-	})
-
-	t.Run("flag on surfaces the connect failure at first use", func(t *testing.T) {
-		var connects atomic.Int32
-		sourcesMap, _, _, _, _, _, _, _, err := server.InitializeConfigs(ctx, newCfg(true, &connects, errSourceUnreachable))
-		if err != nil {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		s := sourcesMap["my-source"].(*countingSource)
-		if _, err := s.handle(ctx); !errors.Is(err, errSourceUnreachable) {
-			t.Fatalf("expected the connect failure at first use, got %q", err)
-		}
-		if got := connects.Load(); got != 1 {
-			t.Fatalf("connect attempts: got %d, want 1", got)
-		}
-	})
-}