address class identity mismatch

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: grypez

packages/kernel-agents/src/attempt.ts

@@ -1,4 +1,4 @@
-import { SampleGenerationError } from '@metamask/kernel-errors/bundleable';
+import { isSampleGenerationError } from '@metamask/kernel-errors/bundleable';
 import type { Logger } from '@metamask/logger';
 import type { LanguageModel } from '@ocap/kernel-language-model-service';
 
@@ -44,7 +44,7 @@ export const doAttempt = async <
         return [action, outcome];
       },
       maxRetries,
-      (error) => error instanceof SampleGenerationError,
+      (error) => isSampleGenerationError(error),
     );
 
     // If done, exit

packages/kernel-errors/src/bundleable/index.ts

@@ -8,4 +8,8 @@
  * import { SampleGenerationError } from '@metamask/kernel-errors/bundleable';
  */
 export { SampleGenerationError } from './SampleGenerationError.ts';
-export { ErrorCode, ErrorSentinel } from '../error-codes.ts';
+export {
+  ErrorCode,
+  ErrorSentinel,
+  isSampleGenerationError,
+} from '../error-codes.ts';

packages/kernel-errors/src/constants.ts

@@ -14,7 +14,11 @@ import { ErrorCode, ErrorSentinel } from './error-codes.ts';
 import type { MarshaledError, MarshaledOcapError } from './types.ts';
 
 // Re-export for backward compatibility
-export { ErrorCode, ErrorSentinel } from './error-codes.ts';
+export {
+  ErrorCode,
+  ErrorSentinel,
+  isSampleGenerationError,
+} from './error-codes.ts';
 
 /**
  * Struct to validate plain {@link Error} objects.

packages/kernel-errors/src/error-codes.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+
+import { SampleGenerationError as BundleableSampleGenerationError } from './bundleable/SampleGenerationError.ts';
+import { ErrorCode, isSampleGenerationError } from './error-codes.ts';
+import { SampleGenerationError as MainSampleGenerationError } from './errors/SampleGenerationError.ts';
+
+describe('error-codes', () => {
+  describe('isSampleGenerationError', () => {
+    it('returns true for bundleable SampleGenerationError', () => {
+      const error = new BundleableSampleGenerationError(
+        'invalid sample',
+        new Error('parse failed'),
+      );
+      expect(isSampleGenerationError(error)).toBe(true);
+    });
+
+    it('returns true for main SampleGenerationError', () => {
+      const error = new MainSampleGenerationError(
+        'invalid sample',
+        new Error('parse failed'),
+      );
+      expect(isSampleGenerationError(error)).toBe(true);
+    });
+
+    it('returns false for plain Error', () => {
+      const error = new Error('some error');
+      expect(isSampleGenerationError(error)).toBe(false);
+    });
+
+    it('returns false for Error with different code', () => {
+      const error = new Error('some error');
+      (error as Error & { code: string }).code = ErrorCode.AbortError;
+      expect(isSampleGenerationError(error)).toBe(false);
+    });
+
+    it('returns false for non-Error values', () => {
+      expect(isSampleGenerationError(null)).toBe(false);
+      expect(isSampleGenerationError(undefined)).toBe(false);
+      expect(isSampleGenerationError('error string')).toBe(false);
+      expect(
+        isSampleGenerationError({ code: ErrorCode.SampleGenerationError }),
+      ).toBe(false);
+    });
+
+    it('narrows type correctly', () => {
+      const error = new BundleableSampleGenerationError(
+        'test sample',
+        new Error('cause'),
+      );
+
+      expect(isSampleGenerationError(error)).toBe(true);
+      // After the check above passes, TypeScript allows accessing these properties
+      expect(error.code).toBe(ErrorCode.SampleGenerationError);
+      expect(error.data.sample).toBe('test sample');
+    });
+  });
+});

packages/kernel-errors/src/error-codes.ts

@@ -20,3 +20,24 @@ export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
  * A sentinel value used to identify marshaled errors.
  */
 export const ErrorSentinel = '@@MARSHALED_ERROR';
+
+/**
+ * Type guard to check if an error is a SampleGenerationError.
+ * Uses error code checking instead of instanceof to work across
+ * package boundaries where different class objects may be used.
+ *
+ * @param error - The error to check.
+ * @returns True if the error has the SampleGenerationError code.
+ */
+export const isSampleGenerationError = (
+  error: unknown,
+): error is Error & {
+  code: typeof ErrorCode.SampleGenerationError;
+  data: { sample: string };
+} => {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    error.code === ErrorCode.SampleGenerationError
+  );
+};

packages/kernel-errors/src/index.test.ts

@@ -23,6 +23,7 @@ describe('index', () => {
       'isMarshaledError',
       'isMarshaledOcapError',
       'isOcapError',
+      'isSampleGenerationError',
       'marshalError',
       'toError',
       'unmarshalError',

packages/kernel-errors/src/index.ts

@@ -13,6 +13,7 @@ export {
   ErrorCode,
   ErrorSentinel,
   ErrorStruct,
+  isSampleGenerationError,
   MarshaledErrorStruct,
   MarshaledOcapErrorStruct,
 } from './constants.ts';