MCP는 joni와 graal-js를 해석하지 않아 {@code pattern} 검증이 {@code java.util.regex}로 처리된다. 이 엔진은 백트래킹 기반이고 {@code Matcher.find()}로 모든 시작 위치를
+ * 시도하므로, 특정 정규식과 긴 입력의 조합에서 처리 시간이 다항·지수적으로 늘어난다. 인증이 없는 경계(ADR-0006)라 호출 빈도를 줄여 주는 계층도 없다.
+ * *
+ * *
pending = new ArrayDeque<>();
+ pending.push(schema);
+ while (!pending.isEmpty()) {
+ JsonNode node = pending.pop();
+ if (node.isObject()) {
+ assertKeywordPattern(node);
+ assertPatternPropertiesAbsent(node);
+ }
+ node.forEach(pending::push);
+ }
+ }
+
+ /**
+ * 한 schema 객체의 {@code pattern}과 그 필드의 {@code maxLength}를 함께 검사합니다. 값이 문자열이 아니면 정규식이 아니라 {@code properties} 아래에 우연히 같은 이름을 쓴 필드
+ * 정의이므로 건너뜁니다.
+ */
+ private static void assertKeywordPattern(JsonNode node) {
+ JsonNode pattern = node.get("pattern");
+ if (pattern == null || !pattern.isTextual()) {
+ return;
+ }
+ assertSafeRegex(pattern.asText());
+ assertBoundedLength(node.get("maxLength"));
+ }
+
+ /**
+ * 정규식이 걸린 문자열의 길이가 묶여 있는지 확인합니다. 검증 비용이 입력 길이를 따라 늘어나므로, 상한이 없으면 정규식 모양과 무관하게 요청 body 한도(약 1MB)까지 열려 버립니다.
+ */
+ private static void assertBoundedLength(JsonNode maxLength) {
+ if (maxLength == null || !maxLength.isIntegralNumber()) {
+ throw new IllegalStateException("Tool inputSchema pattern requires maxLength on the same field");
+ }
+ if (maxLength.intValue() <= 0 || maxLength.intValue() > MAX_PATTERNED_STRING_LENGTH) {
+ throw new IllegalStateException(
+ "Tool inputSchema maxLength with pattern must be at most " + MAX_PATTERNED_STRING_LENGTH);
+ }
+ }
+
+ /**
+ * {@code patternProperties}를 아예 거부합니다. 이 keyword는 값이 아니라 입력 객체의 key에 정규식을 적용하는데, key 길이를 선언할 자리가 없어 {@code pattern}에 쓴 길이
+ * 상한 방식을 그대로 적용할 수 없습니다. {@code propertyNames}로 길이를 묶는 방법은 keyword 평가 순서가 명세에 정해져 있지 않아 정규식이 먼저 돌 수 있으므로 통제로 쓰지 않습니다.
+ *
+ * 현재 어떤 Tool도 이 keyword를 쓰지 않으므로, 묶을 수 없는 것을 남겨 두는 대신 쓰지 않는 기능을 닫습니다. 실제 필요가 생기면 길이를 묶는 방법을 정한 새 ADR을 먼저 씁니다.
+ */
+ private static void assertPatternPropertiesAbsent(JsonNode node) {
+ if (node.has("patternProperties")) {
+ throw new IllegalStateException("Tool inputSchema must not use patternProperties");
+ }
+ }
+
+ /**
+ * 정규식 하나가 길이 상한과 컴파일 가능성을 만족하고, 반복 구조가 허용 범위인지 확인합니다. 컴파일을 여기서 해 두면 잘못된 정규식이 요청 시점이 아니라 등록 시점에 걸립니다.
+ */
+ private static void assertSafeRegex(String regex) {
+ if (regex.length() > MAX_PATTERN_LENGTH) {
+ throw new IllegalStateException(
+ "Tool inputSchema pattern must be at most " + MAX_PATTERN_LENGTH + " characters");
+ }
+ try {
+ Pattern.compile(regex);
+ } catch (PatternSyntaxException exception) {
+ throw new IllegalStateException("Tool inputSchema pattern is not a valid regular expression");
+ }
+ assertRepetitionIsBudgeted(regex);
+ }
+
+ /**
+ * 두 가지 반복 구조를 거부합니다.
+ *
+ *
+ * - 무한 수량자를 품은 그룹을 다시 반복하는 형태. {@code (x+x+)+y}와 {@code (.*,){11}P}가 여기 해당하며, 바깥 반복 횟수에 상한이 있어도 측정상 폭증했으므로 {@code {11}} 같은
+ * 유한 반복도 함께 막습니다.
+ *
- 무한 수량자가 {@value #MAX_UNBOUNDED_QUANTIFIERS}개를 넘는 형태. {@code a*a*a*a*a*b}처럼 겹치는 문자 집합에 수량자가 이어지는 경우를 줄입니다.
+ *
+ *
+ * 겹침 여부까지 판정하지는 않으므로 이 검사만으로 안전이 보장되지 않습니다. 실질적인 상한은 함께 적용하는 {@code maxLength} 제한이 만듭니다.
+ */
+ private static void assertRepetitionIsBudgeted(String regex) {
+ // 각 원소는 "지금까지 이 그룹 안에서 무한 수량자를 봤는가"다.
+ Deque openGroups = new ArrayDeque<>();
+ boolean insideCharacterClass = false;
+ int unboundedQuantifiers = 0;
+ int index = 0;
+ while (index < regex.length()) {
+ char current = regex.charAt(index);
+ if (current == '\\') {
+ // 이스케이프된 문자는 수량자도 그룹도 아니다.
+ index += 2;
+ continue;
+ }
+ if (insideCharacterClass) {
+ insideCharacterClass = current != ']';
+ index++;
+ continue;
+ }
+ if (current == '[') {
+ insideCharacterClass = true;
+ index++;
+ continue;
+ }
+ if (current == '(') {
+ openGroups.push(Boolean.FALSE);
+ index++;
+ continue;
+ }
+ if (current == ')') {
+ boolean groupHasUnbounded = !openGroups.isEmpty() && openGroups.pop();
+ int unbounded = unboundedQuantifierLength(regex, index + 1);
+ int bounded = unbounded > 0 ? 0 : boundedQuantifierLength(regex, index + 1);
+ if (groupHasUnbounded && (unbounded > 0 || bounded > 0)) {
+ throw new IllegalStateException(
+ "Tool inputSchema pattern must not repeat a group that already repeats without bound");
+ }
+ if (unbounded > 0) {
+ unboundedQuantifiers++;
+ markEnclosingGroup(openGroups);
+ }
+ index += 1 + unbounded + bounded;
+ continue;
+ }
+ int unbounded = unboundedQuantifierLength(regex, index);
+ if (unbounded > 0) {
+ unboundedQuantifiers++;
+ markEnclosingGroup(openGroups);
+ index += unbounded;
+ } else {
+ index++;
+ }
+ }
+ if (unboundedQuantifiers > MAX_UNBOUNDED_QUANTIFIERS) {
+ throw new IllegalStateException(
+ "Tool inputSchema pattern must use at most "
+ + MAX_UNBOUNDED_QUANTIFIERS
+ + " unbounded quantifiers");
+ }
+ }
+
+ /**
+ * 지금 열려 있는 그룹에 무한 수량자를 봤다고 기록합니다. 그룹 밖이면 중첩 판정 대상이 없습니다.
+ */
+ private static void markEnclosingGroup(Deque openGroups) {
+ if (!openGroups.isEmpty()) {
+ openGroups.pop();
+ openGroups.push(Boolean.TRUE);
+ }
+ }
+
+ /**
+ * 주어진 위치에서 시작하는 무한 수량자({@code *}, {@code +}, {@code {n,}})의 길이를 반환하고, 아니면 0을 반환합니다.
+ */
+ private static int unboundedQuantifierLength(String regex, int start) {
+ if (start >= regex.length()) {
+ return 0;
+ }
+ char current = regex.charAt(start);
+ if (current == '*' || current == '+') {
+ return 1;
+ }
+ if (current != '{') {
+ return 0;
+ }
+ int close = regex.indexOf('}', start);
+ if (close < 0) {
+ return 0;
+ }
+ return regex.substring(start + 1, close).endsWith(",") ? close - start + 1 : 0;
+ }
+
+ /**
+ * 주어진 위치에서 시작하는 상한 있는 수량자({@code ?}, {@code {n}}, {@code {n,m}})의 길이를 반환하고, 아니면 0을 반환합니다.
+ */
+ private static int boundedQuantifierLength(String regex, int start) {
+ if (start >= regex.length()) {
+ return 0;
+ }
+ if (regex.charAt(start) == '?') {
+ return 1;
+ }
+ if (regex.charAt(start) != '{') {
+ return 0;
+ }
+ int close = regex.indexOf('}', start);
+ return close < 0 ? 0 : close - start + 1;
+ }
+}
diff --git a/src/main/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaReferencePolicy.java b/src/main/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaReferencePolicy.java
new file mode 100644
index 0000000..b312dfa
--- /dev/null
+++ b/src/main/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaReferencePolicy.java
@@ -0,0 +1,80 @@
+package io.shinhanlife.dat.biz.mcp.registry;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * @package io.shinhanlife.dat.biz.mcp.registry
+ * @className ToolSchemaReferencePolicy
+ * @description Tool의 {@code inputSchema}가 문서 밖을 가리키는 참조를 담지 못하게 막는 정책입니다. {@link ToolMetadata}가 만들어질 때만 호출되므로 Portal 매니페스트, local 파일, Redis snapshot 중 어느 경로로 들어온
+ * schema든 같은 규칙을 통과합니다. JSON Schema 검증기는 문서 밖 참조를 만나면 그 주소로 직접 조회를 시도하므로, 매니페스트가 서버의 outbound 호출 대상을 정하는 통로가 되지 않도록 수신 시점에 끊습니다.
+ * @author k.s.m
+ * @create 2026.09.15
+ *
+ *
+ * ============ 개정이력 ============
+ * 수정일 수정자 수정내용
+ * ---------- ---------- ----------------
+ * 2026.09.15 k.s.m 최초생성
+ *
+ *
+ */
+final class ToolSchemaReferencePolicy {
+
+ /**
+ * MCP가 사용하는 유일한 JSON Schema dialect입니다. 다른 dialect를 선언하면 검증기가 그 meta-schema를 외부에서 조회할 수 있습니다.
+ */
+ private static final String SUPPORTED_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+
+ /**
+ * 참조 대상을 문서 안으로 한정하는 keyword입니다. 값이 {@code #}으로 시작하면 같은 문서 안의 위치를 가리킨다.
+ */
+ private static final String[] REFERENCE_KEYWORDS = {"$ref", "$dynamicRef"};
+
+ private ToolSchemaReferencePolicy() {}
+
+ /**
+ * schema 전체를 훑어 문서 밖을 가리키는 참조가 있으면 거부합니다. schema가 없으면 검증할 것이 없으므로 그대로 통과시키고, 위반을 찾으면 해당 Tool을 등록하지 못하도록
+ * {@link IllegalStateException}을 던집니다. 호출자는 이 예외를 기존 매니페스트 형식 오류와 같게 다루므로 bundle 단위 실패 격리와 Redis cache miss 동작이 그대로 적용됩니다.
+ * 적대적으로 깊게 중첩된 schema에서도 스택이 무너지지 않도록 재귀 대신 명시적 스택으로 순회합니다.
+ */
+ static void assertNoExternalReference(JsonNode schema) {
+ if (schema == null || schema.isNull()) {
+ return;
+ }
+ Deque pending = new ArrayDeque<>();
+ pending.push(schema);
+ while (!pending.isEmpty()) {
+ JsonNode node = pending.pop();
+ if (node.isObject()) {
+ assertReferencesStayInDocument(node);
+ assertDialectIsSupported(node);
+ }
+ node.forEach(pending::push);
+ }
+ }
+
+ /**
+ * 한 schema 객체의 참조 keyword가 같은 문서 안을 가리키는지 확인합니다. 문자열이 아닌 값은 참조가 아니라 {@code properties} 아래의 필드 정의이므로 건너뜁니다.
+ */
+ private static void assertReferencesStayInDocument(JsonNode node) {
+ for (String keyword : REFERENCE_KEYWORDS) {
+ JsonNode reference = node.get(keyword);
+ if (reference != null && reference.isTextual() && !reference.asText().startsWith("#")) {
+ throw new IllegalStateException(
+ "Tool inputSchema " + keyword + " must stay inside the document");
+ }
+ }
+ }
+
+ /**
+ * schema가 선언한 dialect가 MCP가 쓰는 2020-12인지 확인합니다. 선언이 없으면 검증기의 기본 dialect가 적용되므로 통과시킵니다.
+ */
+ private static void assertDialectIsSupported(JsonNode node) {
+ JsonNode dialect = node.get("$schema");
+ if (dialect != null && dialect.isTextual() && !SUPPORTED_DIALECT.equals(dialect.asText())) {
+ throw new IllegalStateException("Tool inputSchema $schema must be " + SUPPORTED_DIALECT);
+ }
+ }
+}
diff --git a/src/test/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaPatternPolicyTest.java b/src/test/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaPatternPolicyTest.java
new file mode 100644
index 0000000..4b64778
--- /dev/null
+++ b/src/test/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaPatternPolicyTest.java
@@ -0,0 +1,166 @@
+package io.shinhanlife.dat.biz.mcp.registry;
+
+import static io.shinhanlife.dat.biz.mcp.TestFixtures.OBJECT_MAPPER;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.junit.jupiter.api.Test;
+
+/**
+ * 매니페스트가 준 정규식이 요청 스레드를 오래 붙잡지 못한다는 불변식을 고정하는 테스트입니다. 여기 실린 위험 정규식은 모두 JDK 21에서 실제로 되돌아오지 않는 것이 확인된 형태이고, 정상 업무 정규식이 함께 막히지
+ * 않는지도 같이 검사합니다. 검사는 {@link ToolMetadata} 생성 시점에 걸리므로 Portal·local·Redis 중 어느 경로로 들어와도 같은 규칙이 적용됩니다.
+ */
+class ToolSchemaPatternPolicyTest {
+
+ @Test
+ void rejectsRepeatingAGroupThatAlreadyRepeatsWithoutBound() {
+ // (x+x+)+y 는 입력 1000자에서 되돌아오지 않았다.
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"q":{"type":"string","maxLength":64,"pattern":"(x+x+)+y"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("repeats without bound");
+ }
+
+ @Test
+ void rejectsABoundedRepetitionOfAnUnboundedGroup() {
+ // (.*,){11}P 는 바깥 반복이 11회로 묶여 있어도 입력 1000자에서 되돌아오지 않았다.
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"q":{"type":"string","maxLength":64,"pattern":"(.*,){11}P"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("repeats without bound");
+ }
+
+ @Test
+ void rejectsMoreUnboundedQuantifiersThanTheBudget() {
+ // a*a*a*a*a*b 는 입력 100자에서 이미 되돌아오지 않았다.
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"q":{"type":"string","maxLength":64,"pattern":"a*a*a*a*a*b"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("unbounded quantifiers");
+ }
+
+ @Test
+ void rejectsAPatternedFieldWithoutALengthBound() {
+ // 모양 검사만으로는 겹치는 문자 집합을 가려낼 수 없어, 길이 상한이 실질적인 방어선이다.
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"q":{"type":"string","pattern":"^[0-9]+$"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("requires maxLength");
+ }
+
+ @Test
+ void rejectsALengthBoundLargeEnoughToStillHurt() {
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"q":{"type":"string","maxLength":100000,"pattern":"^[0-9]+$"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("256");
+ }
+
+ @Test
+ void rejectsPatternPropertiesOutright() {
+ // 입력 객체의 key가 대상이라 길이를 묶을 자리가 없다. 안 쓰는 keyword라 통째로 닫는다.
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","patternProperties":{"^[a-z]+$":{"type":"string"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("patternProperties");
+ }
+
+ @Test
+ void rejectsPatternPropertiesEvenWhenPropertyNamesLooksBounded() {
+ // propertyNames로 길이를 묶어도 keyword 평가 순서가 명세에 없어 정규식이 먼저 돌 수 있다.
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","propertyNames":{"maxLength":16},
+ "patternProperties":{"^(a+a+)+$":{"type":"string"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("patternProperties");
+ }
+
+ @Test
+ void rejectsPatternPropertiesNestedBelowTheRoot() {
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"filter":{"type":"object",
+ "patternProperties":{"^k":{"type":"string"}}}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("patternProperties");
+ }
+
+ @Test
+ void rejectsAPatternThatDoesNotCompile() {
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"q":{"maxLength":64,"pattern":"([unclosed"}}}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("valid regular expression");
+ }
+
+ @Test
+ void rejectsAnExcessivelyLongPattern() throws Exception {
+ JsonNode schema = OBJECT_MAPPER.readTree(
+ "{\"type\":\"object\",\"properties\":{\"q\":{\"maxLength\":64,\"pattern\":\""
+ + "a".repeat(513) + "\"}}}");
+
+ assertThatThrownBy(() -> metadata(schema))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("512");
+ }
+
+ @Test
+ void acceptsOrdinaryBusinessPatterns() {
+ // 실제 업무 schema가 이 정책 때문에 막히면 안 된다.
+ assertThatCode(() -> metadata("""
+ {"type":"object","properties":{
+ "customerNo":{"type":"string","maxLength":10,"pattern":"^[0-9]{10}$"},
+ "email":{"type":"string","maxLength":128,"pattern":"^[^@ ]+@[^@ ]+$"},
+ "code":{"type":"string","maxLength":64,"pattern":"^([A-Z]{3}-)+[0-9]+$"}}}
+ """))
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ void keepsQuantifierCharactersInsideACharacterClassLiteral() {
+ // "[+*]"의 +와 *는 수량자가 아니라 문자다. 오탐으로 정상 Tool을 막으면 안 된다.
+ assertThatCode(() -> metadata("""
+ {"type":"object","properties":{"op":{"type":"string","maxLength":32,"pattern":"^[+*]+$"}}}
+ """))
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ void leavesFieldsWithoutAPatternAlone() {
+ // pattern이 없으면 maxLength를 요구하지 않는다.
+ assertThatCode(() -> metadata("""
+ {"type":"object","properties":{"memo":{"type":"string"}}}
+ """))
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ void acceptsAToolWithoutAnyInputSchema() {
+ assertThatCode(() -> metadata((JsonNode) null)).doesNotThrowAnyException();
+ }
+
+ /**
+ * JSON 문자열을 schema로 갖는 {@link ToolMetadata}를 만들어 생성 시점 검사를 태웁니다.
+ */
+ private static ToolMetadata metadata(String schemaJson) throws JsonProcessingException {
+ return metadata(OBJECT_MAPPER.readTree(schemaJson));
+ }
+
+ /**
+ * 검사 대상 schema 외의 필드는 실행에 영향을 주지 않는 고정값으로 채웁니다.
+ */
+ private static ToolMetadata metadata(JsonNode schema) {
+ return new ToolMetadata(
+ "a.search", "1.0.0", "search", "http://tool-a/mcp", schema, 1_000, true, null);
+ }
+}
diff --git a/src/test/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaReferencePolicyTest.java b/src/test/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaReferencePolicyTest.java
new file mode 100644
index 0000000..1a534f5
--- /dev/null
+++ b/src/test/java/io/shinhanlife/dat/biz/mcp/registry/ToolSchemaReferencePolicyTest.java
@@ -0,0 +1,111 @@
+package io.shinhanlife.dat.biz.mcp.registry;
+
+import static io.shinhanlife.dat.biz.mcp.TestFixtures.OBJECT_MAPPER;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.junit.jupiter.api.Test;
+
+/**
+ * 매니페스트가 준 {@code inputSchema}로는 서버의 outbound 호출 대상을 정할 수 없다는 불변식을 고정하는 테스트입니다. 검사는 {@link ToolMetadata} 생성 시점에 걸리므로 Portal·local·Redis 중 어느
+ * 경로로 들어와도 같은 규칙이 적용되는지를 값 객체 수준에서 확인합니다.
+ */
+class ToolSchemaReferencePolicyTest {
+
+ @Test
+ void rejectsASchemaThatReferencesAnAbsoluteUrl() {
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","$ref":"http://attacker.example/schema.json"}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("$ref");
+ }
+
+ @Test
+ void rejectsAReferenceHiddenDeepInsideNestedProperties() {
+ // 최상위만 보는 검사로는 막히지 않는 위치다.
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","properties":{"outer":{"type":"object",
+ "properties":{"inner":{"$ref":"https://attacker.example/deep.json"}}}}}
+ """))
+ .isInstanceOf(IllegalStateException.class);
+ }
+
+ @Test
+ void rejectsAReferenceInsideAnArrayKeyword() {
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","allOf":[{"$ref":"//attacker.example/protocol-relative.json"}]}
+ """))
+ .isInstanceOf(IllegalStateException.class);
+ }
+
+ @Test
+ void rejectsADynamicReferenceThatLeavesTheDocument() {
+ assertThatThrownBy(() -> metadata("""
+ {"type":"object","$dynamicRef":"https://attacker.example/dynamic.json#node"}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("$dynamicRef");
+ }
+
+ @Test
+ void rejectsADialectOtherThanDraft202012() {
+ // 낯선 dialect를 선언하면 검증기가 그 meta-schema를 외부에서 받아오려 할 수 있다.
+ assertThatThrownBy(() -> metadata("""
+ {"$schema":"https://attacker.example/meta.json","type":"object"}
+ """))
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessageContaining("$schema");
+ }
+
+ @Test
+ void acceptsAReferenceThatStaysInsideTheDocument() throws Exception {
+ JsonNode schema = OBJECT_MAPPER.readTree("""
+ {"type":"object","properties":{"customer":{"$ref":"#/$defs/customer"}},
+ "$defs":{"customer":{"type":"string"}}}
+ """);
+
+ assertThatCode(() -> metadata(schema)).doesNotThrowAnyException();
+ }
+
+ @Test
+ void acceptsTheDeclaredDraft202012Dialect() {
+ assertThatCode(() -> metadata("""
+ {"$schema":"https://json-schema.org/draft/2020-12/schema","type":"object"}
+ """))
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ void acceptsAToolWithoutAnyInputSchema() {
+ assertThatCode(() -> metadata((JsonNode) null)).doesNotThrowAnyException();
+ }
+
+ @Test
+ void keepsAPropertyLiterallyNamedRefUsable() throws Exception {
+ // "$ref"라는 이름의 필드 정의는 참조가 아니라 일반 property이므로 막히면 안 된다.
+ JsonNode schema = OBJECT_MAPPER.readTree("""
+ {"type":"object","properties":{"$ref":{"type":"string"}}}
+ """);
+
+ assertThat(metadata(schema).inputSchema().path("properties").has("$ref")).isTrue();
+ }
+
+ /**
+ * JSON 문자열을 schema로 갖는 {@link ToolMetadata}를 만들어 생성 시점 검사를 태웁니다.
+ */
+ private static ToolMetadata metadata(String schemaJson) throws JsonProcessingException {
+ return metadata(OBJECT_MAPPER.readTree(schemaJson));
+ }
+
+ /**
+ * 검사 대상 schema 외의 필드는 실행에 영향을 주지 않는 고정값으로 채웁니다.
+ */
+ private static ToolMetadata metadata(JsonNode schema) {
+ return new ToolMetadata(
+ "a.search", "1.0.0", "search", "http://tool-a/mcp", schema, 1_000, true, null);
+ }
+}