Keep kernel core failures typed

Rhys Sullivan committed 6 months ago

Commit 025cdf61 parent b039b6e3 files · +16 −13Browse files

Unified · Split

3 files

packages/kernel/core/src/code-recovery.ts +1 −0
packages/kernel/core/src/effect-errors.ts +1 −3
packages/kernel/core/src/validation.ts +14 −10

packages/kernel/core/src/code-recovery.ts+1−0

@@ -139,6 +139,7 @@ export const recoverExecutionBody = (code: string): string => { · 138 unmodified lines
139	const source = extractCandidateSource(code);	139	const source = extractCandidateSource(code);
140	if (!source) return "";	140	if (!source) return "";
141		141
		142	// oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: Babel parser throws for malformed candidate code, then recovery falls back to heuristics
142	try {	143	try {
143	return renderParsedBody(source);	144	return renderParsedBody(source);
144	} catch {	145	} catch {

packages/kernel/core/src/effect-errors.ts+1−3

 export class KernelCoreEffectError extends Data.TaggedError("KernelCoreEffectError")<{
   readonly module: string;
   readonly message: string;
+  readonly cause?: unknown;
 }> {}
-export const kernelCoreEffectError = (module: string, message: string) =>
-  new KernelCoreEffectError({ module, message });
 /**
  * Default failure type for any `CodeExecutor.execute` implementation —
  * surfaces sandbox-level defects (isolate crash, module load failure,

packages/kernel/core/src/validation.ts+14−10

 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import * as Effect from "effect/Effect";
-import { kernelCoreEffectError } from "./effect-errors";
+import { KernelCoreEffectError } from "./effect-errors";
 const getSchemaValidator = (
   schema: unknown,
   const validate = getSchemaValidator(input.schema);
   if (!validate) {
     return Effect.fail(
-      kernelCoreEffectError(
+      new KernelCoreEffectError({
-        "validation",
+        module: "validation",
-        `Tool ${input.path} has no Standard Schema validator on inputSchema`,
+        message: `Tool ${input.path} has no Standard Schema validator on inputSchema`,
-      ),
+      }),
     );
   }
   return Effect.tryPromise({
     try: () => Promise.resolve(validate(input.value)),
     catch: (cause) =>
-      kernelCoreEffectError("validation", `Validation error for ${input.path}: ${String(cause)}`),
+      new KernelCoreEffectError({
+        module: "validation",
+        message: `Validation error for ${input.path}`,
+        cause,
+      }),
   }).pipe(
     Effect.flatMap((result) => {
       if ("issues" in result && result.issues) {
         return Effect.fail(
-          kernelCoreEffectError(
+          new KernelCoreEffectError({
-            "validation",
+            module: "validation",
-            `Input validation failed for ${input.path}: ${formatIssues(result.issues)}`,
+            message: `Input validation failed for ${input.path}: ${formatIssues(result.issues)}`,
-          ),
+          }),
         );
       }
       return Effect.succeed(result.value);