support export filter

Author: freeznet

docs/tools/functions_as_tools.md

@@ -71,27 +71,32 @@ If these custom options are not provided, the MCP tool name might default to a d
 
 Beyond customizing individual tool properties at the function deployment level, you can also configure the overall behavior of the "Functions as Tools" feature on the StreamNative MCP Server side using the following environment variables. These variables are typically set when starting the MCP server.
 
-*   `PULSAR_FUNCTIONS_POLL_INTERVAL`
+*   `FUNCTIONS_AS_TOOLS_POLL_INTERVAL`
     *   **Description**: Controls how frequently the MCP Server polls the Pulsar cluster to discover or update available Pulsar Functions. Setting a lower value means functions are discovered faster, but it may increase the load on the Pulsar cluster.
     *   **Unit**: Seconds
     *   **Default**: Defaults to the value specified in `pftools.DefaultManagerOptions()`. Refer to the `pkg/pftools` package for the precise default (e.g., if the internal default is 60 seconds, it will be `60`).
-*   `PULSAR_FUNCTIONS_TIMEOUT`
+*   `FUNCTIONS_AS_TOOLS_TIMEOUT`
     *   **Description**: Sets the default timeout for invoking a Pulsar Function as an MCP tool. If a function execution exceeds this duration, the call will be considered timed out.
     *   **Unit**: Seconds
     *   **Default**: Defaults to the value specified in `pftools.DefaultManagerOptions()` (e.g., if the internal default is 30 seconds, it will be `30`).
-*   `PULSAR_FUNCTIONS_FAILURE_THRESHOLD`
-    *   **Description**: Defines the number of consecutive failures for a specific Pulsar Function tool before it is temporarily moved to a "circuit breaker open" state. In this state, further calls to this specific function tool will be immediately rejected without attempting to execute the function, until the `PULSAR_FUNCTIONS_RESET_TIMEOUT` is reached.
+*   `FUNCTIONS_AS_TOOLS_FAILURE_THRESHOLD`
+    *   **Description**: Defines the number of consecutive failures for a specific Pulsar Function tool before it is temporarily moved to a "circuit breaker open" state. In this state, further calls to this specific function tool will be immediately rejected without attempting to execute the function, until the `FUNCTIONS_AS_TOOLS_RESET_TIMEOUT` is reached.
     *   **Unit**: Integer (number of failures)
     *   **Default**: Defaults to the value specified in `pftools.DefaultManagerOptions()` (e.g., if the internal default is 5, it will be `5`).
-*   `PULSAR_FUNCTIONS_RESET_TIMEOUT`
+*   `FUNCTIONS_AS_TOOLS_RESET_TIMEOUT`
     *   **Description**: Specifies the duration for which a Pulsar Function tool remains in the "circuit breaker open" state (due to exceeding the failure threshold) before the MCP server attempts to reset the circuit and allow calls again.
     *   **Unit**: Seconds
     *   **Default**: Defaults to the value specified in `pftools.DefaultManagerOptions()` (e.g., if the internal default is 60 seconds, it will be `60`).
-*   `PULSAR_FUNCTIONS_TENANT_NAMESPACES`
+*   `FUNCTIONS_AS_TOOLS_TENANT_NAMESPACES`
     *   **Description**: A comma-separated list of Pulsar `tenant/namespace` strings that the MCP Server should scan for Pulsar Functions. This allows you to restrict function discovery to specific namespaces. If not set, the server might attempt to discover functions from all namespaces it has access to, as permitted by its Pulsar client configuration.
     *   **Format**: `tenant1/namespace1,tenant2/namespace2`
     *   **Example**: `public/default,my-tenant/app-functions`
     *   **Default**: Empty (meaning discover from all accessible namespaces (only on StreamNative Cloud)).
+*   `FUNCTIONS_AS_TOOLS_STRICT_EXPORT`
+    *   **Description**: Only export functions with `MCP_TOOL_NAME` and `MCP_TOOL_DESCRIPTION` defined. 
+    *   **Format**: `true` or `false`
+    *   **Example**: `false`
+    *   **Default**: `true`
 
 ## Considerations and Limitations
 

pkg/mcp/pulsar_functions_as_tools.go

