wisent 0.5.12__py3-none-any.whl → 0.5.14__py3-none-any.whl

wisent/core/parser_arguments/utils.py

@@ -0,0 +1,111 @@
+"""
+Utility functions for parser arguments.
+
+Shared helper functions used across multiple command parsers.
+"""
+
+from typing import List, Optional
+
+
+def parse_layers_from_arg(layer_arg: str, model=None) -> List[int]:
+    """
+    Parse layer argument into list of integers.
+
+    Args:
+        layer_arg: String like "15", "14-16", "14,15,16", or "-1" (for auto-optimization)
+        model: Model object (needed for determining available layers)
+
+    Returns:
+        List of layer indices
+    """
+    # Handle special cases
+    if layer_arg == "-1":
+        # Signal for auto-optimization - return single layer list
+        return [-1]
+
+    # Use existing parse_layer_range logic
+    layers = parse_layer_range(layer_arg, model)
+    if layers is None:
+        # "all" case - auto-detect model layers
+        if model is not None:
+            from wisent.core.hyperparameter_optimizer import detect_model_layers
+
+            total_layers = detect_model_layers(model)
+            return list(range(total_layers))
+        # If no model provided, we cannot determine layers - this should not happen
+        raise ValueError("Cannot determine layer range without model instance")
+
+    return layers
+
+
+def parse_layer_range(layer_range_str: str, model=None) -> Optional[List[int]]:
+    """
+    Parse layer range string into list of integers.
+
+    Args:
+        layer_range_str: String like "8-24", "10,15,20", or "all"
+        model: Model object (needed for "all" option)
+
+    Returns:
+        List of layer indices, or None if "all" (will be auto-detected later)
+    """
+    if layer_range_str.lower() == "all":
+        # Return None to signal auto-detection
+        return None
+    if "-" in layer_range_str:
+        # Range format: "8-24"
+        start, end = map(int, layer_range_str.split("-"))
+        return list(range(start, end + 1))
+    if "," in layer_range_str:
+        # Comma-separated format: "10,15,20"
+        return [int(x.strip()) for x in layer_range_str.split(",")]
+    # Single layer
+    return [int(layer_range_str)]
+
+
+def aggregate_token_scores(token_scores: List[float], method: str) -> float:
+    """
+    Aggregate token scores using the specified method.
+
+    Args:
+        token_scores: List of token scores (probabilities)
+        method: Aggregation method ("average", "final", "first", "max", "min")
+
+    Returns:
+        Aggregated score
+    """
+    if not token_scores:
+        return 0.5
+
+    # Convert any tensor values to floats and filter out None values
+    clean_scores = []
+    for i, score in enumerate(token_scores):
+        if score is None:
+            raise ValueError(
+                f"Token score at index {i} is None! This indicates a bug in the classifier output handling."
+            )
+        if hasattr(score, "item"):  # Handle tensors
+            raise ValueError(
+                f"Token score at index {i} is a tensor ({type(score)})! Expected float but got tensor: {score}"
+            )
+        if not isinstance(score, (int, float)):
+            raise ValueError(
+                f"Token score at index {i} has invalid type: {type(score)}. Expected float but got {type(score).__name__}: {score}"
+            )
+        clean_scores.append(float(score))
+
+    if not clean_scores:
+        return 0.5
+
+    if method == "average":
+        return sum(clean_scores) / len(clean_scores)
+    if method == "final":
+        return clean_scores[-1]
+    if method == "first":
+        return clean_scores[0]
+    if method == "max":
+        return max(clean_scores)
+    if method == "min":
+        return min(clean_scores)
+    # Default to average if unknown method
+    return sum(clean_scores) / len(clean_scores)

wisent/core/prompts/core/prompt_formater.py

