feat: Add remove_tool_call_params edit strategy (#84)

* feat: Add remove_tool_call_params edit strategy

Implements #73 - adds new context editing strategy to remove parameters from old tool-call parts, keeping only recent N with full params.

changes:
- Go API: New strategy in pkg/editor with priority 2
- Python SDK: added RemoveToolCallParamsStrategy type hints
- TypeSCript SDK: Added RemoveToolCallParamsStrategySChema
- Tests: Added unit test for the new strategy

TOol call ID and Name remain intact so tool-results can reference them easily
Parameters replace with empty JSON '{}'

Tested and working via API endpoint

* test: Add boundary casetests and modernize loop

- Add test or edge cases: zero value, negative value, nil Meta, mixed parts, no tool calls
- Modernize loop to use range over int

Author: slyt3

src/client/acontext-py/src/acontext/types/session.py

@@ -30,6 +30,34 @@ class RemoveToolResultStrategy(TypedDict):
     params: RemoveToolResultParams
 
 
+class RemoveToolCallParamsParams(TypedDict, total=False):
+    """Parameters for the remove_tool_call_params edit strategy.
+
+    Attributes:
+        keep_recent_n_tool_calls: Number of most recent tool calls to keep with full parameters.
+            Defaults to 3 if not specified.
+    """
+
+    keep_recent_n_tool_calls: NotRequired[int]
+
+
+
+class RemoveToolCallParamsStrategy(TypedDict):
+    """Edit strategy to remove parameters from old tool-call parts.
+
+    Keeps the most recent N tool calls with full parameters, replacing older
+    tool call arguments with empty JSON "{}". The tool call ID and name remain
+    intact so tool-results can still reference them.
+
+    Example:
+        {"type": "remove_tool_call_params", "params": {"keep_recent_n_tool_calls": 5}}
+    """
+
+    type: Literal["remove_tool_call_params"]
+    params: RemoveToolCallParamsParams
+
+
+
 class TokenLimitParams(TypedDict):
     """Parameters for the token_limit edit strategy.
 
@@ -59,7 +87,7 @@ class TokenLimitStrategy(TypedDict):
 
 # Union type for all edit strategies
 # When adding new strategies, add them to this Union: EditStrategy = Union[RemoveToolResultStrategy, OtherStrategy, ...]
-EditStrategy = Union[RemoveToolResultStrategy, TokenLimitStrategy]
+EditStrategy = Union[RemoveToolResultStrategy, RemoveToolCallParamsStrategy, TokenLimitStrategy]
 
 
 class Asset(BaseModel):

src/client/acontext-ts/src/types/session.ts

@@ -145,6 +145,33 @@ export const RemoveToolResultParamsSchema = z.object({
 
 export type RemoveToolResultParams = z.infer<typeof RemoveToolResultParamsSchema>;
 
+/**
+ * Parameters for the remove_tool_call_params edit strategy.
+ */
+export const RemoveToolCallParamsParamsSchema = z.object({
+  /**
+   * Number of most recent tool calls to keep with full parameters.
+   * @default 3
+   */
+  keep_recent_n_tool_calls: z.number().optional(),
+});
+export type RemoveToolCallParamsParams = z.infer<typeof RemoveToolCallParamsParamsSchema>;
+
+/**
+ * Edit strategy to remove parameters from old tool-call parts.
+ * 
+ * Keeps the most recent N tool calls with full parameters, replacing older
+ * tool call arguments with empty JSON "{}". The tool call ID and name remain
+ * intact so tool-results can still reference them.
+ * 
+ * Example: { type: 'remove_tool_call_params', params: { keep_recent_n_tool_calls: 5 } }
+ */
+export const RemoveToolCallParamsStrategySchema = z.object({
+  type: z.literal('remove_tool_call_params'),
+  params: RemoveToolCallParamsParamsSchema,
+});
+export type RemoveToolCallParamsStrategy = z.infer<typeof RemoveToolCallParamsStrategySchema>;
+
 /**
  * Edit strategy to replace old tool results with placeholder text.
  * 
@@ -193,6 +220,7 @@ export type TokenLimitStrategy = z.infer<typeof TokenLimitStrategySchema>;
  */
 export const EditStrategySchema = z.union([
   RemoveToolResultStrategySchema,
+  RemoveToolCallParamsStrategySchema,
   TokenLimitStrategySchema,
 ]);
 

src/server/api/go/internal/pkg/editor/editor.go

@@ -24,6 +24,8 @@ func CreateStrategy(config StrategyConfig) (EditStrategy, error) {
 	switch config.Type {
 	case "remove_tool_result":
 		return createRemoveToolResultStrategy(config.Params)
+	case "remove_tool_call_params":
+		return createRemoveToolCallParamsStrategy(config.Params)
 	case "token_limit":
 		return createTokenLimitStrategy(config.Params)
 	default:
@@ -38,6 +40,8 @@ func getStrategyPriority(strategyType string) int {
 	switch strategyType {
 	case "remove_tool_result":
 		return 1 // Content reduction strategies go first
+	case "remove_tool_call_params":
+		return 2
 	case "token_limit":
 		return 100 // Token limit always goes last
 	default:

src/server/api/go/internal/pkg/editor/strategy_remove_tool_call_params.go

@@ -0,0 +1,80 @@
+package editor
+
+import (
+	"fmt"
+	"github.com/memodb-io/Acontext/internal/modules/model"
+)
+
+// RemoveToolCallParamsStrategy removes parameters from old tool-call parts
+type RemoveToolCallParamsStrategy struct {
+	KeepRecentN int
+}
+
+// Name returns the strategy name
+func (s *RemoveToolCallParamsStrategy) Name() string {
+	return "remove_tool_call_params"
+}
+
+// Apply removes input parameters from old tool-call parts
+// Keeps the most recent N tool-call parts with their original parameters
+func (s *RemoveToolCallParamsStrategy) Apply(messages []model.Message) ([]model.Message, error) {
+	if s.KeepRecentN < 0 {
+		return nil, fmt.Errorf("keep_recent_n_tool_calls must be >= 0, got %d", s.KeepRecentN)
+	}
+
+	// Collect all tool-call parts with their positions
+	type toolCallPosition struct {
+		messageIdx int
+		partIdx    int
+	}
+	var toolCallPositions []toolCallPosition
+
+	for msgIdx, msg := range messages {
+		for partIdx, part := range msg.Parts {
+			if part.Type == "tool-call" {
+				toolCallPositions = append(toolCallPositions, toolCallPosition{
+					messageIdx: msgIdx,
+					partIdx:    partIdx,
+				})
+			}
+		}
+	}
+
+	// Calculate how many to modify
+	totalToolCalls := len(toolCallPositions)
+	if totalToolCalls <= s.KeepRecentN {
+		return messages, nil
+	}
+
+	numToModify := totalToolCalls - s.KeepRecentN
+
+	// Remove arguments from the oldest tool-call parts
+	for i := range numToModify {
+		pos := toolCallPositions[i]
+		if messages[pos.messageIdx].Parts[pos.partIdx].Meta != nil {
+			messages[pos.messageIdx].Parts[pos.partIdx].Meta["arguments"] = "{}"
+		}
+	}
+
+	return messages, nil
+}
+
+// createRemoveToolCallParamsStrategy creates a RemoveToolCallParamsStrategy from config params
+func createRemoveToolCallParamsStrategy(params map[string]interface{}) (EditStrategy, error) {
+	keepRecentNInt := 3
+
+	if keepRecentN, ok := params["keep_recent_n_tool_calls"]; ok {
+		switch v := keepRecentN.(type) {
+		case float64:
+			keepRecentNInt = int(v)
+		case int:
+			keepRecentNInt = v
+		default:
+			return nil, fmt.Errorf("keep_recent_n_tool_calls must be an integer, got %T", keepRecentN)
+		}
+	}
+
+	return &RemoveToolCallParamsStrategy{
+		KeepRecentN: keepRecentNInt,
+	}, nil
+}

src/server/api/go/internal/pkg/editor/strategy_remove_tool_call_params_test.go

@@ -0,0 +1,173 @@
+package editor
+
+import (
+	"testing"
+
+	"github.com/memodb-io/Acontext/internal/modules/model"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRemoveToolCallParamsStrategy_Apply(t *testing.T) {
+	t.Run("removes parameters from old tool calls", func(t *testing.T) {
+		messages := []model.Message{
+			{
+				Parts: []model.Part{
+					{
+						Type: "tool-call",
+						Meta: map[string]any{
+							"id":        "call_1",
+							"name":      "search",
+							"arguments": `{"query": "old search"}`,
+						},
+					},
+				},
+			},
+			{
+				Parts: []model.Part{
+					{
+						Type: "tool-call",
+						Meta: map[string]any{
+							"id":        "call_2",
+							"name":      "search",
+							"arguments": `{"query": "recent search"}`,
+						},
+					},
+				},
+			},
+		}
+
+		strategy := &RemoveToolCallParamsStrategy{KeepRecentN: 1}
+		result, err := strategy.Apply(messages)
+
+		assert.NoError(t, err)
+		assert.Equal(t, "{}", result[0].Parts[0].Meta["arguments"])
+		assert.Equal(t, `{"query": "recent search"}`, result[1].Parts[0].Meta["arguments"])
+	})
+
+	t.Run("keeps all when under limit", func(t *testing.T) {
+		messages := []model.Message{
+			{
+				Parts: []model.Part{
+					{
+						Type: "tool-call",
+						Meta: map[string]any{
+							"id":        "call_1",
+							"name":      "search",
+							"arguments": `{"query": "test"}`,
+						},
+					},
+				},
+			},
+		}
+
+		strategy := &RemoveToolCallParamsStrategy{KeepRecentN: 3}
+		result, err := strategy.Apply(messages)
+
+		assert.NoError(t, err)
+		assert.Equal(t, `{"query": "test"}`, result[0].Parts[0].Meta["arguments"])
+	})
+
+	t.Run("removes all when keep_recent_n is zero", func(t *testing.T) {
+		messages := []model.Message{
+			{
+				Parts: []model.Part{
+					{
+						Type: "tool-call",
+						Meta: map[string]any{
+							"id":        "call_1",
+							"name":      "search",
+							"arguments": `{"query": "test"}`,
+						},
+					},
+				},
+			},
+		}
+
+		strategy := &RemoveToolCallParamsStrategy{KeepRecentN: 0}
+		result, err := strategy.Apply(messages)
+
+		assert.NoError(t, err)
+		assert.Equal(t, "{}", result[0].Parts[0].Meta["arguments"])
+	})
+
+	t.Run("returns error for negative keep_recent_n", func(t *testing.T) {
+		messages := []model.Message{}
+		strategy := &RemoveToolCallParamsStrategy{KeepRecentN: -1}
+		_, err := strategy.Apply(messages)
+
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "must be >= 0")
+	})
+
+	t.Run("handles messages with no tool calls", func(t *testing.T) {
+		messages := []model.Message{
+			{
+				Parts: []model.Part{
+					{Type: "text", Text: "hello"},
+				},
+			},
+		}
+
+		strategy := &RemoveToolCallParamsStrategy{KeepRecentN: 1}
+		result, err := strategy.Apply(messages)
+
+		assert.NoError(t, err)
+		assert.Equal(t, messages, result)
+	})
+
+	t.Run("handles mixed part types", func(t *testing.T) {
+		messages := []model.Message{
+			{
+				Parts: []model.Part{
+					{Type: "text", Text: "hello"},
+					{
+						Type: "tool-call",
+						Meta: map[string]any{
+							"id":        "call_1",
+							"name":      "search",
+							"arguments": `{"query": "old"}`,
+						},
+					},
+				},
+			},
+			{
+				Parts: []model.Part{
+					{
+						Type: "tool-call",
+						Meta: map[string]any{
+							"id":        "call_2",
+							"name":      "search",
+							"arguments": `{"query": "new"}`,
+						},
+					},
+				},
+			},
+		}
+
+		strategy := &RemoveToolCallParamsStrategy{KeepRecentN: 1}
+		result, err := strategy.Apply(messages)
+
+		assert.NoError(t, err)
+		assert.Equal(t, "{}", result[0].Parts[1].Meta["arguments"])
+		assert.Equal(t, `{"query": "new"}`, result[1].Parts[0].Meta["arguments"])
+	})
+
+	t.Run("handles tool call with nil meta gracefully", func(t *testing.T) {
+		messages := []model.Message{
+			{
+				Parts: []model.Part{
+					{
+						Type: "tool-call",
+						Meta: nil,
+					},
+				},
+			},
+		}
+
+		strategy := &RemoveToolCallParamsStrategy{KeepRecentN: 0}
+		result, err := strategy.Apply(messages)
+
+		assert.NoError(t, err)
+		assert.Nil(t, result[0].Parts[0].Meta)
+	})
+}