@@ -61,39 +61,44 @@ func PulsarFunctionManagedMcpTools(s *server.MCPServer, readOnly bool, features
 
 	options := pftools.DefaultManagerOptions()
 
-	if pollIntervalStr := os.Getenv("PULSAR_FUNCTIONS_POLL_INTERVAL"); pollIntervalStr != "" {
+	if pollIntervalStr := os.Getenv("FUNCTIONS_AS_TOOLS_POLL_INTERVAL"); pollIntervalStr != "" {
 		if seconds, err := strconv.Atoi(pollIntervalStr); err == nil && seconds > 0 {
 			options.PollInterval = time.Duration(seconds) * time.Second
 			log.Printf("Setting Pulsar Functions poll interval to %v", options.PollInterval)
 		}
 	}
 
-	if timeoutStr := os.Getenv("PULSAR_FUNCTIONS_TIMEOUT"); timeoutStr != "" {
+	if timeoutStr := os.Getenv("FUNCTIONS_AS_TOOLS_TIMEOUT"); timeoutStr != "" {
 		if seconds, err := strconv.Atoi(timeoutStr); err == nil && seconds > 0 {
 			options.DefaultTimeout = time.Duration(seconds) * time.Second
 			log.Printf("Setting Pulsar Functions default timeout to %v", options.DefaultTimeout)
 		}
 	}
 
-	if failureThresholdStr := os.Getenv("PULSAR_FUNCTIONS_FAILURE_THRESHOLD"); failureThresholdStr != "" {
+	if failureThresholdStr := os.Getenv("FUNCTIONS_AS_TOOLS_FAILURE_THRESHOLD"); failureThresholdStr != "" {
 		if threshold, err := strconv.Atoi(failureThresholdStr); err == nil && threshold > 0 {
 			options.FailureThreshold = threshold
 			log.Printf("Setting Pulsar Functions failure threshold to %d", options.FailureThreshold)
 		}
 	}
 
-	if resetTimeoutStr := os.Getenv("PULSAR_FUNCTIONS_RESET_TIMEOUT"); resetTimeoutStr != "" {
+	if resetTimeoutStr := os.Getenv("FUNCTIONS_AS_TOOLS_RESET_TIMEOUT"); resetTimeoutStr != "" {
 		if seconds, err := strconv.Atoi(resetTimeoutStr); err == nil && seconds > 0 {
 			options.ResetTimeout = time.Duration(seconds) * time.Second
 			log.Printf("Setting Pulsar Functions reset timeout to %v", options.ResetTimeout)
 		}
 	}
 
-	if tenantNamespacesStr := os.Getenv("PULSAR_FUNCTIONS_TENANT_NAMESPACES"); tenantNamespacesStr != "" {
+	if tenantNamespacesStr := os.Getenv("FUNCTIONS_AS_TOOLS_TENANT_NAMESPACES"); tenantNamespacesStr != "" {
 		options.TenantNamespaces = strings.Split(tenantNamespacesStr, ",")
 		log.Printf("Setting Pulsar Functions tenant namespaces to %v", options.TenantNamespaces)
 	}
 
+	if strictExportStr := os.Getenv("FUNCTIONS_AS_TOOLS_STRICT_EXPORT"); strictExportStr != "" {
+		options.StrictExport = strictExportStr == "true"
+		log.Printf("Setting Pulsar Functions strict export to %v", options.StrictExport)
+	}
+
 	manager, err := pftools.NewPulsarFunctionManager(s, readOnly, options)
 	if err != nil {
 		log.Printf("Failed to create Pulsar Function manager: %v", err)
@@ -102,7 +107,7 @@ func PulsarFunctionManagedMcpTools(s *server.MCPServer, readOnly bool, features
 
 	manager.Start()
 
-	managerID := "pulsar_functions_manager_" + strconv.FormatInt(time.Now().UnixNano(), 10)
+	managerID := "FUNCTIONS_AS_TOOLS_manager_" + strconv.FormatInt(time.Now().UnixNano(), 10)
 	functionManagersLock.Lock()
 	functionManagers[managerID] = manager
 	functionManagersLock.Unlock()

pkg/pftools/manager.go

@@ -82,6 +82,7 @@ func NewPulsarFunctionManager(mcpServer *server.MCPServer, readOnly bool, option
 		defaultTimeout:    options.DefaultTimeout,
 		circuitBreakers:   make(map[string]*CircuitBreaker),
 		tenantNamespaces:  options.TenantNamespaces,
+		strictExport:      options.StrictExport,
 	}
 
 	return manager, nil
@@ -230,6 +231,11 @@ func (m *PulsarFunctionManager) getFunctionsList() ([]*utils.FunctionConfig, err
 	}
 
 	for _, fn := range allFunctions {
+		if m.strictExport &&
+			!strings.Contains(fn.CustomRuntimeOptions, CustomRuntimeOptionsEnvMcpToolNameKey) &&
+			!strings.Contains(fn.CustomRuntimeOptions, CustomRuntimeOptionsEnvMcpToolDescriptionKey) {
+			continue
+		}
 		status, err := m.adminClient.Functions().GetFunctionStatus(fn.Tenant, fn.Namespace, fn.Name)
 		if err != nil {
 			continue

pkg/pftools/types.go

@@ -44,6 +44,7 @@ type PulsarFunctionManager struct {
 	defaultTimeout    time.Duration
 	circuitBreakers   map[string]*CircuitBreaker
 	tenantNamespaces  []string
+	strictExport      bool
 }
 
 type FunctionTool struct {
@@ -86,6 +87,7 @@ type ManagerOptions struct {
 	FailureThreshold int
 	ResetTimeout     time.Duration
 	TenantNamespaces []string
+	StrictExport     bool
 }
 
 func DefaultManagerOptions() *ManagerOptions {
@@ -95,5 +97,6 @@ func DefaultManagerOptions() *ManagerOptions {
 		FailureThreshold: 5,
 		ResetTimeout:     60 * time.Second,
 		TenantNamespaces: []string{},
+		StrictExport:     false,
 	}
 }