@@ -110,14 +110,14 @@ class PromptFormatter:
             RuntimeError: If the 'strategies' package is not found or no strategies are discovered.
         """
         try:
-            import wisent_guard.core.prompts.prompt_stratiegies as strategies_pkg
+            import wisent.core.prompts.prompt_stratiegies as strategies_pkg
         except ModuleNotFoundError as exc:
             raise RuntimeError(
                 "The 'strategies' package was not found. "
                 "Create a 'strategies' directory with an empty __init__.py."
             ) from exc
 
-        import wisent_guard.core.prompts.prompt_stratiegies as strategies_pkg
+        import wisent.core.prompts.prompt_stratiegies as strategies_pkg
 
         for module_info in pkgutil.iter_modules(strategies_pkg.__path__):
             name = module_info.name
@@ -125,7 +125,7 @@ class PromptFormatter:
                 # Skip private/dunder modules.
                 continue
 
-            module = importlib.import_module(f"strategies.{name}")
+            module = importlib.import_module(f"wisent.core.prompts.prompt_stratiegies.{name}")
             self._register_strategies_from_module(module)
 
         if not self._registry:

wisent/core/prompts/prompt_stratiegies/direct_completion.py

@@ -7,6 +7,8 @@ __all__ = ["DirectCompletionStrategy"]
 class DirectCompletionStrategy(PromptStrategy):
     """Direct completion strategy: question from user, answer from assistant."""
 
+    strategy_key = "direct_completion"
+
     def build(
         self,
         question: str,

wisent/core/prompts/prompt_stratiegies/instruction_following.py

@@ -7,6 +7,8 @@ __all__ = ["InstructionFollowingStrategy"]
 class InstructionFollowingStrategy(PromptStrategy):
     """Plain instruction/QA style: question from user, answer from assistant."""
 
+    strategy_key = "instruction_following"
+
     def build(
         self,
         question: str,

wisent/core/prompts/prompt_stratiegies/multiple_choice.py

@@ -7,6 +7,8 @@ __all__ = ["MultipleChoiceStrategy"]
 class MultipleChoiceStrategy(PromptStrategy):
     """Formats a multiple-choice prompt with options A/B."""
 
+    strategy_key = "multiple_choice"
+
     def build(
         self,
         question: str,

wisent/core/prompts/prompt_stratiegies/role_playing.py

@@ -7,6 +7,8 @@ __all__ = ["RolePlayingStrategy"]
 class RolePlayingStrategy(PromptStrategy):
     """Asks the model to behave like someone who gives a specific answer."""
 
+    strategy_key = "role_playing"
+
     def build(
         self,
         question: str,

wisent/{cli/steering_methods/steering_rotator.py → core/steering_methods/rotator.py}

@@ -25,7 +25,7 @@ class SteeringMethodRotator:
     def __init__(
         self,
         method: str | BaseSteeringMethod | Type[BaseSteeringMethod] | None = None,
-        methods_location: str | Path = "wisent_guard.core.steering_methods.methods",
+        methods_location: str | Path = "wisent.core.steering_methods.methods",
         autoload: bool = True,
         **default_method_kwargs: Any,
     ) -> None:
@@ -44,7 +44,7 @@ class SteeringMethodRotator:
                 spec = importlib.util.spec_from_file_location(mod_name, py)
                 if spec and spec.loader:
                     module = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(module)  
+                    spec.loader.exec_module(module)
             return
 
         if not isinstance(location, str):
@@ -91,7 +91,7 @@ class SteeringMethodRotator:
         if isinstance(method, str):
             return BaseSteeringMethod.get(method)(**kwargs)
         raise TypeError("method must be None, str name, BaseSteeringMethod instance, or subclass.")
-    
+
     def use(self, method: str | BaseSteeringMethod | Type[BaseSteeringMethod], **kwargs: Any) -> None:
         self._method = self._resolve_method(method, **kwargs)
 
@@ -107,4 +107,4 @@ if __name__ == "__main__":
     rot = SteeringMethodRotator()
     print("Available steering methods:")
     for m in rot.list_methods():
-        print(f" - {m['name']}: {m['description']} ({m['class']})")
+        print(f" - {m['name']}: {m['description']} ({m['class']})")

wisent/core/steering_optimizer.py

@@ -392,19 +392,21 @@ class SteeringOptimizer:
         
         if layer_search_range is None:
             # Default: search around classification layer if available
-            if self.base_classification_layer:
-                min_layer = max(1, self.base_classification_layer - 3)
-                max_layer = self.base_classification_layer + 3
-                layer_search_range = (min_layer, max_layer)
-            else:
-                # TODO: Auto-detect model layer count and use reasonable range
-                layer_search_range = (10, 20)  # Default fallback
-        
-        # TODO: Implement layer optimization logic
+            if not self.base_classification_layer:
+                raise ValueError(
+                    "Layer optimization requires either layer_search_range parameter or "
+                    "base_classification_layer to be set. Please provide a layer_search_range "
+                    "or initialize SteeringOptimizer with a base_classification_layer."
+                )
+            min_layer = max(1, self.base_classification_layer - 3)
+            max_layer = self.base_classification_layer + 3
+            layer_search_range = (min_layer, max_layer)
+
         raise NotImplementedError(
             "Steering layer optimization not yet implemented. "
             "This requires implementing steering vector training and "
-            "effectiveness measurement across different layers."
+            "effectiveness measurement across different layers. "
+            f"Would search layers {layer_search_range}."
         )
     
     def optimize_steering_strength(
@@ -419,7 +421,7 @@ class SteeringOptimizer:
     ) -> SteeringOptimizationResult:
         """
         Find optimal steering strength for a specific method, layer, and task.
