Add result helper type

src/main/java/mcp/util/Err.java

@@ -0,0 +1,4 @@
+package mcp.util;
+
+public record Err<E, T extends Throwable>(T throwable) implements Result<E, T> {
+}

src/main/java/mcp/util/Ok.java

@@ -0,0 +1,4 @@
+package mcp.util;
+
+public record Ok<E, T extends Throwable>(E value) implements Result<E, T> {
+}

src/main/java/mcp/util/Result.java

@@ -0,0 +1,61 @@
+package mcp.util;
+
+import java.util.Optional;
+
+public sealed interface Result<E, T extends Throwable> permits Err, Ok {
+   
+    default boolean isError() {
+        return this instanceof Err;
+    }
+    
+    default boolean isOk() {
+        return this instanceof Ok;
+    }
+    
+    default E unwrap() throws T {
+        return switch (this) {
+            case Err<E, T> err -> throw err.throwable();
+            case Ok<E, T> ok -> ok.value();
+        };
+    }
+    
+    default E unwrapOrElse(E defaultValue) {
+        try {
+            return isError() ? defaultValue : unwrap();
+        } catch (Throwable e) {
+            return defaultValue;
+        }
+    }
+    
+    default Optional<E> toOptional() {
+        try {
+            return isError() ? Optional.empty() : Optional.of(unwrap());
+        } catch (Throwable e) {
+            return Optional.empty();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    default <R> Result<R, T> map(java.util.function.Function<? super E, ? extends R> mapper) {
+        return switch (this) {
+            case Ok<E, T> ok -> new Ok<>(mapper.apply(ok.value()));
+            case Err<E, T> err -> (Err<R, T>) err;
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    default <R> Result<R, T> flatMap(java.util.function.Function<? super E, ? extends Result<R, T>> mapper) {
+        return switch (this) {
+            case Ok<E, T> ok -> mapper.apply(ok.value());
+            case Err<E, T> err -> (Err<R, T>) err;
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    default <F extends Throwable> Result<E, F> mapError(java.util.function.Function<? super T, ? extends F> mapper) {
+        return switch (this) {
+            case Ok<E, T> ok -> (Ok<E, F>) ok;
+            case Err<E, T> err -> new Err<>(mapper.apply(err.throwable()));
+        };
+    }
+}