feat(adk): optimize filesystem

Author: meguminnnnnnnnn

adk/filesystem/backend.go

@@ -272,16 +272,10 @@ type ExecuteResponse struct {
 	Truncated bool   // Whether the output was truncated
 }
 
-// ShellBackend is a shell backend interface that extends Backend and adds command execution functionality.
-type ShellBackend interface {
-	Backend
-	// Execute executes a command and returns the result.
+type Shell interface {
 	Execute(ctx context.Context, input *ExecuteRequest) (result *ExecuteResponse, err error)
 }
 
-// StreamingShellBackend is a streaming shell backend interface that supports streaming command execution results.
-type StreamingShellBackend interface {
-	Backend
-	// ExecuteStreaming executes a command in streaming mode and returns the result.
+type StreamingShell interface {
 	ExecuteStreaming(ctx context.Context, input *ExecuteRequest) (result *schema.StreamReader[*ExecuteResponse], err error)
 }

adk/middlewares/filesystem/backend.go

@@ -18,8 +18,6 @@
 package filesystem
 
 import (
-	"context"
-
 	"github.com/cloudwego/eino/adk/filesystem"
 )
 
@@ -31,49 +29,3 @@ type GrepRequest = filesystem.GrepRequest
 type GlobInfoRequest = filesystem.GlobInfoRequest
 type WriteRequest = filesystem.WriteRequest
 type EditRequest = filesystem.EditRequest
-
-// Backend is a pluggable, unified file backend protocol interface.
-//
-// All methods use struct-based parameters to allow future extensibility
-// without breaking backward compatibility.
-type Backend interface {
-	// LsInfo lists file information under the given path.
-	//
-	// Returns:
-	//   - []FileInfo: List of matching file information
-	//   - error: Error if the operation fails
-	LsInfo(ctx context.Context, req *LsInfoRequest) ([]FileInfo, error)
-
-	// Read reads file content with support for line-based offset and limit.
-	//
-	// Returns:
-	//   - string: The file content read
-	//   - error: Error if file does not exist or read fails
-	Read(ctx context.Context, req *ReadRequest) (string, error)
-
-	// GrepRaw searches for content matching the specified pattern in files.
-	//
-	// Returns:
-	//   - []GrepMatch: List of all matching results
-	//   - error: Error if the search fails
-	GrepRaw(ctx context.Context, req *GrepRequest) ([]GrepMatch, error)
-
-	// GlobInfo returns file information matching the glob pattern.
-	//
-	// Returns:
-	//   - []FileInfo: List of matching file information
-	//   - error: Error if the pattern is invalid or operation fails
-	GlobInfo(ctx context.Context, req *GlobInfoRequest) ([]FileInfo, error)
-
-	// Write creates or updates file content.
-	//
-	// Returns:
-	//   - error: Error if the write operation fails
-	Write(ctx context.Context, req *WriteRequest) error
-
-	// Edit replaces string occurrences in a file.
-	//
-	// Returns:
-	//   - error: Error if file does not exist, OldString is empty, or OldString is not found
-	Edit(ctx context.Context, req *EditRequest) error
-}

adk/middlewares/filesystem/filesystem.go

@@ -37,10 +37,17 @@ import (
 // Config is the configuration for the filesystem middleware
 type Config struct {
 	// Backend provides filesystem operations used by tools and offloading.
-	// If the Backend also implements ShellBackend, an additional execute tool
-	// will be registered to support shell command execution.
 	// required
-	Backend Backend
+	Backend filesystem.Backend
+
+	// Shell provides shell command execution capability.
+	// If set, an execute tool will be registered to support shell command execution.
+	// optional, mutually exclusive with StreamingShell
+	Shell filesystem.Shell
+	// StreamingShell provides streaming shell command execution capability.
+	// If set, a streaming execute tool will be registered for real-time output.
+	// optional, mutually exclusive with Shell
+	StreamingShell filesystem.StreamingShell
 
 	// WithoutLargeToolResultOffloading disables automatic offloading of large tool result to Backend
 	// optional, false(enabled) by default
@@ -86,6 +93,9 @@ func (c *Config) Validate() error {
 	if c.Backend == nil {
 		return errors.New("backend should not be nil")
 	}
+	if c.StreamingShell != nil && c.Shell != nil {
+		return errors.New("shell and streaming shell should not be both set")
+	}
 	return nil
 }
 
@@ -109,18 +119,16 @@ func NewMiddleware(ctx context.Context, config *Config) (adk.AgentMiddleware, er
 	if config.CustomSystemPrompt != nil {
 		systemPrompt = *config.CustomSystemPrompt
 	} else {
-		var err error
 		systemPrompt, err = internal.SelectPrompt(internal.I18nPrompts{
 			English: ToolsSystemPrompt,
 			Chinese: ToolsSystemPromptChinese,
 		})
 		if err != nil {
 			return adk.AgentMiddleware{}, err
 		}
-		_, ok1 := config.Backend.(filesystem.StreamingShellBackend)
-		_, ok2 := config.Backend.(filesystem.ShellBackend)
-		if ok1 || ok2 {
-			executePrompt, err := internal.SelectPrompt(internal.I18nPrompts{
+		if config.Shell != nil || config.StreamingShell != nil {
+			var executePrompt string
+			executePrompt, err = internal.SelectPrompt(internal.I18nPrompts{
 				English: ExecuteToolsSystemPrompt,
 				Chinese: ExecuteToolsSystemPromptChinese,
 			})
@@ -187,10 +195,9 @@ func NewChatModelAgentMiddleware(ctx context.Context, config *Config) (adk.ChatM
 		if err != nil {
 			return nil, err
 		}
-		_, ok1 := config.Backend.(filesystem.StreamingShellBackend)
-		_, ok2 := config.Backend.(filesystem.ShellBackend)
-		if ok1 || ok2 {
-			executePrompt, err := internal.SelectPrompt(internal.I18nPrompts{
+		if config.Shell != nil || config.StreamingShell != nil {
+			var executePrompt string
+			executePrompt, err = internal.SelectPrompt(internal.I18nPrompts{
 				English: ExecuteToolsSystemPrompt,
 				Chinese: ExecuteToolsSystemPromptChinese,
 			})
@@ -324,16 +331,16 @@ func getFilesystemTools(_ context.Context, validatedConfig *Config) ([]tool.Base
 	}
 	tools = append(tools, grepTool)
 
-	if sb, ok := validatedConfig.Backend.(filesystem.StreamingShellBackend); ok {
+	if validatedConfig.StreamingShell != nil {
 		var executeTool tool.BaseTool
-		executeTool, err = newStreamingExecuteTool(sb, validatedConfig.CustomExecuteToolDesc)
+		executeTool, err = newStreamingExecuteTool(validatedConfig.StreamingShell, validatedConfig.CustomExecuteToolDesc)
 		if err != nil {
 			return nil, err
 		}
 		tools = append(tools, executeTool)
-	} else if sb, ok := validatedConfig.Backend.(filesystem.ShellBackend); ok {
+	} else if validatedConfig.Shell != nil {
 		var executeTool tool.BaseTool
-		executeTool, err = newExecuteTool(sb, validatedConfig.CustomExecuteToolDesc)
+		executeTool, err = newExecuteTool(validatedConfig.Shell, validatedConfig.CustomExecuteToolDesc)
 		if err != nil {
 			return nil, err
 		}
@@ -641,7 +648,7 @@ type executeArgs struct {
 	Command string `json:"command"`
 }
 
-func newExecuteTool(sb filesystem.ShellBackend, desc *string) (tool.BaseTool, error) {
+func newExecuteTool(sb filesystem.Shell, desc *string) (tool.BaseTool, error) {
 	d, err := selectToolDesc(desc, ExecuteToolDesc, ExecuteToolDescChinese)
 	if err != nil {
 		return nil, err
@@ -658,7 +665,7 @@ func newExecuteTool(sb filesystem.ShellBackend, desc *string) (tool.BaseTool, er
 	})
 }
 
-func newStreamingExecuteTool(sb filesystem.StreamingShellBackend, desc *string) (tool.BaseTool, error) {
+func newStreamingExecuteTool(sb filesystem.StreamingShell, desc *string) (tool.BaseTool, error) {
 	d, err := selectToolDesc(desc, ExecuteToolDesc, ExecuteToolDescChinese)
 	if err != nil {
 		return nil, err

adk/middlewares/filesystem/filesystem_test.go

@@ -561,18 +561,6 @@ func TestNewMiddleware(t *testing.T) {
 		assert.Nil(t, m.WrapToolCall.Invokable)
 		assert.Nil(t, m.WrapToolCall.Streamable)
 	})
-
-	t.Run("ShellBackend adds execute tool", func(t *testing.T) {
-		shellBackend := &mockShellBackend{
-			Backend: backend,
-			resp:    &filesystem.ExecuteResponse{Output: "ok"},
-		}
-		m, err := NewMiddleware(ctx, &Config{Backend: shellBackend})
-		assert.NoError(t, err)
-
-		// ShellBackend should have 7 tools (6 + execute)
-		assert.Len(t, m.AdditionalTools, 7)
-	})
 }
 
 func TestGetFilesystemTools(t *testing.T) {
@@ -598,12 +586,12 @@ func TestGetFilesystemTools(t *testing.T) {
 		assert.Contains(t, toolNames, "grep")
 	})
 
-	t.Run("returns 7 tools for ShellBackend", func(t *testing.T) {
+	t.Run("returns 7 tools for Shell", func(t *testing.T) {
 		shellBackend := &mockShellBackend{
 			Backend: backend,
 			resp:    &filesystem.ExecuteResponse{Output: "ok"},
 		}
-		tools, err := getFilesystemTools(ctx, &Config{Backend: shellBackend})
+		tools, err := getFilesystemTools(ctx, &Config{Backend: shellBackend, Shell: shellBackend})
 		assert.NoError(t, err)
 		assert.Len(t, tools, 7)
 
@@ -699,7 +687,7 @@ func TestNewChatModelAgentMiddleware(t *testing.T) {
 			Backend: backend,
 			resp:    &filesystem.ExecuteResponse{Output: "ok"},
 		}
-		m, err := NewChatModelAgentMiddleware(ctx, &Config{Backend: shellBackend})
+		m, err := NewChatModelAgentMiddleware(ctx, &Config{Backend: shellBackend, Shell: shellBackend})
 		assert.NoError(t, err)
 
 		fm, ok := m.(*filesystemMiddleware)

adk/middlewares/filesystem/large_tool_result.go

@@ -27,13 +27,14 @@ import (
 
 	"github.com/slongfield/pyfmt"
 
+	"github.com/cloudwego/eino/adk/filesystem"
 	"github.com/cloudwego/eino/adk/internal"
 	"github.com/cloudwego/eino/compose"
 	"github.com/cloudwego/eino/schema"
 )
 
 type toolResultOffloadingConfig struct {
-	Backend       Backend
+	Backend       filesystem.Backend
 	TokenLimit    int
 	PathGenerator func(ctx context.Context, input *compose.ToolInput) (string, error)
 }
@@ -62,7 +63,7 @@ func newToolResultOffloading(ctx context.Context, config *toolResultOffloadingCo
 }
 
 type toolResultOffloading struct {
-	backend       Backend
+	backend       filesystem.Backend
 	tokenLimit    int
 	pathGenerator func(ctx context.Context, input *compose.ToolInput) (string, error)
 }