feat: add option to disable automatic MCP tool injection per request

Pratham-Mishra04 · Pratham-Mishra04 · commit b515efc75aa2 · 2026-03-05T18:13:43.000+05:30
diff --git a/core/bifrost.go b/core/bifrost.go
@@ -3174,7 +3174,7 @@ func (bifrost *Bifrost) getProviderMutex(providerKey schemas.ModelProvider) *syn
 //	    }, toolSchema)
 func (bifrost *Bifrost) RegisterMCPTool(name, description string, handler func(args any) (string, error), toolSchema schemas.ChatTool) error {
 	if bifrost.MCPManager == nil {
-		return fmt.Errorf("MCP is not configured in this Bifrost instance")
+		return fmt.Errorf("mcp is not configured in this bifrost instance")
 	}
 
 	return bifrost.MCPManager.RegisterTool(name, description, handler, toolSchema)
@@ -3192,7 +3192,7 @@ func (bifrost *Bifrost) RegisterMCPTool(name, description string, handler func(a
 //   - error: Any retrieval error
 func (bifrost *Bifrost) GetMCPClients() ([]schemas.MCPClient, error) {
 	if bifrost.MCPManager == nil {
-		return nil, fmt.Errorf("MCP is not configured in this Bifrost instance")
+		return nil, fmt.Errorf("mcp is not configured in this bifrost instance")
 	}
 
 	clients := bifrost.MCPManager.GetClients()
@@ -3303,7 +3303,7 @@ func (bifrost *Bifrost) AddMCPClient(config *schemas.MCPClientConfig) error {
 //	}
 func (bifrost *Bifrost) RemoveMCPClient(id string) error {
 	if bifrost.MCPManager == nil {
-		return fmt.Errorf("MCP is not configured in this Bifrost instance")
+		return fmt.Errorf("mcp is not configured in this bifrost instance")
 	}
 
 	return bifrost.MCPManager.RemoveClient(id)
@@ -3336,7 +3336,7 @@ func (bifrost *Bifrost) SetMCPManager(manager mcp.MCPManagerInterface) {
 //	})
 func (bifrost *Bifrost) UpdateMCPClient(id string, updatedConfig *schemas.MCPClientConfig) error {
 	if bifrost.MCPManager == nil {
-		return fmt.Errorf("MCP is not configured in this Bifrost instance")
+		return fmt.Errorf("mcp is not configured in this bifrost instance")
 	}
 
 	return bifrost.MCPManager.UpdateClient(id, updatedConfig)
@@ -3351,7 +3351,7 @@ func (bifrost *Bifrost) UpdateMCPClient(id string, updatedConfig *schemas.MCPCli
 //   - error: Any reconnection error
 func (bifrost *Bifrost) ReconnectMCPClient(id string) error {
 	if bifrost.MCPManager == nil {
-		return fmt.Errorf("MCP is not configured in this Bifrost instance")
+		return fmt.Errorf("mcp is not configured in this bifrost instance")
 	}
 
 	return bifrost.MCPManager.ReconnectClient(id)
@@ -3361,7 +3361,7 @@ func (bifrost *Bifrost) ReconnectMCPClient(id string) error {
 // This allows for hot-reloading of the tool manager config at runtime.
 func (bifrost *Bifrost) UpdateToolManagerConfig(maxAgentDepth int, toolExecutionTimeoutInSeconds int, codeModeBindingLevel string) error {
 	if bifrost.MCPManager == nil {
-		return fmt.Errorf("MCP is not configured in this Bifrost instance")
+		return fmt.Errorf("mcp is not configured in this bifrost instance")
 	}
 
 	bifrost.MCPManager.UpdateToolManagerConfig(&schemas.MCPToolManagerConfig{
@@ -3372,6 +3372,16 @@ func (bifrost *Bifrost) UpdateToolManagerConfig(maxAgentDepth int, toolExecution
 	return nil
 }
 
+// UpdateMCPDisableAutoToolInject updates the auto tool injection toggle at runtime.
+// This allows for hot-reloading without a server restart.
+func (bifrost *Bifrost) UpdateMCPDisableAutoToolInject(val bool) error {
+	if bifrost.MCPManager == nil {
+		return fmt.Errorf("mcp is not configured in this bifrost instance")
+	}
+	bifrost.MCPManager.UpdateDisableAutoToolInject(val)
+	return nil
+}
+
 // PROVIDER MANAGEMENT
 
 // createBaseProvider creates a provider based on the base provider type
@@ -5086,7 +5096,7 @@ func (bifrost *Bifrost) handleMCPToolExecution(ctx *schemas.BifrostContext, mcpR
 		return nil, &schemas.BifrostError{
 			IsBifrostError: false,
 			Error: &schemas.ErrorField{
-				Message: "MCP is not configured in this Bifrost instance",
+				Message: "mcp is not configured in this bifrost instance",
 			},
 			ExtraFields: schemas.BifrostErrorExtraFields{
 				RequestType: requestType,
diff --git a/core/changelog.md b/core/changelog.md
@@ -1,2 +1,3 @@
+- feat: add DisableAutoToolInject to MCPToolManagerConfig to suppress automatic MCP tool injection per request
 - feat: add Filename field to TranscriptionInput schema to carry original filename through the request pipeline
 - fix: add AudioFilenameFromBytes utility to detect audio format from file headers with mp3 fallback
diff --git a/core/mcp/interface.go b/core/mcp/interface.go
@@ -25,6 +25,9 @@ type MCPManagerInterface interface {
 	// UpdateToolManagerConfig updates the configuration for the tool manager
 	UpdateToolManagerConfig(config *schemas.MCPToolManagerConfig)
 
+	// UpdateDisableAutoToolInject updates the global auto tool injection toggle at runtime
+	UpdateDisableAutoToolInject(val bool)
+
 	// Agent Mode Operations
 	// CheckAndExecuteAgentForChatRequest handles agent mode for Chat Completions API
 	CheckAndExecuteAgentForChatRequest(
diff --git a/core/mcp/mcp.go b/core/mcp/mcp.go
@@ -174,6 +174,13 @@ func (m *MCPManager) UpdateToolManagerConfig(config *schemas.MCPToolManagerConfi
 	m.toolsManager.UpdateConfig(config)
 }
 
+// UpdateDisableAutoToolInject updates the global auto tool injection toggle at runtime.
+// When val is true, MCP tools are not injected into requests unless an explicit
+// context filter (MCPContextKeyIncludeTools or MCPContextKeyIncludeClients) is set.
+func (m *MCPManager) UpdateDisableAutoToolInject(val bool) {
+	m.toolsManager.UpdateDisableAutoToolInject(val)
+}
+
 // CheckAndExecuteAgentForChatRequest checks if the chat response contains tool calls,
 // and if so, executes agent mode to handle the tool calls iteratively. If no tool calls
 // are present, it returns the original response unchanged.
diff --git a/core/mcp/toolmanager.go b/core/mcp/toolmanager.go
@@ -30,9 +30,10 @@ type PluginPipeline interface {
 
 // ToolsManager manages MCP tool execution and agent mode.
 type ToolsManager struct {
-	toolExecutionTimeout atomic.Value
-	maxAgentDepth        atomic.Int32
-	clientManager        ClientManager
+	toolExecutionTimeout  atomic.Value
+	maxAgentDepth         atomic.Int32
+	disableAutoToolInject atomic.Bool
+	clientManager         ClientManager
 	logger               schemas.Logger
 	agentModeExecutor    *AgentModeExecutor
 
@@ -146,6 +147,7 @@ func NewToolsManagerWithCodeMode(
 	// Initialize atomic values
 	manager.toolExecutionTimeout.Store(config.ToolExecutionTimeout)
 	manager.maxAgentDepth.Store(int32(config.MaxAgentDepth))
+	manager.disableAutoToolInject.Store(config.DisableAutoToolInject)
 
 	manager.logger.Info("%s tool manager initialized with tool execution timeout: %v, max agent depth: %d, and code mode binding level: %s", MCPLogPrefix, config.ToolExecutionTimeout, config.MaxAgentDepth, config.CodeModeBindingLevel)
 	return manager
@@ -293,6 +295,16 @@ func (m *ToolsManager) ParseAndAddToolsToRequest(ctx context.Context, req *schem
 		return req
 	}
 
+	// When auto tool injection is disabled, only inject tools if the request
+	// has explicit context filters set (e.g. via x-bf-mcp-include-tools header).
+	if m.disableAutoToolInject.Load() {
+		includeTools := ctx.Value(MCPContextKeyIncludeTools)
+		includeClients := ctx.Value(MCPContextKeyIncludeClients)
+		if includeTools == nil && includeClients == nil {
+			return req
+		}
+	}
+
 	availableTools := m.GetAvailableTools(ctx)
 
 	if len(availableTools) == 0 {
@@ -659,9 +671,17 @@ func (m *ToolsManager) UpdateConfig(config *schemas.MCPToolManagerConfig) {
 		})
 	}
 
+	m.disableAutoToolInject.Store(config.DisableAutoToolInject)
+
 	m.logger.Info("%s tool manager configuration updated with tool execution timeout: %v, max agent depth: %d, and code mode binding level: %s", MCPLogPrefix, config.ToolExecutionTimeout, config.MaxAgentDepth, config.CodeModeBindingLevel)
 }
 
+// UpdateDisableAutoToolInject updates the auto tool injection toggle atomically.
+// This method is safe to call concurrently from multiple goroutines.
+func (m *ToolsManager) UpdateDisableAutoToolInject(val bool) {
+	m.disableAutoToolInject.Store(val)
+}
+
 // GetCodeModeBindingLevel returns the current code mode binding level.
 // This method is safe to call concurrently from multiple goroutines.
 func (m *ToolsManager) GetCodeModeBindingLevel() schemas.CodeModeBindingLevel {
diff --git a/core/schemas/mcp.go b/core/schemas/mcp.go
@@ -47,9 +47,10 @@ type MCPConfig struct {
 }
 
 type MCPToolManagerConfig struct {
-	ToolExecutionTimeout time.Duration        `json:"tool_execution_timeout"`
-	MaxAgentDepth        int                  `json:"max_agent_depth"`
-	CodeModeBindingLevel CodeModeBindingLevel `json:"code_mode_binding_level,omitempty"` // How tools are exposed in VFS: "server" or "tool"
+	ToolExecutionTimeout  time.Duration        `json:"tool_execution_timeout"`
+	MaxAgentDepth         int                  `json:"max_agent_depth"`
+	CodeModeBindingLevel  CodeModeBindingLevel `json:"code_mode_binding_level,omitempty"` // How tools are exposed in VFS: "server" or "tool"
+	DisableAutoToolInject bool                 `json:"disable_auto_tool_inject,omitempty"` // When true, MCP tools are not injected into requests by default
 }
 
 const (
diff --git a/framework/changelog.md b/framework/changelog.md
@@ -0,0 +1 @@
+- feat: add MCPDisableAutoToolInject column to TableClientConfig
diff --git a/framework/configstore/clientconfig.go b/framework/configstore/clientconfig.go
@@ -54,7 +54,8 @@ type ClientConfig struct {
 	MCPAgentDepth           int                              `json:"mcp_agent_depth"`                     // The maximum depth for MCP agent mode tool execution
 	MCPToolExecutionTimeout int                              `json:"mcp_tool_execution_timeout"`          // The timeout for individual tool execution in seconds
 	MCPCodeModeBindingLevel string                           `json:"mcp_code_mode_binding_level"`         // Code mode binding level: "server" or "tool"
-	MCPToolSyncInterval     int                              `json:"mcp_tool_sync_interval"`              // Global tool sync interval in minutes (default: 10, 0 = disabled)
+	MCPToolSyncInterval        int                              `json:"mcp_tool_sync_interval"`                 // Global tool sync interval in minutes (default: 10, 0 = disabled)
+	MCPDisableAutoToolInject   bool                             `json:"mcp_disable_auto_tool_inject"`           // When true, MCP tools are not injected into requests by default
 	HeaderFilterConfig      *tables.GlobalHeaderFilterConfig `json:"header_filter_config,omitempty"`      // Global header filtering configuration for x-bf-eh-* headers
 	AsyncJobResultTTL       int                              `json:"async_job_result_ttl"`                // Default TTL for async job results in seconds (default: 3600 = 1 hour)
 	RequiredHeaders         []string                         `json:"required_headers,omitempty"`          // Headers that must be present on every request (case-insensitive)
@@ -134,6 +135,12 @@ func (c *ClientConfig) GenerateClientConfigHash() (string, error) {
 		hash.Write([]byte("mcpToolSyncInterval:0"))
 	}
 
+	if c.MCPDisableAutoToolInject {
+		hash.Write([]byte("mcpDisableAutoToolInject:true"))
+	} else {
+		hash.Write([]byte("mcpDisableAutoToolInject:false"))
+	}
+
 	if c.AsyncJobResultTTL > 0 {
 		hash.Write([]byte("asyncJobResultTTL:" + strconv.Itoa(c.AsyncJobResultTTL)))
 	} else {
diff --git a/framework/configstore/migrations.go b/framework/configstore/migrations.go
@@ -296,6 +296,9 @@ func triggerMigrations(ctx context.Context, db *gorm.DB) error {
 	if err := migrationAddBedrockAssumeRoleColumns(ctx, db); err != nil {
 		return err
 	}
+	if err := migrationAddMCPDisableAutoToolInjectColumn(ctx, db); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -4173,3 +4176,33 @@ func migrationAddBedrockAssumeRoleColumns(ctx context.Context, db *gorm.DB) erro
 	}
 	return nil
 }
+
+// migrationAddMCPDisableAutoToolInjectColumn adds the mcp_disable_auto_tool_inject column to the client config table.
+// When true, MCP tools are not automatically injected into requests; only explicit context filters apply.
+func migrationAddMCPDisableAutoToolInjectColumn(ctx context.Context, db *gorm.DB) error {
+	m := migrator.New(db, migrator.DefaultOptions, []*migrator.Migration{{
+		ID: "add_mcp_disable_auto_tool_inject_column",
+		Migrate: func(tx *gorm.DB) error {
+			tx = tx.WithContext(ctx)
+			migratorInstance := tx.Migrator()
+			if !migratorInstance.HasColumn(&tables.TableClientConfig{}, "mcp_disable_auto_tool_inject") {
+				if err := migratorInstance.AddColumn(&tables.TableClientConfig{}, "mcp_disable_auto_tool_inject"); err != nil {
+					return err
+				}
+			}
+			return nil
+		},
+		Rollback: func(tx *gorm.DB) error {
+			tx = tx.WithContext(ctx)
+			migratorInstance := tx.Migrator()
+			if err := migratorInstance.DropColumn(&tables.TableClientConfig{}, "mcp_disable_auto_tool_inject"); err != nil {
+				return err
+			}
+			return nil
+		},
+	}})
+	if err := m.Migrate(); err != nil {
+		return fmt.Errorf("error while running mcp disable auto tool inject migration: %s", err.Error())
+	}
+	return nil
+}
diff --git a/framework/configstore/rdb.go b/framework/configstore/rdb.go
@@ -56,7 +56,8 @@ func (s *RDBConfigStore) UpdateClientConfig(ctx context.Context, config *ClientC
 		MCPAgentDepth:           config.MCPAgentDepth,
 		MCPToolExecutionTimeout: config.MCPToolExecutionTimeout,
 		MCPCodeModeBindingLevel: config.MCPCodeModeBindingLevel,
-		MCPToolSyncInterval:     config.MCPToolSyncInterval,
+		MCPToolSyncInterval:        config.MCPToolSyncInterval,
+		MCPDisableAutoToolInject:   config.MCPDisableAutoToolInject,
 		AsyncJobResultTTL:       config.AsyncJobResultTTL,
 		RequiredHeaders:         config.RequiredHeaders,
 		LoggingHeaders:          config.LoggingHeaders,
@@ -221,8 +222,9 @@ func (s *RDBConfigStore) GetClientConfig(ctx context.Context) (*ClientConfig, er
 		MCPAgentDepth:           dbConfig.MCPAgentDepth,
 		MCPToolExecutionTimeout: dbConfig.MCPToolExecutionTimeout,
 		MCPCodeModeBindingLevel: dbConfig.MCPCodeModeBindingLevel,
-		MCPToolSyncInterval:     dbConfig.MCPToolSyncInterval,
-		AsyncJobResultTTL:       dbConfig.AsyncJobResultTTL,
+		MCPToolSyncInterval:        dbConfig.MCPToolSyncInterval,
+		MCPDisableAutoToolInject:   dbConfig.MCPDisableAutoToolInject,
+		AsyncJobResultTTL:          dbConfig.AsyncJobResultTTL,
 		RequiredHeaders:         dbConfig.RequiredHeaders,
 		LoggingHeaders:          dbConfig.LoggingHeaders,
 		HeaderFilterConfig:      dbConfig.HeaderFilterConfig,
@@ -894,9 +896,10 @@ func (s *RDBConfigStore) GetMCPConfig(ctx context.Context) (*schemas.MCPConfig,
 		return nil, err
 	}
 	toolManagerConfig := schemas.MCPToolManagerConfig{
-		ToolExecutionTimeout: time.Duration(clientConfig.MCPToolExecutionTimeout) * time.Second,
-		MaxAgentDepth:        clientConfig.MCPAgentDepth,
-		CodeModeBindingLevel: schemas.CodeModeBindingLevel(clientConfig.MCPCodeModeBindingLevel),
+		ToolExecutionTimeout:    time.Duration(clientConfig.MCPToolExecutionTimeout) * time.Second,
+		MaxAgentDepth:           clientConfig.MCPAgentDepth,
+		CodeModeBindingLevel:    schemas.CodeModeBindingLevel(clientConfig.MCPCodeModeBindingLevel),
+		DisableAutoToolInject:   clientConfig.MCPDisableAutoToolInject,
 	}
 	clientConfigs := make([]*schemas.MCPClientConfig, len(dbMCPClients))
 	for i, dbClient := range dbMCPClients {
diff --git a/framework/configstore/tables/clientconfig.go b/framework/configstore/tables/clientconfig.go
@@ -28,7 +28,8 @@ type TableClientConfig struct {
 	MCPAgentDepth           int    `gorm:"default:10" json:"mcp_agent_depth"`
 	MCPToolExecutionTimeout int    `gorm:"default:30" json:"mcp_tool_execution_timeout"`      // Timeout for individual tool execution in seconds (default: 30)
 	MCPCodeModeBindingLevel string `gorm:"default:server" json:"mcp_code_mode_binding_level"` // How tools are exposed in VFS: "server" or "tool"
-	MCPToolSyncInterval     int    `gorm:"default:10" json:"mcp_tool_sync_interval"`          // Global tool sync interval in minutes (default: 10, 0 = disabled)
+	MCPToolSyncInterval        int  `gorm:"default:10" json:"mcp_tool_sync_interval"`             // Global tool sync interval in minutes (default: 10, 0 = disabled)
+	MCPDisableAutoToolInject   bool `gorm:"default:false" json:"mcp_disable_auto_tool_inject"`    // When true, MCP tools are not injected into requests by default
 	AsyncJobResultTTL       int    `gorm:"default:3600" json:"async_job_result_ttl"`          // Default TTL for async job results in seconds (default: 3600 = 1 hour)
 	RequiredHeadersJSON     string `gorm:"type:text" json:"-"`                                // JSON serialized []string
 	LoggingHeadersJSON      string `gorm:"type:text" json:"-"`                                // JSON serialized []string
diff --git a/transports/bifrost-http/handlers/config.go b/transports/bifrost-http/handlers/config.go
@@ -48,6 +48,7 @@ type ConfigManager interface {
 	ForceReloadPricing(ctx context.Context) error
 	UpdateDropExcessRequests(ctx context.Context, value bool)
 	UpdateMCPToolManagerConfig(ctx context.Context, maxAgentDepth int, toolExecutionTimeoutInSeconds int, codeModeBindingLevel string) error
+	UpdateMCPDisableAutoToolInject(ctx context.Context, val bool) error
 	ReloadPlugin(ctx context.Context, name string, path *string, pluginConfig any) error
 	RemovePlugin(ctx context.Context, name string) error
 	ReloadProxyConfig(ctx context.Context, config *configstoreTables.GlobalProxyConfig) error
@@ -285,6 +286,16 @@ func (h *ConfigHandler) updateConfig(ctx *fasthttp.RequestCtx) {
 		}
 	}
 
+	// Handle MCPDisableAutoToolInject toggle (bool — always sync regardless of value)
+	if payload.ClientConfig.MCPDisableAutoToolInject != currentConfig.MCPDisableAutoToolInject && h.store.MCPConfig != nil {
+		if err := h.configManager.UpdateMCPDisableAutoToolInject(ctx, payload.ClientConfig.MCPDisableAutoToolInject); err != nil {
+			logger.Warn(fmt.Sprintf("failed to update mcp disable auto tool inject: %v", err))
+			SendError(ctx, fasthttp.StatusInternalServerError, fmt.Sprintf("failed to update mcp disable auto tool inject: %v", err))
+			return
+		}
+	}
+	updatedConfig.MCPDisableAutoToolInject = payload.ClientConfig.MCPDisableAutoToolInject
+
 	if !slices.Equal(payload.ClientConfig.PrometheusLabels, currentConfig.PrometheusLabels) {
 		updatedConfig.PrometheusLabels = payload.ClientConfig.PrometheusLabels
 		restartReasons = append(restartReasons, "Prometheus labels")
diff --git a/transports/bifrost-http/lib/config_test.go b/transports/bifrost-http/lib/config_test.go
@@ -14957,7 +14957,8 @@ var excludedGoFields = map[string]map[string]bool{
 		"mcp_agent_depth":             true, // Managed via MCP config
 		"mcp_code_mode_binding_level": true,
 		"mcp_tool_execution_timeout":  true,
-		"mcp_tool_sync_interval":      true,
+		"mcp_tool_sync_interval":        true,
+		"mcp_disable_auto_tool_inject":  true,
 	},
 	"configstore.ProviderConfig": {"ConfigHash": true},
 	// GovernanceConfig - some fields are internal/enterprise
diff --git a/transports/bifrost-http/server/server.go b/transports/bifrost-http/server/server.go
@@ -87,6 +87,7 @@ type ServerCallbacks interface {
 	RemoveMCPClient(ctx context.Context, id string) error
 	UpdateMCPClient(ctx context.Context, id string, updatedConfig *schemas.MCPClientConfig) error
 	UpdateMCPToolManagerConfig(ctx context.Context, maxAgentDepth int, toolExecutionTimeoutInSeconds int, codeModeBindingLevel string) error
+	UpdateMCPDisableAutoToolInject(ctx context.Context, val bool) error
 	ReconnectMCPClient(ctx context.Context, id string) error
 	// Logging related callbacks
 	NewLogEntryAdded(ctx context.Context, logEntry *logstore.Log) error
@@ -700,6 +701,14 @@ func (s *BifrostHTTPServer) UpdateMCPToolManagerConfig(ctx context.Context, maxA
 	return s.Client.UpdateToolManagerConfig(maxAgentDepth, toolExecutionTimeoutInSeconds, codeModeBindingLevel)
 }
 
+// UpdateMCPDisableAutoToolInject updates the auto tool injection toggle
+func (s *BifrostHTTPServer) UpdateMCPDisableAutoToolInject(ctx context.Context, val bool) error {
+	if s.Config == nil {
+		return fmt.Errorf("config not found")
+	}
+	return s.Client.UpdateMCPDisableAutoToolInject(val)
+}
+
 // reloadObservabilityPlugins reloads all observability plugins in the tracing middleware
 func (s *BifrostHTTPServer) reloadObservabilityPlugins() {
 	observabilityPlugins := s.CollectObservabilityPlugins()
diff --git a/transports/changelog.md b/transports/changelog.md
@@ -1 +1,2 @@
+-feat: add option to disable automatic MCP tool injection per request
 - fix: preserve original audio filename in transcription requests
diff --git a/transports/config.schema.json b/transports/config.schema.json
@@ -168,6 +168,11 @@
           "minimum": 0,
           "description": "Global tool sync interval in minutes (0 = disabled)",
           "default": 10
+        },
+        "mcp_disable_auto_tool_inject": {
+          "type": "boolean",
+          "description": "When true, MCP tools are not automatically injected into requests. Tools are only included when explicitly specified via request context (x-bf-mcp-include-tools or x-bf-mcp-include-clients headers).",
+          "default": false
         }
       },
       "additionalProperties": false
diff --git a/transports/schema_test/config_schema_test.go b/transports/schema_test/config_schema_test.go
diff --git a/ui/app/workspace/config/views/mcpView.tsx b/ui/app/workspace/config/views/mcpView.tsx
diff --git a/ui/lib/types/config.ts b/ui/lib/types/config.ts
diff --git a/ui/lib/types/schemas.ts b/ui/lib/types/schemas.ts

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
	`1`	`+- feat: add DisableAutoToolInject to MCPToolManagerConfig to suppress automatic MCP tool injection per request`
`1`	`2`	`- feat: add Filename field to TranscriptionInput schema to carry original filename through the request pipeline`
`2`	`3`	`- fix: add AudioFilenameFromBytes utility to detect audio format from file headers with mp3 fallback`
Original file line number	Diff line number	Diff line change
`@@ -47,9 +47,10 @@ type MCPConfig struct {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`type MCPToolManagerConfig struct {`
`50`		- ToolExecutionTimeout time.Duration `json:"tool_execution_timeout"`
`51`		- MaxAgentDepth int `json:"max_agent_depth"`
`52`		- CodeModeBindingLevel CodeModeBindingLevel `json:"code_mode_binding_level,omitempty"` // How tools are exposed in VFS: "server" or "tool"
	`50`	+ ToolExecutionTimeout time.Duration `json:"tool_execution_timeout"`
	`51`	+ MaxAgentDepth int `json:"max_agent_depth"`
	`52`	+ CodeModeBindingLevel CodeModeBindingLevel `json:"code_mode_binding_level,omitempty"` // How tools are exposed in VFS: "server" or "tool"
	`53`	+ DisableAutoToolInject bool `json:"disable_auto_tool_inject,omitempty"` // When true, MCP tools are not injected into requests by default
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`const (`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+- feat: add MCPDisableAutoToolInject column to TableClientConfig`