Validate schema enum values

Author: SqlRush

docs/cc-100-roadmap.md

@@ -287,6 +287,8 @@ M5 补充：WebSearch `query` schema 现在按官方 `min(2)` 约束拒绝单字
 
 M5 补充：WebSearch domain filters 现在在 schema 层声明 array `items:string`，通用 tool schema validator 同步支持 `items` 校验；`allowed_domains`/`blocked_domains` 会拒绝空字符串、URL/port、非法 wildcard 和非域名 label。
 
+M5 补充：通用 tool schema validator 现在支持 `enum`，可直接执行 Grep output mode、NotebookEdit edit mode/cell type、Todo status/priority、Task target/action、LSP severity 等工具 schema 的枚举契约。
+
 M7 补充：scripted permission payload、dialog expectation、event、cancel-permission 和 dialog-result expectation 现在接受 `ID`/`ToolName`/`Actions`、`permissionID`、`requestID`、`toolUseID`、`operationID`、`operation`、`commandName`、`resourcePath`、`body`、`reasonText`、`allowedActions`、`buttons` 等相邻字段，并支持数字 request ID。
 
 M6 补充：microcompact disk cache loader 和 prune 现在接受 digest 缺失但文件名已 keyed 的 cache entry，会用 `<digest>.json` 文件名作为 digest fallback，同时保留显式 digest mismatch 的 invalid-cache guard。

docs/claude-code-go-rewrite-plan.md

@@ -184,6 +184,7 @@ test/parity/                 # golden tests against TS/official behavior
 - 本轮补充：WebSearch JSON result parser 现在支持 `pageUrl`/`targetUrl`/`source_url`/`formattedUrl` 等 URL aliases、`htmlTitle`/`htmlSnippet` 等 HTML 标记字段清理、嵌套 URL object，以及 `deepLinks`/`siteLinks` 子结果递归解析。
 - 本轮补充：WebSearch `query` schema 现在按官方 `min(2)` 约束拒绝单字符查询，通用 tool schema validator 同步支持 `minLength`，让工具定义可直接表达字符串最小长度契约。
 - 本轮补充：WebSearch domain filters 现在在 schema 层声明 array `items:string`，通用 tool schema validator 同步支持 `items` 校验；`allowed_domains`/`blocked_domains` 会拒绝空字符串、URL/port、非法 wildcard 和非域名 label。
+- 本轮补充：通用 tool schema validator 现在支持 `enum`，可直接执行 Grep output mode、NotebookEdit edit mode/cell type、Todo status/priority、Task target/action、LSP severity 等工具 schema 的枚举契约。
 - 本轮补充：WebFetch/WebSearch 输入解码现在兼容 `timeout`、`max_bytes`/`maxBytes`、`max_results`/`maxResults` 的 quoted semantic string 数值；WebSearch 也会按官方校验拒绝同一请求同时设置 `allowed_domains` 和 `blocked_domains`。
 - 本轮补充：Grep 现在支持 whole-word 搜索参数 `word_regexp`/`wordRegexp`/`word-regexp`/`-w`，在 regex 和 fixed-string 模式下按词边界过滤匹配，并兼容 quoted boolean 输入。
 - 本轮补充：Grep 现在支持反向匹配参数 `invert_match`/`invertMatch`/`invert-match`/`-v`，`files_with_matches`、`content`、`count` 和 multiline 模式都会按非匹配行/未覆盖行输出，并兼容 quoted boolean 输入。

internal/tool/schema.go

@@ -28,6 +28,11 @@ func validateValue(schema contracts.JSONSchema, value any, path string) error {
 			return fmt.Errorf("%s must be %s", path, strings.Join(types, " or "))
 		}
 	}