-        
+
         Args:
             task_name: Task to optimize for
             steering_method: Steering method to use
@@ -427,16 +429,26 @@ class SteeringOptimizer:
             strength_range: (min_strength, max_strength) to search
             strength_steps: Number of strength values to test
             limit: Maximum samples for testing
-            
+
         Returns:
             SteeringOptimizationResult with optimal strength
         """
+        import time
+        start_time = time.time()
+
         if layer is None:
-            layer = self.base_classification_layer or 15  # Default fallback
-        
+            if not self.base_classification_layer:
+                raise ValueError(
+                    "Steering strength optimization requires a layer to be specified. "
+                    "Please provide the 'layer' parameter or initialize SteeringOptimizer "
+                    "with a base_classification_layer."
+                )
+            layer = self.base_classification_layer
+
         if strength_range is None:
-            strength_range = (0.1, 2.0)  # Default strength range
-        
+            # Default strength range is reasonable for most steering methods
+            strength_range = (0.1, 2.0)
+
         logger.info(f"⚡ Optimizing steering strength for {task_name}")
         logger.info(f"   Method: {steering_method.value}, Layer: {layer}")
         logger.info(f"   Strength range: {strength_range}, Steps: {strength_steps}")
@@ -609,7 +621,10 @@ class SteeringOptimizer:
                     'score': 0.0,
                     'error': str(e)
                 })
-        
+
+        # Calculate optimization time
+        optimization_time = time.time() - start_time
+
         return SteeringOptimizationResult(
             task_name=task_name,
             best_steering_layer=layer,
@@ -618,7 +633,7 @@ class SteeringOptimizer:
             optimal_parameters={'strength': best_strength},
             steering_effectiveness_score=best_score,
             classification_accuracy_impact=best_score,  # Using same score for now
-            optimization_time_seconds=0.0,  # TODO: Track actual time
+            optimization_time_seconds=optimization_time,
             total_configurations_tested=len(results),
             error_message=None
         )
@@ -750,10 +765,19 @@ class SteeringOptimizer:
                 task_overrides = self.classification_config.get("task_specific_overrides", {})
                 tasks = list(task_overrides.keys())
                 if not tasks:
-                    logger.warning("No classification-optimized tasks found, using default task set")
-                    tasks = ["truthfulqa_mc1", "gsm8k", "squad2"]  # Default fallback
+                    raise ValueError(
+                        "No classification-optimized tasks found in classification_config. "
+                        "Please either:\n"
+                        "  1. Run classification optimization first to populate task_specific_overrides, or\n"
+                        "  2. Explicitly provide a list of tasks via the 'tasks' parameter"
+                    )
             else:
-                tasks = ["truthfulqa_mc1", "gsm8k", "squad2"]  # Default fallback
+                raise ValueError(
+                    "No tasks provided and no classification_config available. "
+                    "Please either:\n"
+                    "  1. Provide explicit tasks via the 'tasks' parameter, or\n"
+                    "  2. Initialize SteeringOptimizer with a classification_config that contains task_specific_overrides"
+                )
         
         if methods is None:
             methods = [SteeringMethod.CAA, SteeringMethod.HPR]  # Start with simpler methods

wisent/{synthetic → core/synthetic}/cleaners/deduper_cleaner.py

@@ -1,8 +1,8 @@
-from wisent.synthetic.cleaners.core.atoms import CleanStep
-from wisent.synthetic.cleaners.core.atoms import CleanStepStats
+from wisent.core.synthetic.cleaners.core.atoms import CleanStep
+from wisent.core.synthetic.cleaners.core.atoms import CleanStepStats
 
 from wisent.core.contrastive_pairs.core.set import ContrastivePairSet
-from wisent.synthetic.cleaners.methods.core.atoms import Deduper
+from wisent.core.synthetic.cleaners.methods.core.atoms import Deduper
 
 
 __all__ = [

wisent/{synthetic → core/synthetic}/cleaners/methods/base_dedupers.py

@@ -4,7 +4,7 @@ import hashlib
 from collections import Counter, defaultdict
 from typing import Mapping, Sequence, Callable
 
-from wisent.synthetic.cleaners.methods.core.atoms import Deduper
+from wisent.core.synthetic.cleaners.methods.core.atoms import Deduper
 from wisent.core.contrastive_pairs.core.set import ContrastivePairSet
 
 __all__ = [
@@ -279,7 +279,7 @@ class SimHashDeduper(Deduper):
             64-bit integer hash
             
         example:
-            >>> SimHashDeduper()._hash64("wisent_guard")
+            >>> SimHashDeduper()._hash64("wisent")
             TODO: actual value" 
         """
         h = hashlib.blake2b(s.encode("utf-8"), digest_size=8)

