@setluca/mcp 0.1.0 → 0.2.0

package/dist/errors.js

@@ -1,4 +1,6 @@
-import { Data } from "effect";
+import { Data, Match, Option } from "effect";
+import * as z from "zod/v4";
+import { toJsonPayload } from "./serialization.js";
 export class LucaConfigError extends Data.TaggedError("LucaConfigError") {
 }
 export class LucaNetworkError extends Data.TaggedError("LucaNetworkError") {
@@ -7,19 +9,62 @@ export class LucaDecodeError extends Data.TaggedError("LucaDecodeError") {
 }
 export class LucaHttpError extends Data.TaggedError("LucaHttpError") {
 }
-export function formatError(error) {
-    if (error instanceof LucaConfigError) {
-        return error.message;
-    }
-    if (error instanceof LucaNetworkError) {
-        return error.message;
-    }
-    if (error instanceof LucaDecodeError) {
-        return `${error.message}: ${error.body.slice(0, 500)}`;
+/**
+ * One attempt ran past the request timeout and was cancelled. It is its own
+ * error rather than a network error because a caller can retry it safely under
+ * the same rules but cannot tell from a network failure whether the request
+ * reached the API.
+ */
+export class LucaTimeoutError extends Data.TaggedError("LucaTimeoutError") {
+}
+/**
+ * A tool was called with arguments that are not a JSON object. The MCP SDK
+ * validates against the tool's own input schema before the handler runs, so a
+ * real client cannot reach this. It exists so no code ahead of `runPromise` can
+ * throw where the error channel cannot see it.
+ */
+export class LucaToolInputError extends Data.TaggedError("LucaToolInputError") {
+}
+const DECODE_BODY_EXCERPT = 500;
+function formatDecodeError(error) {
+    return `${error.message}: ${error.body.slice(0, DECODE_BODY_EXCERPT)}`;
+}
+function formatHttpError(error) {
+    const request = Option.fromNullable(error.requestId).pipe(Option.match({
+        onNone: () => "",
+        onSome: (requestId) => ` requestId=${requestId}`,
+    }));
+    return `Luca API returned ${error.status} ${error.statusText}${request}: ${toJsonPayload(error.body)}`;
+}
+/**
+ * A value that carries no message of its own, rendered for a human. Anything
+ * that is not already a string comes back as JSON rather than "[object Object]".
+ */
+function formatJsonValue(error) {
+    const text = z.string().safeParse(error);
+    if (text.success) {
+        return text.data;
     }
-    if (error instanceof LucaHttpError) {
-        const request = error.requestId ? ` requestId=${error.requestId}` : "";
-        return `Luca API returned ${error.status} ${error.statusText}${request}: ${JSON.stringify(error.body)}`;
+    const scalar = z.union([z.number(), z.boolean()]).safeParse(error);
+    if (scalar.success) {
+        return String(scalar.data);
     }
-    return error instanceof Error ? error.message : String(error);
+    return toJsonPayload(error);
+}
+/** Any failure this server can hand a client, as one line of text. */
+export function formatError(error) {
+    return error instanceof Error ? formatThrown(error) : formatJsonValue(error);
+}
+/**
+ * A thrown value rendered for a human. The two structured errors get their own
+ * rendering; every other tagged error carries a `message`, and one branch
+ * covers all of them rather than a case per tag that would all say the same
+ * thing.
+ *
+ * The match is on the class, not on `_tag`. This takes any `Error`, including
+ * one thrown by a dependency that carries no tag at all, so there is no tagged
+ * union here for `Match.tag` to narrow.
+ */
+function formatThrown(error) {
+    return Match.value(error).pipe(Match.when(Match.instanceOf(LucaDecodeError), formatDecodeError), Match.when(Match.instanceOf(LucaHttpError), formatHttpError), Match.orElse((thrown) => thrown.message));
 }