Merge pull request #25 from WildMeOrg/feat/pipeline-partial-success

feat: keep partial pipeline results when one species or detection fails

Author: JasonWildMe

__tests__/rntl/screens/CaptureScreen.test.tsx

@@ -106,9 +106,33 @@ const MOCK_PIPELINE_RESULT = {
   observationId: 'obs-123',
   photoUri: 'file:///mock/camera.jpg',
   detections: [],
+  errors: [],
   totalInferenceTimeMs: 150,
 };
 
+const MOCK_DETECTION = {
+  id: 'det-1',
+  observationId: 'obs-123',
+  boundingBox: { x: 0.1, y: 0.2, width: 0.3, height: 0.4 },
+  species: 'horse_wild',
+  speciesConfidence: 0.9,
+  croppedImageUri: 'file:///mock/crop.jpg',
+  embedding: [0.1, 0.2],
+  matchResult: {
+    topCandidates: [],
+    approvedIndividual: null,
+    reviewStatus: 'pending',
+  },
+  encounterFields: {
+    locationId: null,
+    sex: null,
+    lifeStage: null,
+    behavior: null,
+    submitterId: null,
+    projectId: null,
+  },
+};
+
 describe('CaptureScreen', () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -338,6 +362,56 @@ describe('CaptureScreen', () => {
     expect(call.speciesConfigs[0].packId).toBe('pack-compatible');
   });
 
+  // ==========================================================================
+  // Partial-success handling
+  // ==========================================================================
+
+  it('saves the observation and warns when some detections failed', async () => {
+    (wildlifePipeline.processPhoto as jest.Mock).mockResolvedValue({
+      ...MOCK_PIPELINE_RESULT,
+      detections: [MOCK_DETECTION],
+      errors: [
+        { species: 'zebra_plains', stage: 'detector', message: 'ONNX error' },
+      ],
+    });
+
+    const { getByTestId } = render(<CaptureScreen />);
+    fireEvent.press(getByTestId('take-photo-button'));
+
+    await waitFor(() => {
+      expect(mockNavigate).toHaveBeenCalledWith('DetectionResults', {
+        observationId: 'obs-123',
+      });
+    });
+    expect(useWildlifeStore.getState().observations).toHaveLength(1);
+    expect(Alert.alert).toHaveBeenCalledWith(
+      'Some detections failed',
+      expect.stringContaining('zebra_plains'),
+    );
+  });
+
+  it('does not save an observation when everything failed', async () => {
+    (wildlifePipeline.processPhoto as jest.Mock).mockResolvedValue({
+      ...MOCK_PIPELINE_RESULT,
+      detections: [],
+      errors: [
+        { species: null, stage: 'embedding-model', message: 'model corrupt' },
+      ],
+    });
+
+    const { getByTestId } = render(<CaptureScreen />);
+    fireEvent.press(getByTestId('take-photo-button'));
+
+    await waitFor(() => {
+      expect(Alert.alert).toHaveBeenCalledWith(
+        'Detection Failed',
+        expect.stringContaining('model corrupt'),
+      );
+    });
+    expect(useWildlifeStore.getState().observations).toHaveLength(0);
+    expect(mockNavigate).not.toHaveBeenCalled();
+  });
+
   // ==========================================================================
   // Error Handling
   // ==========================================================================

__tests__/unit/services/wildlifePipeline.test.ts

@@ -299,18 +299,121 @@ describe('WildlifePipeline', () => {
     expect(mockExtractEmbedding).toHaveBeenCalledTimes(2);
   });
 
-  it('should propagate errors when detector fails', async () => {
-    mockRunDetection.mockRejectedValueOnce(new Error('Detector ONNX error'));
+  it('should record a detector failure as an error and keep other species results', async () => {
+    const detectionResult = {
+      boundingBox: { x: 0.1, y: 0.2, width: 0.3, height: 0.4 },
+      species: 'giraffe',
+      confidence: 0.9,
+    };
+    mockRunDetection
+      .mockRejectedValueOnce(new Error('Detector ONNX error'))
+      .mockResolvedValueOnce({ results: [detectionResult], inferenceTimeMs: 100 });
+    mockExtractEmbedding.mockResolvedValue({
+      embedding: [0.1, 0.2, 0.3],
+      inferenceTimeMs: 50,
+    });
+    mockMatchEmbedding.mockReturnValue([]);
 
-    const config = makeSpeciesConfig();
-    await expect(
-      wildlifePipeline.processPhoto({
-        photoUri: 'file:///photos/fail.jpg',
-  
-        speciesConfigs: [config],
-        miewidModelPath: '/models/miewid.onnx',
-      }),
-    ).rejects.toThrow('Detector ONNX error');
+    const result = await wildlifePipeline.processPhoto({
+      photoUri: 'file:///photos/partial.jpg',
+      speciesConfigs: [
+        makeSpeciesConfig({ species: 'zebra_plains' }),
+        makeSpeciesConfig({
+          packId: 'pack-giraffe',
+          species: 'giraffe',
+          detectorModelPath: '/models/giraffe_detector.onnx',
+        }),
+      ],
+      miewidModelPath: '/models/miewid.onnx',
+    });
+
+    expect(result.detections).toHaveLength(1);
+    expect(result.detections[0].species).toBe('giraffe');
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0]).toMatchObject({
+      species: 'zebra_plains',
+      stage: 'detector',
+      message: expect.stringContaining('Detector ONNX error'),
+    });
+  });
+
+  it('should record a per-detection failure and keep the remaining detections', async () => {
+    const makeDetection = (x: number) => ({
+      boundingBox: { x, y: 0.2, width: 0.3, height: 0.4 },
+      species: 'zebra_plains',
+      confidence: 0.9,
+    });
+    mockRunDetection.mockResolvedValueOnce({
+      results: [makeDetection(0.1), makeDetection(0.5)],
+      inferenceTimeMs: 100,
+    });
+    mockExtractEmbedding
+      .mockRejectedValueOnce(new Error('embedding blew up'))
+      .mockResolvedValueOnce({ embedding: [0.1, 0.2, 0.3], inferenceTimeMs: 50 });
+    mockMatchEmbedding.mockReturnValue([]);
+
+    const result = await wildlifePipeline.processPhoto({
+      photoUri: 'file:///photos/two-animals.jpg',
+      speciesConfigs: [makeSpeciesConfig()],
+      miewidModelPath: '/models/miewid.onnx',
+    });
+
+    expect(result.detections).toHaveLength(1);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0]).toMatchObject({
+      species: 'zebra_plains',
+      stage: 'embedding',
+      message: expect.stringContaining('embedding blew up'),
+    });
+  });
+
+  it('should fail fast with an embedding-model error when MiewID cannot load', async () => {
+    // MiewID is the first load attempt (fail-fast contract)
+    mockIsModelLoaded.mockReturnValueOnce(false);
+    mockLoadModel.mockRejectedValueOnce(new Error('MiewID file corrupt'));
+
+    const result = await wildlifePipeline.processPhoto({
+      photoUri: 'file:///photos/test.jpg',
+      speciesConfigs: [makeSpeciesConfig()],
+      miewidModelPath: '/models/miewid.onnx',
+    });
+
+    expect(result.detections).toHaveLength(0);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0]).toMatchObject({
+      species: null,
+      stage: 'embedding-model',
+      message: expect.stringContaining('MiewID file corrupt'),
+    });
+    // No detector work is wasted when embeddings are impossible
+    expect(mockRunDetection).not.toHaveBeenCalled();
+  });
+
+  it('should return an empty errors array on full success', async () => {
+    mockRunDetection.mockResolvedValueOnce({
+      results: [
+        {
+          boundingBox: { x: 0.1, y: 0.2, width: 0.3, height: 0.4 },
+          species: 'zebra_plains',
+          confidence: 0.9,
+        },
+      ],
+      inferenceTimeMs: 100,
+    });
+    mockExtractEmbedding.mockResolvedValueOnce({
+      embedding: [0.1, 0.2, 0.3],
+      inferenceTimeMs: 50,
+    });
+    mockMatchEmbedding.mockReturnValue([]);
+
+    const result = await wildlifePipeline.processPhoto({
+      photoUri: 'file:///photos/test.jpg',
+      speciesConfigs: [makeSpeciesConfig()],
+      miewidModelPath: '/models/miewid.onnx',
+    });
+
+    expect(result.errors).toEqual([]);
+    expect(result.detections).toHaveLength(1);
   });
 
   it('should accumulate inference time from detection and embedding', async () => {

src/screens/CaptureScreen/useCaptureFlow.ts

@@ -163,6 +163,17 @@ export function useCaptureFlow() {
           miewidModelPath: miewidModel.path,
         });
 
+        // Total failure: nothing completed, nothing worth saving.
+        if (result.detections.length === 0 && result.errors.length > 0) {
+          Alert.alert(
+            'Detection Failed',
+            result.errors
+              .map((e) => (e.species ? `${e.species}: ${e.message}` : e.message))
+              .join('\n'),
+          );
+          return;
+        }
+
         // Save observation to store
         useWildlifeStore.getState().addObservation({
           id: result.observationId,
@@ -178,6 +189,17 @@ export function useCaptureFlow() {
         navigation.navigate('DetectionResults', {
           observationId: result.observationId,
         });
+
+        // Partial failure: the observation is saved with what completed;
+        // tell the user what was lost.
+        if (result.errors.length > 0) {
+          Alert.alert(
+            'Some detections failed',
+            result.errors
+              .map((e) => (e.species ? `${e.species}: ${e.message}` : e.message))
+              .join('\n'),
+          );
+        }
       } catch (error) {
         const message =
           error instanceof Error ? error.message : 'Unknown error';