Fix: Handle single-element tuple outputs in layer hook

- Fixed "tuple index out of range" when output has only one element
- Properly checks tuple length before accessing output[1:]
- Handles all output format cases correctly

The previous fix assumed output tuples always had multiple elements,
but some layers return single-element tuples.

🤖 Generated with [Claude Code](https://claude.ai/code)

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

backend/model_service.py

@@ -303,18 +303,24 @@ class ModelManager:
                     # The output is (hidden_states, optional_attention_weights, ...)
                     # We want to pass the input hidden states as if the layer did nothing
                     
-                    if isinstance(input, tuple):
-                        # Return input hidden states, but keep any additional outputs from the layer
-                        # This maintains compatibility with the expected output format
-                        if isinstance(output, tuple) and len(output) > 1:
-                            # Keep attention weights etc. from output if present
-                            return (input[0],) + output[1:]
+                    # Get the input hidden states
+                    if isinstance(input, tuple) and len(input) > 0:
+                        input_hidden_states = input[0]
+                    else:
+                        input_hidden_states = input
+                    
+                    # Return in the same format as the output
+                    if isinstance(output, tuple):
+                        # Check if there are additional elements to preserve
+                        if len(output) > 1:
+                            # Keep any additional outputs (like attention weights)
+                            return (input_hidden_states,) + output[1:]
                         else:
-                            # Just return the input hidden states
-                            return input[0]
+                            # Output is a single-element tuple, return the same
+                            return (input_hidden_states,)
                     else:
-                        # Simple tensor input/output
-                        return input
+                        # Output is a plain tensor, return input as plain tensor
+                        return input_hidden_states
                 return hook
             
             # Apply hooks and log what's being disabled