Validate conditional schema constraints

Author: SqlRush

docs/cc-100-roadmap.md

@@ -299,6 +299,8 @@ M4/M5/M10 补充：`FuncTool.Validate` 现在使用与模型 tool definition 同
 
 M5/M9 补充：通用 tool schema validator 继续补齐 `not`、`multipleOf`、`uniqueItems`、`prefixItems`/`items:false`、`contains`/`minContains`/`maxContains`、`patternProperties` 和 `dependentRequired`；`additionalProperties:false` 会正确把 pattern-matched 字段视为已定义，Go typed nested schema map 也会被执行。
 
+M5/M9 补充：通用 tool schema validator 现在支持条件类 JSON Schema 约束 `propertyNames`、`dependentSchemas` 和 `if`/`then`/`else`，外部 MCP/动态工具可用 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

@@ -190,6 +190,7 @@ test/parity/                 # golden tests against TS/official behavior
 - 本轮补充：通用 tool schema validator 现在支持 `const`、`pattern`、`maxLength`、`minItems`/`maxItems`、`minProperties`/`maxProperties`、`exclusiveMinimum`/`exclusiveMaximum` 以及 `allOf`/`anyOf`/`oneOf`，并兼容 Go 代码直接构造的 typed schema list，外部 MCP 工具 schema 的基础 JSON Schema 约束会在本地调用前执行。
 - 本轮补充：`FuncTool.Validate` 现在使用与模型 tool definition 同源的动态 `InputSchemaFunc`，本地执行前校验会应用 Task subagent enum 等 runtime metadata 驱动的 schema 约束，避免“模型看到的 schema”和“实际执行校验”分叉。
 - 本轮补充：通用 tool schema validator 继续补齐 `not`、`multipleOf`、`uniqueItems`、`prefixItems`/`items:false`、`contains`/`minContains`/`maxContains`、`patternProperties` 和 `dependentRequired`；`additionalProperties:false` 会正确把 pattern-matched 字段视为已定义，Go typed nested schema map 也会被执行。
+- 本轮补充：通用 tool schema validator 现在支持条件类 JSON Schema 约束 `propertyNames`、`dependentSchemas` 和 `if`/`then`/`else`，外部 MCP/动态工具可用 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

@@ -48,6 +48,19 @@ func validateValue(schema contracts.JSONSchema, value any, path string) error {
 			return fmt.Errorf("%s must not match disallowed schema", path)
 		}
 	}
+	if ifSchema, ok := schemaMap(schema["if"]); ok {
+		if err := validateValue(ifSchema, value, path); err == nil {
+			if thenSchema, ok := schemaMap(schema["then"]); ok {
+				if err := validateValue(thenSchema, value, path); err != nil {
+					return err
+				}
+			}
+		} else if elseSchema, ok := schemaMap(schema["else"]); ok {
+			if err := validateValue(elseSchema, value, path); err != nil {
+				return err
+			}
+		}
+	}
 	if types := stringOrStrings(schema["type"]); len(types) > 0 {
 		if !matchesAnyType(types, value) {
 			return fmt.Errorf("%s must be %s", path, strings.Join(types, " or "))
@@ -200,6 +213,13 @@ func validateValue(schema contracts.JSONSchema, value any, path string) error {
 	if maxProperties, ok := intSchemaConstraint(schema["maxProperties"]); ok && len(obj) > maxProperties {
 		return fmt.Errorf("%s must contain at most %d properties", path, maxProperties)
 	}
+	if propertyNameSchema, ok := schemaMap(schema["propertyNames"]); ok {
+		for key := range obj {
+			if err := validateValue(propertyNameSchema, key, fmt.Sprintf("%s property name %q", path, key)); err != nil {
+				return err
+			}
+		}
+	}
 	if ok {
 		for key, propertySchema := range properties {
 			child, ok := obj[key]
@@ -215,6 +235,20 @@ func validateValue(schema contracts.JSONSchema, value any, path string) error {
 			}
 		}
 	}
+	if dependentSchemas, ok := objectMap(schema["dependentSchemas"]); ok {
+		for key, rawSchema := range dependentSchemas {
+			if _, present := obj[key]; !present {
+				continue
+			}
+			dependencySchema, ok := schemaMap(rawSchema)
+			if !ok {
+				continue
+			}
+			if err := validateValue(dependencySchema, value, path); err != nil {
+				return err
+			}
+		}
+	}
 	patternDefined, err := validatePatternProperties(schema["patternProperties"], obj, path)
 	if err != nil {
 		return err

internal/tool/tool_test.go

@@ -219,6 +219,61 @@ func TestValidateSchemaAdditionalAdvancedConstraints(t *testing.T) {
 	}
 }
 
+func TestValidateSchemaConditionalConstraints(t *testing.T) {
+	schema := contracts.JSONSchema{
+		"type": "object",
+		"propertyNames": map[string]any{
+			"pattern": "^[a-z_]+$",
+		},
+		"properties": map[string]any{
+			"mode":         map[string]any{"type": "string"},
+			"note":         map[string]any{"type": "string"},
+			"secret":       map[string]any{"type": "string"},
+			"token":        map[string]any{"type": "string"},
+			"token_secret": map[string]any{"type": "string"},
+		},
+		"if": map[string]any{
+			"required": []string{"mode"},
+			"properties": map[string]any{
+				"mode": map[string]any{"const": "secure"},
+			},
+		},
+		"then": map[string]any{
+			"required": []string{"secret"},
+		},
+		"else": map[string]any{
+			"required": []string{"note"},
+		},
+		"dependentSchemas": map[string]any{
+			"token": contracts.JSONSchema{"required": []string{"token_secret"}},
+		},
+	}
+	cases := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{"property-names", `{"Bad":1,"note":"ok"}`, `input property name "Bad" must match pattern ^[a-z_]+$`},
+		{"then", `{"mode":"secure"}`, "input.secret is required"},
+		{"else", `{"mode":"plain"}`, "input.note is required"},
+		{"dependent-schemas", `{"note":"ok","token":"abc"}`, "input.token_secret is required"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := ValidateSchema(schema, json.RawMessage(tc.input))
+			if err == nil || !strings.Contains(err.Error(), tc.want) {
+				t.Fatalf("err = %v, want %q", err, tc.want)
+			}
+		})
+	}
+	if err := ValidateSchema(schema, json.RawMessage(`{"mode":"secure","secret":"s"}`)); err != nil {
+		t.Fatal(err)
+	}
+	if err := ValidateSchema(schema, json.RawMessage(`{"mode":"plain","note":"ok","token":"abc","token_secret":"def"}`)); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestFuncToolValidateUsesDynamicInputSchema(t *testing.T) {
 	dynamic := FuncTool{
 		DefinitionValue: contracts.ToolDefinition{