wisent/{synthetic → core/synthetic}/cleaners/methods/base_refusalers.py

@@ -1,4 +1,4 @@
-from wisent.synthetic.cleaners.methods.core.atoms import Refusaler
+from wisent.core.synthetic.cleaners.methods.core.atoms import Refusaler
 from wisent.core.models.wisent_model import WisentModel 
 
 import re, unicodedata

wisent/{synthetic → core/synthetic}/cleaners/pairs_cleaner.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from typing import Iterable, TYPE_CHECKING
 
-from wisent.synthetic.cleaners.core.atoms import CleanStep, Cleaner
-from wisent.synthetic.cleaners.core.atoms import CleanerStats
+from wisent.core.synthetic.cleaners.core.atoms import CleanStep, Cleaner
+from wisent.core.synthetic.cleaners.core.atoms import CleanerStats
 from wisent.core.contrastive_pairs.core.set import ContrastivePairSet
 
 __all__ = [
@@ -39,9 +39,9 @@ class PairsCleaner(Cleaner):
             >>> from wisent.core.contrastive_pairs.core.set import ContrastivePairSet
             >>> from wisent.core.contrastive_pairs.core.pair import ContrastivePair
             >>> from wisent.core.contrastive_pairs.core.response import PositiveResponse, NegativeResponse
-            >>> from wisent.synthetic.cleaners.methods.base_refusalers import BasesRefusaler
-            >>> from wisent.synthetic.cleaners.methods.base_dedupers import SimHashDeduper
-            >>> from wisent.synthetic.cleaners.cleaners import PairsCleaner
+            >>> from wisent.core.synthetic.cleaners.methods.base_refusalers import BasesRefusaler
+            >>> from wisent.core.synthetic.cleaners.methods.base_dedupers import SimHashDeduper
+            >>> from wisent.core.synthetic.cleaners.cleaners import PairsCleaner
             >>> from wisent.core.models.wisent_model import WisentModel
             >>> refusal = BasesRefusaler()
             >>> deduper = SimHashDeduper()

wisent/{synthetic → core/synthetic}/cleaners/refusaler_cleaner.py

@@ -1,9 +1,9 @@
 
-from wisent.synthetic.cleaners.core.atoms import CleanStep
+from wisent.core.synthetic.cleaners.core.atoms import CleanStep
 from wisent.core.contrastive_pairs.core.pair import ContrastivePair
-from wisent.synthetic.cleaners.core.atoms import CleanStepStats
+from wisent.core.synthetic.cleaners.core.atoms import CleanStepStats
 
-from wisent.synthetic.cleaners.methods.core.atoms import Refusaler
+from wisent.core.synthetic.cleaners.methods.core.atoms import Refusaler
 from wisent.core.models.wisent_model import WisentModel
 from wisent.core.contrastive_pairs.core.set import ContrastivePairSet
 from wisent.core.contrastive_pairs.core.response import PositiveResponse, NegativeResponse
@@ -59,7 +59,7 @@ class RefusalerCleaner(CleanStep):
             >>> from wisent.core.contrastive_pairs.core.set import ContrastivePairSet
             >>> from wisent.core.contrastive_pairs.core.pair import ContrastivePair
             >>> from wisent.core.contrastive_pairs.core.response import PositiveResponse, NegativeResponse
-            >>> from wisent.synthetic.cleaners.methods.base_refusalers import SimpleRefusaler
+            >>> from wisent.core.synthetic.cleaners.methods.base_refusalers import SimpleRefusaler
             >>> from wisent.core.models.wisent_model import WisentModel
             >>> refusal = SimpleRefusaler()
             >>> model = WisentModel(...)

wisent/{synthetic → core/synthetic}/db_instructions/mini_dp.py

@@ -1,5 +1,5 @@
 
-from wisent.synthetic.db_instructions.core.atoms import DB_Instructions
+from wisent.core.synthetic.db_instructions.core.atoms import DB_Instructions
 
 __all__ = ["Default_DB_Instructions"]
 

wisent/{synthetic → core/synthetic}/generators/diversities/methods/fast_diversity.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Iterable
 import re
 import numpy as np
-from wisent.synthetic.generators.diversities.core.core import Diversity, DiversityScores
+from wisent.core.synthetic.generators.diversities.core.core import Diversity, DiversityScores
 
 __all__ = [
     "FastDiversity",

wisent/{synthetic → core/synthetic}/generators/pairs_generator.py

@@ -3,18 +3,18 @@ from __future__ import annotations
 import logging
 
 
-from wisent.core.contrastive_pairs.core.pair import ContrastivePair  
-from wisent.core.contrastive_pairs.core.response import PositiveResponse, NegativeResponse  
-from wisent.core.contrastive_pairs.core.set import ContrastivePairSet 
+from wisent.core.contrastive_pairs.core.pair import ContrastivePair
+from wisent.core.contrastive_pairs.core.response import PositiveResponse, NegativeResponse
+from wisent.core.contrastive_pairs.core.set import ContrastivePairSet
 
 from wisent.core.models.wisent_model import WisentModel
-from wisent.synthetic.db_instructions.core.atoms import DB_Instructions
+from wisent.core.synthetic.db_instructions.core.atoms import DB_Instructions
 
-from wisent.synthetic.generators.core.atoms import GenerationReport
+from wisent.core.synthetic.generators.core.atoms import GenerationReport
 
-from wisent.synthetic.generators.diversities.core.core import Diversity
+from wisent.core.synthetic.generators.diversities.core.core import Diversity
 
-from wisent.synthetic.cleaners.pairs_cleaner import PairsCleaner
+from wisent.core.synthetic.cleaners.pairs_cleaner import PairsCleaner
 
 __all__ = [
     "SyntheticContrastivePairsGenerator",
@@ -80,7 +80,8 @@ class SyntheticContrastivePairsGenerator:
         # 3) clean
         cleaned, stats = self.cleaner.clean(parsed)
 
-        retries = stats.step_stats.get("refusaler_cleaner").modified_items 
+        refusaler_stats = stats.step_stats.get("refusaler_cleaner")
+        retries = refusaler_stats.modified_items if refusaler_stats else 0 
 
         # 4) build domain objects
         cps = ContrastivePairSet(name=self.contrastive_set_name, task_type=self.trait_label)
@@ -123,25 +124,47 @@ class SyntheticContrastivePairsGenerator:
             name=self.contrastive_set_name,
             task_type=self.trait_label,
         )
-        for r in raw:
+
+        logger.info(f"[PARSE DEBUG] Received {len(raw)} raw outputs to parse")
+
+        for idx, r in enumerate(raw):
+            logger.info(f"[PARSE DEBUG] Raw output {idx}:\n{r[:500]}")  # First 500 chars
+
+            original_r = r
             #TODO: this is very ugly, need to improve robustness
             # r can have instruction, and i want extacrt everything between ```json and ``` (after - You must return answer in valid JSON format only. Don't include any explanations or additional text.assistant)
             # also try to recover like Expecting ',' delimiter
             if "```json" in r:
                 r = r.split("```json")[-1]
+                logger.info(f"[PARSE DEBUG] After json block extraction: {r[:200]}")
             if "```" in r:
                 r = r.split("```")[0]
+                logger.info(f"[PARSE DEBUG] After backtick removal: {r[:200]}")
             r = r.strip()
+
+            logger.info(f"[PARSE DEBUG] Final cleaned string to parse:\n{r}")
+
             try:
                 data = json.loads(r)
-            except json.JSONDecodeError:
+                logger.info(f"[PARSE DEBUG] Successfully parsed JSON: {data}")
+            except json.JSONDecodeError as e:
+                logger.warning(f"[PARSE DEBUG] JSON decode failed: {e}")
                 # try to recover from common errors
                 r = r.replace("'", '"').replace("```", '')
+                logger.info(f"[PARSE DEBUG] Attempting recovery with quote replacement: {r[:200]}")
                 try:
                     data = json.loads(r)
-                except json.JSONDecodeError:
+                    logger.info(f"[PARSE DEBUG] Recovery successful: {data}")
+                except json.JSONDecodeError as e2:
+                    logger.error(f"[PARSE DEBUG] Recovery failed: {e2}. Skipping this output.")
+                    logger.error(f"[PARSE DEBUG] Original raw output was:\n{original_r}")
                     continue
-            for item in data.get("pairs", []):
+
+            pairs_list = data.get("pairs", [])
+            logger.info(f"[PARSE DEBUG] Found {len(pairs_list)} pairs in data")
+
+            for item_idx, item in enumerate(pairs_list):
+                logger.info(f"[PARSE DEBUG] Processing pair {item_idx}: {item}")
                 cp = ContrastivePair(
                     prompt=item["prompt"],
                     positive_response=PositiveResponse(model_response=item["positive"]),
@@ -150,6 +173,9 @@ class SyntheticContrastivePairsGenerator:
                     trait_description=item.get("trait_description", self.trait_description),
                 )
                 out.add(cp)
+                logger.info(f"[PARSE DEBUG] Successfully added pair {item_idx}")
+
+        logger.info(f"[PARSE DEBUG] Finished parsing. Total pairs collected: {len(out)}")
         return out
 
     @staticmethod

wisent/core/tasks/livecodebench_task.py

@@ -52,97 +52,11 @@ class LiveCodeBenchTask(TaskInterface):
 
     def load_data(self, limit: Optional[int] = None) -> List[Dict[str, Any]]:
         """Load LiveCodeBench data for the specified release version."""
-        try:
-            # Load real LiveCodeBench data
-            problems = self._data_loader.load_problems(release_version=self._release_version, limit=limit)
-
-            # Convert to dictionary format
-            return [problem.to_dict() for problem in problems]
-
-        except Exception as e:
-            # Fallback to sample data if loading fails
-            import logging
+        # Load real LiveCodeBench data - no fallbacks
+        problems = self._data_loader.load_problems(release_version=self._release_version, limit=limit)
 
-            logging.warning(f"Failed to load real LiveCodeBench data: {e}. Using sample data.")
-            return self._generate_sample_data_fallback(limit)
-
-    def _generate_sample_data_fallback(self, limit: Optional[int] = None) -> List[Dict[str, Any]]:
-        """Generate sample data for the specified number of problems."""
-        base_problems = [
-            {
-                "task_id": "lcb_001",
-                "question_title": "Two Sum",
-                "question_content": "Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.",
-                "starter_code": "def two_sum(nums, target):\n    # Your code here\n    pass",
-                "difficulty": "EASY",
-                "platform": "LEETCODE",
-                "public_test_cases": [{"input": "[2,7,11,15], 9", "output": "[0,1]", "testtype": "FUNCTIONAL"}],
-                "contest_date": "2023-05-15",
-                "metadata": {"tags": ["array", "hash-table"], "constraints": "2 <= nums.length <= 10^4"},
-            },
-            {
-                "task_id": "lcb_002",
-                "question_title": "Valid Parentheses",
-                "question_content": "Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.",
-                "starter_code": "def is_valid(s):\n    # Your code here\n    pass",
-                "difficulty": "EASY",
-                "platform": "LEETCODE",
-                "public_test_cases": [{"input": '"()"', "output": "true", "testtype": "FUNCTIONAL"}],
-                "contest_date": "2023-06-01",
-                "metadata": {"tags": ["string", "stack"], "constraints": "1 <= s.length <= 10^4"},
-            },
-            {
-                "task_id": "lcb_003",
-                "question_title": "Longest Increasing Subsequence",
-                "question_content": "Given an integer array nums, return the length of the longest strictly increasing subsequence.",
-                "starter_code": "def length_of_lis(nums):\n    # Your code here\n    pass",
-                "difficulty": "MEDIUM",
-                "platform": "LEETCODE",
-                "public_test_cases": [{"input": "[10,9,2,5,3,7,101,18]", "output": "4", "testtype": "FUNCTIONAL"}],
-                "contest_date": "2023-07-10",
-                "metadata": {
-                    "tags": ["array", "binary-search", "dynamic-programming"],
-                    "constraints": "1 <= nums.length <= 2500",
-                },
-            },
-            {
-                "task_id": "lcb_004",
-                "question_title": "Merge Two Sorted Lists",
-                "question_content": "You are given the heads of two sorted linked lists list1 and list2. Merge the two lists into one sorted list.",
-                "starter_code": "def merge_two_lists(list1, list2):\n    # Your code here\n    pass",
-                "difficulty": "EASY",
-                "platform": "LEETCODE",
-                "public_test_cases": [
-                    {"input": "[1,2,4], [1,3,4]", "output": "[1,1,2,3,4,4]", "testtype": "FUNCTIONAL"}
-                ],
-                "contest_date": "2023-08-01",
-                "metadata": {
-                    "tags": ["linked-list", "recursion"],
-                    "constraints": "0 <= list1.length, list2.length <= 50",
-                },
-            },
-            {
-                "task_id": "lcb_005",
-                "question_title": "Best Time to Buy and Sell Stock",
-                "question_content": "You are given an array prices where prices[i] is the price of a given stock on the ith day. Find the maximum profit.",
-                "starter_code": "def max_profit(prices):\n    # Your code here\n    pass",
-                "difficulty": "EASY",
-                "platform": "LEETCODE",
-                "public_test_cases": [{"input": "[7,1,5,3,6,4]", "output": "5", "testtype": "FUNCTIONAL"}],
-                "contest_date": "2023-09-15",
-                "metadata": {"tags": ["array", "dynamic-programming"], "constraints": "1 <= prices.length <= 10^5"},
-            },
-        ]
-
-        # Generate limited sample data for fallback
-        if limit:
-            base_problems = base_problems[:limit]
-
-        # Add version-specific metadata
-        for problem in base_problems:
-            problem["release_version"] = self._release_version
-
-        return base_problems
+        # Convert to dictionary format
+        return [problem.to_dict() for problem in problems]
 
     def get_extractor(self):
         """Get the LiveCodeBench extractor."""
@@ -186,16 +100,3 @@ class LiveCodeBenchTask(TaskInterface):
         question = doc.get("question_content", "")
         starter = doc.get("starter_code", "")
         return f"{question}\n\n{starter}"
-
-
-# TODO: In a real implementation, this would integrate with the actual LiveCodeBench library
-# Example integration:
-# from livecodebench import LiveCodeBench
-#
-# class LiveCodeBenchTask(TaskInterface):
-#     def __init__(self):
-#         self._lcb = LiveCodeBench()
-#         # self._extractor = LiveCodeBenchExtractor()  # Not needed with model outputs approach
-#
-#     def load_data(self, limit: Optional[int] = None) -> List[Dict[str, Any]]:
-#         return self._lcb.load_problems(limit=limit)