+	if enumValues, ok := schemaEnumValues(schema["enum"]); ok {
+		if !matchesEnumValue(value, enumValues) {
+			return fmt.Errorf("%s must be one of %s", path, describeEnumValues(enumValues))
+		}
+	}
 	if minLength, ok := intSchemaConstraint(schema["minLength"]); ok {
 		text, ok := value.(string)
 		if ok && utf8.RuneCountInString(text) < minLength {
@@ -117,6 +122,78 @@ func matchesAnyType(types []string, value any) bool {
 	return false
 }
 
+func schemaEnumValues(value any) ([]any, bool) {
+	switch v := value.(type) {
+	case []any:
+		return v, len(v) > 0
+	case []string:
+		out := make([]any, 0, len(v))
+		for _, item := range v {
+			out = append(out, item)
+		}
+		return out, len(out) > 0
+	default:
+		return nil, false
+	}
+}
+
+func matchesEnumValue(value any, enumValues []any) bool {
+	for _, candidate := range enumValues {
+		if equalSchemaValue(value, candidate) {
+			return true
+		}
+	}
+	return false
+}
+
+func equalSchemaValue(a any, b any) bool {
+	if af, ok := schemaNumber(a); ok {
+		if bf, ok := schemaNumber(b); ok {
+			return af == bf
+		}
+	}
+	switch av := a.(type) {
+	case string:
+		bv, ok := b.(string)
+		return ok && av == bv
+	case bool:
+		bv, ok := b.(bool)
+		return ok && av == bv
+	case nil:
+		return b == nil
+	default:
+		return fmt.Sprint(a) == fmt.Sprint(b)
+	}
+}
+
+func describeEnumValues(enumValues []any) string {
+	parts := make([]string, 0, len(enumValues))
+	for _, value := range enumValues {
+		parts = append(parts, fmt.Sprint(value))
+	}
+	return strings.Join(parts, ", ")
+}
+
+func schemaNumber(value any) (float64, bool) {
+	switch v := value.(type) {
+	case float64:
+		return v, true
+	case float32:
+		return float64(v), true
+	case int:
+		return float64(v), true
+	case int64:
+		return float64(v), true
+	case int32:
+		return float64(v), true
+	case json.Number:
+		f, err := v.Float64()
+		return f, err == nil
+	default:
+		return 0, false
+	}
+}
+
 func intSchemaConstraint(value any) (int, bool) {
 	switch v := value.(type) {
 	case int:

internal/tool/tool_test.go

@@ -36,8 +36,10 @@ func TestValidateSchema(t *testing.T) {
 		"type":     "object",
 		"required": []any{"path"},
 		"properties": map[string]any{
-			"path": map[string]any{"type": "string", "minLength": 2},
-			"tags": map[string]any{"type": "array", "items": map[string]any{"type": "string"}},
+			"path":  map[string]any{"type": "string", "minLength": 2},
+			"mode":  map[string]any{"type": "string", "enum": []any{"read", "write"}},
+			"count": map[string]any{"type": "integer", "enum": []any{1, 2}},
+			"tags":  map[string]any{"type": "array", "items": map[string]any{"type": "string"}},
 		},
 	}
 	if err := ValidateSchema(schema, json.RawMessage(`{"path":3}`)); err == nil {
@@ -49,9 +51,18 @@ func TestValidateSchema(t *testing.T) {
 	if err := ValidateSchema(schema, json.RawMessage(`{"path":"README.md","tags":[3]}`)); err == nil || !strings.Contains(err.Error(), "input.tags[0] must be string") {
 		t.Fatalf("err = %v", err)
 	}
+	if err := ValidateSchema(schema, json.RawMessage(`{"path":"README.md","mode":"delete"}`)); err == nil || !strings.Contains(err.Error(), "input.mode must be one of read, write") {
+		t.Fatalf("err = %v", err)
+	}
+	if err := ValidateSchema(schema, json.RawMessage(`{"path":"README.md","count":3}`)); err == nil || !strings.Contains(err.Error(), "input.count must be one of 1, 2") {
+		t.Fatalf("err = %v", err)
+	}
 	if err := ValidateSchema(schema, json.RawMessage(`{"path":"README.md"}`)); err != nil {
 		t.Fatal(err)
 	}
+	if err := ValidateSchema(schema, json.RawMessage(`{"path":"README.md","mode":"read","count":2}`)); err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestExecutorRunsAllowedTool(t *testing.T) {

internal/tools/lsp/tools_test.go

@@ -52,7 +52,7 @@ func TestDiagnosticsToolNoSessionPath(t *testing.T) {
 
 func TestDiagnosticsToolValidatesSeverity(t *testing.T) {
 	err := NewDiagnosticsTool().Validate(tool.Context{}, json.RawMessage(`{"severity":"fatal"}`))
-	if err == nil || !strings.Contains(err.Error(), "unsupported severity") {
+	if err == nil || !strings.Contains(err.Error(), "input.severity must be one of error, warning, info, hint") {
 		t.Fatalf("severity validation err = %v", err)
 	}
 }

internal/tools/todo/tools_test.go

@@ -148,12 +148,12 @@ func TestTodoWriteValidatesInput(t *testing.T) {
 		{
 			name:  "invalid status",
 			input: `{"todos":[{"id":"1","content":"x","status":"blocked","priority":"low"}]}`,
-			want:  "status must be one of pending, in_progress, or completed",
+			want:  "input.todos[0].status must be one of pending, in_progress, completed",
 		},
 		{
 			name:  "invalid priority",
 			input: `{"todos":[{"id":"1","content":"x","status":"pending","priority":"urgent"}]}`,
-			want:  "priority must be one of high, medium, or low",
+			want:  "input.todos[0].priority must be one of high, medium, low",
 		},
 		{
 			name:  "duplicate id",