package PBS references and expose paginated MCP reads

This commit is contained in:
2026-09-29 08:48:33 +01:00
parent 58f11a8123
commit feb57c5298
23 changed files with 738 additions and 21 deletions
@@ -304,7 +304,7 @@ public class StudioApplicationConfiguration {
@Bean
p.studio.app.mcp.McpToolRegistry mcpToolRegistry(p.studio.app.mcp.McpToolCatalog catalog, ObjectMapper mapper,
p.studio.api.automation.ProjectKnowledge knowledge) {
// Further providers are connected in PLN-0139 steps 18–20. Never advertise placeholders.
// Further providers are connected in PLN-0139 steps 19–20. Never advertise placeholders.
return new p.studio.app.mcp.McpToolRegistry(catalog, mapper,
p.studio.app.mcp.McpProjectKnowledgeTools.handlers(knowledge, mapper));
}
@@ -20,6 +20,8 @@ import java.util.*;
/** Read-only manifest/provider discovery. Never selects a default frontend or starts a build. */
public final class CompilerProjectKnowledge implements ProjectKnowledge {
private record OwnedReference(String owner, p.studio.compiler.services.FrontendReferenceProvider.Reference reference) {}
private record Discovery(Context context, Map<String, OwnedReference> references) {}
private static final int MAX_PROJECTS = 256;
private final ProjectAccessRegistry openProjects;
private final ProjectCatalog projects;
@@ -33,6 +35,10 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge {
}
@Override public Context context(Path openProjectRoot) {
return discover(openProjectRoot).context();
}
private Discovery discover(Path openProjectRoot) {
Path root = openProjects.requireOpenRoot(openProjectRoot);
var limitations = new ArrayList<String>();
var discovered = new LinkedHashMap<Path, ProjectReference>();
@@ -128,12 +134,15 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge {
}
}
libraries.addAll(unresolved);
var references = new LinkedHashMap<String, OwnedReference>();
discovered.values().forEach(project -> collectReferences(project, references, limitations));
var languages = new ArrayList<Language>();
String primary = discovered.get(root).languageId();
if (byLanguage.size() > 1) limitations.add("The installed build pipeline requires the same language across the dependency graph");
for (var entry : byLanguage.entrySet()) {
var language = language(entry.getKey(), entry.getValue(), primary.equals(entry.getKey()),
dependenciesComplete && byLanguage.size() == 1, limitations);
dependenciesComplete && byLanguage.size() == 1, limitations,
references.entrySet().stream().filter(ref -> ref.getValue().owner().equals(entry.getKey())).map(Map.Entry::getKey).toList());
languages.add(language);
for (Path source : language.sourceRoots()) if (!source.startsWith(root)) readOnly.add(source);
for (var project : entry.getValue()) {
@@ -144,15 +153,19 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge {
}
}
limitations.add("SDK resources are provider-owned, read-only resources, not editable project files");
limitations.add("DOCUMENTATION_UNAVAILABLE: installed language/SDK reference index is not yet available");
// Closing a project during discovery must not publish a successful context for that closed project.
openProjects.requireOpenRoot(root);
return new Context(root, discovered.get(root).name(), languages, libraries,
List.of(root), List.copyOf(readOnly), List.of(), limitations);
var descriptors = references.values().stream().map(owned -> {
var ref = owned.reference();
return new Reference(ref.id(), ref.title(), owned.owner(), ReferenceKind.valueOf(ref.kind().name()),
new Version(ref.version(), ref.versionSource()));
}).toList();
return new Discovery(new Context(root, discovered.get(root).name(), languages, libraries,
List.of(root), List.copyOf(readOnly), descriptors, limitations.stream().distinct().toList()), Map.copyOf(references));
}
private Language language(String id, List<ProjectReference> projects, boolean primary,
boolean graphBuildable, List<String> limitations) {
boolean graphBuildable, List<String> limitations, List<String> referenceIds) {
var sdkVersions = projects.stream().map(ProjectReference::stdlibVersion).distinct().toList();
Version sdk = sdkVersions.size() == 1
? new Version(sdkVersions.getFirst().toString(), "prometeu.json#stdlib (requested)") : Version.unknown();
@@ -161,7 +174,7 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge {
if (provider.isEmpty()) {
limitations.add("UNSUPPORTED_LANGUAGE: no installed frontend for " + id);
return new Language(id, primary, Version.unknown(), Version.unknown(), sdk, List.of(), List.of(),
List.of(capability("build", false), capability("lsp", false)), List.of());
List.of(capability("build", false), capability("lsp", false)), referenceIds);
}
var spec = provider.get().specification();
var roots = new LinkedHashSet<Path>();
@@ -176,7 +189,35 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge {
String compilerVersion = provider.get().getClass().getPackage().getImplementationVersion();
return new Language(id, primary, Version.unknown(), compilerVersion == null || compilerVersion.isBlank()
? Version.unknown() : new Version(compilerVersion, "installed frontend package Implementation-Version"), sdk,
spec.getAllowedExtensions().stream().sorted().toList(), List.copyOf(roots), capabilities, List.of());
spec.getAllowedExtensions().stream().sorted().toList(), List.copyOf(roots), capabilities, referenceIds);
}
private void collectReferences(ProjectReference project, Map<String, OwnedReference> references, List<String> limitations) {
String owner = project.languageId();
String selection = owner + " / " + project.target() + " / SDK " + project.stdlibVersion();
try {
var documentation = FrontendRegistryService.getProvider(owner).flatMap(p.studio.compiler.services.FrontendProvider::documentation);
if (documentation.isEmpty()) {
limitations.add("DOCUMENTATION_UNAVAILABLE: no installed reference provider for " + owner);
return;
}
var selected = documentation.get().references(project.stdlibVersion(), p.studio.AppMode.valueOf(project.target().name()));
var additions = new LinkedHashMap<String, OwnedReference>();
for (var reference : selected) {
var owned = new OwnedReference(owner, reference);
if (!reference.id().startsWith(owner + ":")
|| references.containsKey(reference.id()) && !references.get(reference.id()).equals(owned)
|| additions.putIfAbsent(reference.id(), owned) != null)
throw new IllegalStateException("Ambiguous or invalid reference ID");
}
references.putAll(additions);
if (selected.isEmpty()) limitations.add("DOCUMENTATION_UNAVAILABLE: no installed references for " + selection);
if (selected.stream().noneMatch(ref -> ref.kind() == p.studio.compiler.services.FrontendReferenceProvider.Kind.SDK
&& Integer.toString(project.stdlibVersion()).equals(ref.version())))
limitations.add("DOCUMENTATION_UNAVAILABLE: no installed SDK reference for " + selection);
} catch (RuntimeException unavailable) {
limitations.add("DOCUMENTATION_UNAVAILABLE: cannot load installed references for " + selection);
}
}
private void addLspCapabilities(String id, ProjectReference project, List<Capability> capabilities, List<String> limitations) {
@@ -224,6 +265,21 @@ public final class CompilerProjectKnowledge implements ProjectKnowledge {
@Override public ReferencePage readReference(Path openProjectRoot, String referenceId, int offset, int limit) {
openProjects.requireOpenRoot(openProjectRoot);
throw new AutomationException(AutomationFailure.Code.DOCUMENTATION_UNAVAILABLE, "No installed reference index is available");
if (referenceId == null || referenceId.isBlank() || offset < 0 || limit < 1 || limit > 16000)
throw new IllegalArgumentException("Invalid reference ID or pagination");
var discovery = discover(openProjectRoot);
var reference = discovery.references().get(referenceId);
if (reference == null) {
var primary = discovery.context().languages().stream().filter(Language::primary).findFirst().orElseThrow();
var code = FrontendRegistryService.getProvider(primary.id()).isEmpty() ? AutomationFailure.Code.UNSUPPORTED_LANGUAGE
: discovery.references().isEmpty() ? AutomationFailure.Code.DOCUMENTATION_UNAVAILABLE : AutomationFailure.Code.REFERENCE_NOT_FOUND;
throw new AutomationException(code, "Reference is not available in this project's installed index");
}
String text = reference.reference().text();
int total = text.codePointCount(0, text.length());
if (offset > total) throw new IllegalArgumentException("Reference offset exceeds its length");
int next = offset + Math.min(limit, total - offset);
String page = text.substring(text.offsetByCodePoints(0, offset), text.offsetByCodePoints(0, next));
return new ReferencePage(referenceId, offset, total, next == total ? null : next, page);
}
}
@@ -19,6 +19,16 @@ public final class McpProjectKnowledgeTools {
var paths = new SimpleModule().addSerializer(Path.class, new ToStringSerializer());
var wireMapper = mapper.copy().registerModule(paths);
return Map.of("studio_project_context", arguments -> McpToolResult.success(mapper,
wireMapper.valueToTree(knowledge.context(Path.of(arguments.path("projectRoot").asText())))));
wireMapper.valueToTree(knowledge.context(Path.of(arguments.path("projectRoot").asText())))),
"studio_reference_read", arguments -> McpToolResult.success(mapper, wireMapper.valueToTree(
knowledge.readReference(Path.of(arguments.path("projectRoot").asText()), arguments.path("referenceId").asText(),
integer(arguments, "offset", 0), integer(arguments, "limit", 4000)))));
}
private static int integer(JsonNode arguments, String name, int fallback) {
var value = arguments.get(name);
if (value == null) return fallback;
if (!value.isIntegralNumber() || !value.canConvertToInt()) throw new IllegalArgumentException("Invalid " + name);
return value.intValue();
}
}
@@ -111,6 +111,7 @@
"offset": {
"type": "integer",
"minimum": 0,
"maximum": 2147483647,
"default": 0
},
"limit": {
@@ -183,12 +184,12 @@
},
"exampleArguments": {
"projectRoot": "/projects/game",
"referenceId": "pbs.quickstart",
"referenceId": "pbs:quickstart",
"offset": 0,
"limit": 4000
},
"exampleValue": {
"referenceId": "pbs.quickstart",
"referenceId": "pbs:quickstart",
"offset": 0,
"total": 7,
"nextOffset": null,
@@ -30,8 +30,9 @@ class StudioApplicationConfigurationTest {
assertFalse(executor.isShutdown());
assertTrue(mcp.isRunning());
var tools = context.getBean(p.studio.app.mcp.McpToolRegistry.class).descriptors();
org.junit.jupiter.api.Assertions.assertEquals(1, tools.size());
org.junit.jupiter.api.Assertions.assertEquals(2, tools.size());
org.junit.jupiter.api.Assertions.assertEquals("studio_project_context", tools.get(0).path("name").asText());
org.junit.jupiter.api.Assertions.assertEquals("studio_reference_read", tools.get(1).path("name").asText());
}
assertTrue(executor.isShutdown());
assertFalse(mcp.isRunning());
@@ -45,8 +45,10 @@ class CompilerProjectKnowledgeTest {
assertEquals(List.of(root), result.editableRoots());
assertFalse(result.libraries().getFirst().editable());
assertTrue(result.libraries().getFirst().id().startsWith("sdk:pbs:"));
assertTrue(result.references().isEmpty());
assertTrue(result.limitations().stream().anyMatch(value -> value.contains("DOCUMENTATION_UNAVAILABLE")));
assertFalse(result.references().isEmpty());
assertTrue(result.references().stream().anyMatch(value -> value.id().equals("pbs:quickstart")));
assertTrue(language.referenceIds().contains("pbs:quickstart"));
assertFalse(result.limitations().stream().anyMatch(value -> value.contains("DOCUMENTATION_UNAVAILABLE")));
assertFalse(Files.exists(root.resolve(".workspace")));
assertFalse(Files.exists(root.resolve(".studio")));
}
@@ -0,0 +1,62 @@
package p.studio.app.compiler;
import com.fasterxml.jackson.databind.ObjectMapper;
import p.studio.api.automation.ProjectKnowledge;
import p.studio.compiler.FrontendRegistryService;
import p.studio.compiler.messages.BuilderPipelineConfig;
import p.studio.compiler.models.BuilderPipelineContext;
import p.studio.compiler.workspaces.BuilderPipelineService;
import p.studio.core.project.*;
import p.studio.utilities.logs.LogAggregator;
import java.nio.file.Files;
import java.nio.file.Path;
/** Separate JVM gate: product classes/resources must resolve exclusively from installDist JARs. */
public final class InstalledKnowledgeProbe {
public static void main(String[] arguments) throws Exception {
var provider = FrontendRegistryService.require("pbs");
check(provider.getClass().getProtectionDomain().getCodeSource().getLocation().getPath().endsWith(".jar"), "Frontend must come from installed JAR");
check(CompilerProjectKnowledge.class.getProtectionDomain().getCodeSource().getLocation().getPath().endsWith(".jar"), "App must come from installed JAR");
check(!Files.exists(Path.of("settings.gradle.kts")) && !Files.exists(Path.of("docs")), "No repository in working directory");
Path root = Files.createDirectory(Path.of("example")).toRealPath();
var docs = provider.documentation().orElseThrow().references(1, p.studio.AppMode.Game);
for (var reference : docs) {
if (reference.id().startsWith("pbs:example:game:1:")) {
Path file = root.resolve(reference.id().substring("pbs:example:game:1:".length()));
Files.createDirectories(file.getParent());
Files.writeString(file, reference.text());
}
}
var mapper = new ObjectMapper();
var access = new ProjectAccessRegistry();
var registration = access.register(root, () -> { throw new AssertionError("References require no grant"); }, () -> true);
var catalog = new ProjectCatalogService(root, mapper, new ProjectLocalStudioSetupStore(mapper));
var knowledge = new CompilerProjectKnowledge(access, catalog, mapper);
var context = knowledge.context(root);
for (var kind : java.util.List.of(ProjectKnowledge.ReferenceKind.QUICKSTART, ProjectKnowledge.ReferenceKind.SYNTAX,
ProjectKnowledge.ReferenceKind.SEMANTICS, ProjectKnowledge.ReferenceKind.EXAMPLE, ProjectKnowledge.ReferenceKind.SDK))
check(context.references().stream().anyMatch(ref -> ref.kind() == kind), "Missing " + kind);
for (var reference : docs) {
var actual = new StringBuilder();
int offset = 0;
while (true) {
var page = knowledge.readReference(root, reference.id(), offset, 997);
actual.append(page.text());
if (page.nextOffset() == null) break;
offset = page.nextOffset();
}
check(actual.toString().equals(reference.text()), "Incorrect installed reference: " + reference.id());
}
var result = BuilderPipelineService.INSTANCE.compile(
BuilderPipelineContext.fromConfig(new BuilderPipelineConfig(false, root.toString())), LogAggregator.empty());
check(result.diagnostics().stream().noneMatch(issue -> issue.isError()), "Example must compile without errors");
check(result.bytecodeBytes().length > 0, "Example must produce bytecode");
registration.unsubscribe();
System.out.println("Installed knowledge verified: " + docs.size() + " references; example compiled");
}
private static void check(boolean condition, String message) {
if (!condition) throw new AssertionError(message);
}
}
@@ -0,0 +1,33 @@
package p.studio.app.compiler;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import static org.junit.jupiter.api.Assertions.*;
class InstalledKnowledgeTest {
@TempDir Path outsideRepository;
@Test void installedJarsProvideAllReferencesAndCompileTheExampleOutsideTheCheckout() throws Exception {
Path distribution = Path.of(System.getProperty("studio.test.distribution"));
String jars;
try (var files = Files.list(distribution.resolve("lib"))) {
jars = files.filter(file -> file.toString().endsWith(".jar")).sorted()
.map(Path::toString).collect(Collectors.joining(java.io.File.pathSeparator));
}
String probeClasses = Path.of(InstalledKnowledgeProbe.class.getProtectionDomain().getCodeSource().getLocation().toURI()).toString();
Path output = outsideRepository.resolve("probe.log");
var process = new ProcessBuilder(Path.of(System.getProperty("java.home"), "bin", "java").toString(),
"-cp", jars + java.io.File.pathSeparator + probeClasses, InstalledKnowledgeProbe.class.getName())
.directory(outsideRepository.toFile()).redirectErrorStream(true).redirectOutput(output.toFile()).start();
try {
assertTrue(process.waitFor(45, TimeUnit.SECONDS), "Installed knowledge probe timed out");
String log = Files.readString(output);
assertEquals(0, process.exitValue(), log);
assertTrue(log.contains("references; example compiled"), log);
} finally { if (process.isAlive()) process.destroyForcibly().waitFor(); }
}
}
@@ -0,0 +1,143 @@
package p.studio.app.compiler;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.studio.api.automation.*;
import p.studio.compiler.FrontendRegistryService;
import p.studio.compiler.models.FrontendSpec;
import p.studio.compiler.services.*;
import p.studio.core.project.*;
import p.studio.utilities.structures.ReadOnlySet;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import static org.junit.jupiter.api.Assertions.*;
class ProjectReferencesTest {
@TempDir Path root;
final ObjectMapper mapper = new ObjectMapper();
final ProjectAccessRegistry access = new ProjectAccessRegistry();
CompilerProjectKnowledge knowledge(String language, String sdk) throws Exception {
writeManifest(language, sdk);
access.register(root, () -> { throw new AssertionError("Read needs no grant"); }, () -> true);
return new CompilerProjectKnowledge(access, new ProjectCatalogService(root, mapper, new ProjectLocalStudioSetupStore(mapper)), mapper);
}
void writeManifest(String language, String sdk) throws Exception {
mapper.writeValue(root.resolve("prometeu.json").toFile(), Map.of("name", "References", "version", "1.0.0",
"language", language, "stdlib", sdk, "target", "Game", "dependencies", List.of()));
}
@Test void pbsReferenceKindsAndVersionsMatchTheInstalledProviderAndPaginateExactly() throws Exception {
var knowledge = knowledge("pbs", "1");
var context = knowledge.context(root);
var kinds = context.references().stream().map(ProjectKnowledge.Reference::kind).collect(java.util.stream.Collectors.toSet());
assertTrue(kinds.containsAll(List.of(ProjectKnowledge.ReferenceKind.QUICKSTART, ProjectKnowledge.ReferenceKind.SYNTAX,
ProjectKnowledge.ReferenceKind.SEMANTICS, ProjectKnowledge.ReferenceKind.EXAMPLE, ProjectKnowledge.ReferenceKind.SDK)));
assertEquals(context.references().size(), context.languages().getFirst().referenceIds().size());
for (var reference : context.references()) {
assertEquals("pbs", reference.owner());
if (reference.kind() == ProjectKnowledge.ReferenceKind.SDK || reference.kind() == ProjectKnowledge.ReferenceKind.EXAMPLE) {
assertEquals("1", reference.version().value());
assertTrue(reference.version().source().contains("SDK"));
} else assertFalse(reference.version().known());
}
var sdk = "pbs:sdk:game:1:sdk/gfx/main.pbs";
var expected = FrontendRegistryService.require("pbs").documentation().orElseThrow().references(1, p.studio.AppMode.Game)
.stream().filter(ref -> ref.id().equals(sdk)).findFirst().orElseThrow().text();
var actual = new StringBuilder();
int offset = 0;
do {
var page = knowledge.readReference(root, sdk, offset, 97);
assertEquals(expected.codePointCount(0, expected.length()), page.total());
actual.append(page.text());
if (page.nextOffset() == null) break;
offset = page.nextOffset();
} while (true);
assertEquals(expected, actual.toString());
assertTrue(actual.toString().contains("fn fill_rect"));
}
@Test void unknownAndTraversalLikeIdsNeverReadFilesOrUrls() throws Exception {
var knowledge = knowledge("pbs", "1");
Path secret = root.resolve("secret.txt");
Files.writeString(secret, "not a reference");
for (String id : List.of(secret.toString(), secret.toUri().toString(), "../secret.txt", "pbs:../secret.txt",
"pbs-knowledge/index.json", "pbs:%2e%2e/secret.txt", "https://example.invalid", "pbs:unknown")) {
assertEquals(AutomationFailure.Code.REFERENCE_NOT_FOUND,
assertThrows(AutomationException.class, () -> knowledge.readReference(root, id, 0, 100)).failure().code());
}
}
@Test void changedSdkCannotReadPreviouslyAdvertisedSdkOrExampleIds() throws Exception {
var knowledge = knowledge("pbs", "1");
assertTrue(knowledge.context(root).languages().getFirst().referenceIds().contains("pbs:sdk:game:1:sdk/gfx/main.pbs"));
writeManifest("pbs", "999");
var context = knowledge.context(root);
assertTrue(context.references().stream().noneMatch(ref -> ref.kind() == ProjectKnowledge.ReferenceKind.SDK || ref.kind() == ProjectKnowledge.ReferenceKind.EXAMPLE));
assertTrue(context.limitations().stream().anyMatch(value -> value.contains("no installed SDK reference")));
assertEquals(AutomationFailure.Code.REFERENCE_NOT_FOUND, assertThrows(AutomationException.class,
() -> knowledge.readReference(root, "pbs:sdk:game:1:sdk/gfx/main.pbs", 0, 100)).failure().code());
assertFalse(knowledge.readReference(root, "pbs:quickstart", 0, 100).text().isEmpty());
}
@Test void paginationCountsUnicodeCodePointsAndAcceptsTheExactEnd() throws Exception {
String id = "reference-test";
register(id, Optional.of((sdk, target) -> List.of(new FrontendReferenceProvider.Reference(
id + ":text", "Unicode text", FrontendReferenceProvider.Kind.QUICKSTART, null, "unknown", "A😀é\nB"))));
try {
var knowledge = knowledge(id, "1");
var emoji = knowledge.readReference(root, id + ":text", 1, 1);
assertEquals("😀", emoji.text());
assertEquals(5, emoji.total());
assertEquals(2, emoji.nextOffset());
var end = knowledge.readReference(root, id + ":text", 5, 100);
assertEquals("", end.text()); assertNull(end.nextOffset());
for (int offset : List.of(-1, 6, Integer.MAX_VALUE))
assertThrows(IllegalArgumentException.class, () -> knowledge.readReference(root, id + ":text", offset, 1));
for (int limit : List.of(0, -1, 16001))
assertThrows(IllegalArgumentException.class, () -> knowledge.readReference(root, id + ":text", 0, limit));
} finally { FrontendRegistryService.unregister(id); }
}
@Test void missingDocumentationAndUnsupportedLanguageHaveExplicitFailures() throws Exception {
String id = "reference-test";
register(id, Optional.empty());
try {
var knowledge = knowledge(id, "1");
assertTrue(knowledge.context(root).references().isEmpty());
assertEquals(AutomationFailure.Code.DOCUMENTATION_UNAVAILABLE, assertThrows(AutomationException.class,
() -> knowledge.readReference(root, id + ":text", 0, 100)).failure().code());
writeManifest("uninstalled", "1");
assertEquals(AutomationFailure.Code.UNSUPPORTED_LANGUAGE, assertThrows(AutomationException.class,
() -> knowledge.readReference(root, id + ":text", 0, 100)).failure().code());
} finally { FrontendRegistryService.unregister(id); }
}
@Test void failingProviderDoesNotAdvertiseUnreadableReferences() throws Exception {
String id = "reference-test";
register(id, Optional.of((sdk, target) -> { throw new IllegalStateException("Missing installed index"); }));
try {
var knowledge = knowledge(id, "1");
var context = knowledge.context(root);
assertTrue(context.references().isEmpty());
assertTrue(context.limitations().stream().anyMatch(value -> value.contains("cannot load installed references")));
assertEquals(AutomationFailure.Code.DOCUMENTATION_UNAVAILABLE, assertThrows(AutomationException.class,
() -> knowledge.readReference(root, id + ":text", 0, 100)).failure().code());
} finally { FrontendRegistryService.unregister(id); }
}
private void register(String id, Optional<FrontendReferenceProvider> documentation) {
FrontendRegistryService.register(new FrontendProvider() {
@Override public FrontendSpec specification() {
return FrontendSpec.builder().languageId(id).allowedExtensions(ReadOnlySet.from("alt"))
.sourceRoots(ReadOnlySet.from("src")).stdlibVersions(List.of(FrontendSpec.Stdlib.of(1))).build();
}
@Override public FrontendPhaseService compiler() { throw new AssertionError("No compilation for reference reads"); }
@Override public Optional<FrontendReferenceProvider> documentation() { return documentation; }
});
}
}
@@ -129,6 +129,20 @@ class LocalMcpServerTest {
assertEquals("pbs", value.path("languages").get(0).path("id").asText());
assertTrue(value.path("languages").get(0).path("languageVersion").path("value").isNull());
assertFalse(java.nio.file.Files.exists(root.resolve(".studio")));
var params = (com.fasterxml.jackson.databind.node.ObjectNode) call.path("params");
params.put("name", "studio_reference_read");
var arguments = (com.fasterxml.jackson.databind.node.ObjectNode) params.path("arguments");
arguments.put("referenceId", "pbs:quickstart");
var page = mapper.readTree(post(call.toString()).body()).path("result").path("structuredContent").path("value");
assertEquals(0, page.path("offset").asInt());
assertEquals(4000, page.path("text").asText().codePointCount(0, page.path("text").asText().length()));
assertEquals(4000, page.path("nextOffset").asInt());
arguments.put("offset", 4294967296L);
assertEquals(-32602, mapper.readTree(post(call.toString()).body()).path("error").path("code").asInt());
arguments.remove("offset");
arguments.put("referenceId", "../../prometeu.json");
var missing = mapper.readTree(post(call.toString()).body()).path("result");
assertEquals("REFERENCE_NOT_FOUND", missing.path("structuredContent").path("error").path("code").asText());
registration.unsubscribe();
var denied = mapper.readTree(post(call.toString()).body()).path("result");
assertTrue(denied.path("isError").asBoolean());