synkro 0.4.36__py3-none-any.whl

synkro/interactive/rich_ui.py

@@ -0,0 +1,459 @@
+"""Rich UI components for Human-in-the-Loop interaction."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from synkro.types.logic_map import LogicMap, GoldenScenario
+    from synkro.types.core import Plan
+
+
+class LogicMapDisplay:
+    """Rich-based display for Logic Maps."""
+
+    def __init__(self) -> None:
+        from rich.console import Console
+
+        self.console = Console()
+
+    def display_full(self, logic_map: "LogicMap") -> None:
+        """Display the complete Logic Map with all details."""
+        from rich.panel import Panel
+        from rich.tree import Tree
+
+        # Build tree view of rules by category
+        tree = Tree("[bold cyan]Logic Map[/bold cyan]")
+
+        # Group rules by category
+        categories: dict[str, list] = {}
+        for rule in logic_map.rules:
+            cat = rule.category.value if hasattr(rule.category, "value") else str(rule.category)
+            if cat not in categories:
+                categories[cat] = []
+            categories[cat].append(rule)
+
+        # Add each category as a branch
+        for category, rules in sorted(categories.items()):
+            branch = tree.add(f"[bold]{category}[/bold] ({len(rules)} rules)")
+            for rule in rules:
+                rule_text = f"[cyan]{rule.rule_id}[/cyan]: {rule.text[:60]}..."
+                if rule.dependencies:
+                    rule_text += f" [dim]→ {', '.join(rule.dependencies)}[/dim]"
+                branch.add(rule_text)
+
+        # Show root rules
+        root_info = f"[dim]Root rules: {', '.join(logic_map.root_rules)}[/dim]"
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                tree,
+                title=f"[bold]📜 Logic Map ({len(logic_map.rules)} rules)[/bold]",
+                subtitle=root_info,
+                border_style="cyan",
+            )
+        )
+
+    def display_diff(self, before: "LogicMap", after: "LogicMap") -> None:
+        """Display all rules with changes highlighted in different colors."""
+        from rich.panel import Panel
+        from rich.tree import Tree
+
+        before_ids = {r.rule_id for r in before.rules}
+        after_ids = {r.rule_id for r in after.rules}
+
+        added = after_ids - before_ids
+        removed = before_ids - after_ids
+        common = before_ids & after_ids
+
+        # Check for modifications in common rules
+        modified: set[str] = set()
+        before_map = {r.rule_id: r for r in before.rules}
+        after_map = {r.rule_id: r for r in after.rules}
+
+        for rule_id in common:
+            if before_map[rule_id].text != after_map[rule_id].text:
+                modified.add(rule_id)
+            elif before_map[rule_id].dependencies != after_map[rule_id].dependencies:
+                modified.add(rule_id)
+
+        if not added and not removed and not modified:
+            self.console.print("[dim]No changes detected[/dim]")
+            return
+
+        # Build tree view of rules by category (like display_full but with colors)
+        tree = Tree("[bold cyan]Logic Map[/bold cyan]")
+
+        # Group rules by category
+        categories: dict[str, list] = {}
+        for rule in after.rules:
+            cat = rule.category.value if hasattr(rule.category, "value") else str(rule.category)
+            if cat not in categories:
+                categories[cat] = []
+            categories[cat].append(rule)
+
+        # Add each category as a branch
+        for category, rules in sorted(categories.items()):
+            branch = tree.add(f"[bold]{category}[/bold] ({len(rules)} rules)")
+            for rule in rules:
+                # Determine style based on change type
+                if rule.rule_id in added:
+                    prefix = "[green]+ "
+                    style_close = "[/green]"
+                    id_style = "[green]"
+                elif rule.rule_id in modified:
+                    prefix = "[yellow]~ "
+                    style_close = "[/yellow]"
+                    id_style = "[yellow]"
+                else:
+                    prefix = ""
+                    style_close = ""
+                    id_style = "[cyan]"
+
+                rule_text = f"{prefix}{id_style}{rule.rule_id}[/]: {rule.text[:60]}...{style_close}"
+                if rule.dependencies:
+                    rule_text += f" [dim]→ {', '.join(rule.dependencies)}[/dim]"
+                branch.add(rule_text)
+
+        # Add removed rules section at the bottom
+        if removed:
+            removed_branch = tree.add("[red][bold]REMOVED[/bold][/red]")
+            for rule_id in sorted(removed):
+                rule = before_map[rule_id]
+                removed_branch.add(f"[red][strike]- {rule_id}: {rule.text[:60]}...[/strike][/red]")
+
+        # Build legend
+        legend = "[dim]Legend: [green]+ Added[/green] | [yellow]~ Modified[/yellow] | [red][strike]- Removed[/strike][/red][/dim]"
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                tree,
+                title=f"[bold]📜 Logic Map ({len(after.rules)} rules)[/bold]",
+                subtitle=legend,
+                border_style="cyan",
+            )
+        )
+
+    def display_rule(self, rule_id: str, logic_map: "LogicMap") -> None:
+        """Display details of a specific rule."""
+        from rich.panel import Panel
+
+        rule = logic_map.get_rule(rule_id)
+        if not rule:
+            self.console.print(f"[red]Rule {rule_id} not found[/red]")
+            return
+
+        content = f"""[bold]ID:[/bold] {rule.rule_id}
+[bold]Text:[/bold] {rule.text}
+[bold]Category:[/bold] {rule.category}
+[bold]Condition:[/bold] {rule.condition or 'N/A'}
+[bold]Action:[/bold] {rule.action or 'N/A'}
+[bold]Dependencies:[/bold] {', '.join(rule.dependencies) if rule.dependencies else 'None (root rule)'}"""
+
+        self.console.print(Panel(content, title=f"Rule {rule_id}", border_style="cyan"))
+
+    def show_error(self, message: str) -> None:
+        """Display an error message."""
+        self.console.print(f"[red]Error:[/red] {message}")
+
+    def show_success(self, message: str) -> None:
+        """Display a success message."""
+        self.console.print(f"[green]✓[/green] {message}")
+
+    def spinner(self, message: str = "Processing..."):
+        """Context manager that shows a loading spinner.
+
+        Usage:
+            with display.spinner("Applying changes..."):
+                await some_llm_call()
+        """
+        from rich.status import Status
+        self.console.print()  # Add space above spinner
+        return Status(f"[cyan]{message}[/cyan]", spinner="dots", console=self.console)
+
+    def display_session_state(
+        self,
+        plan: "Plan",
+        logic_map: "LogicMap",
+        current_turns: int,
+    ) -> None:
+        """Display both conversation settings and logic map together."""
+        from rich.panel import Panel
+        from rich.table import Table
+
+        # Conversation settings panel
+        turns_table = Table(show_header=False, box=None)
+        turns_table.add_row(
+            "[dim]Complexity:[/dim]",
+            f"[cyan]{plan.complexity_level.title()}[/cyan]",
+        )
+        turns_table.add_row(
+            "[dim]Turns:[/dim]",
+            f"[green]{current_turns}[/green]",
+        )
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                turns_table,
+                title="[cyan]Conversation Settings[/cyan]",
+                border_style="cyan",
+            )
+        )
+
+        # Then display logic map (existing method)
+        self.display_full(logic_map)
+
+    def display_scenarios(
+        self,
+        scenarios: list["GoldenScenario"],
+        distribution: dict[str, int] | None = None,
+    ) -> None:
+        """Display all scenarios with S1, S2... IDs grouped by type."""
+        from rich.panel import Panel
+        from rich.tree import Tree
+
+        # Scenario tree view grouped by type
+        tree = Tree("[bold cyan]Scenarios[/bold cyan]")
+
+        # Group by type
+        by_type: dict[str, list[tuple[int, "GoldenScenario"]]] = {}
+        for i, scenario in enumerate(scenarios, start=1):
+            type_key = scenario.scenario_type.value
+            if type_key not in by_type:
+                by_type[type_key] = []
+            by_type[type_key].append((i, scenario))
+
+        # Add each type as a branch
+        for type_name in ["positive", "negative", "edge_case", "irrelevant"]:
+            if type_name in by_type:
+                type_display = type_name.replace("_", " ").title()
+                branch = tree.add(f"[bold]{type_display}[/bold] ({len(by_type[type_name])})")
+                for idx, scenario in by_type[type_name]:
+                    desc = scenario.description[:50] + "..." if len(scenario.description) > 50 else scenario.description
+                    rules = ", ".join(scenario.target_rule_ids[:3]) if scenario.target_rule_ids else "None"
+                    if len(scenario.target_rule_ids) > 3:
+                        rules += "..."
+                    branch.add(f"[cyan]S{idx}[/cyan]: {desc} [dim]→ {rules}[/dim]")
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                tree,
+                title=f"[bold]📋 Scenarios ({len(scenarios)} total)[/bold]",
+                border_style="green",
+            )
+        )
+
+    def display_scenario(
+        self,
+        scenario_id: str,
+        scenarios: list["GoldenScenario"],
+    ) -> None:
+        """Display details of a specific scenario."""
+        from rich.panel import Panel
+
+        # Parse S1, S2, etc. to index
+        try:
+            idx = int(scenario_id.upper().replace("S", "")) - 1
+            if idx < 0 or idx >= len(scenarios):
+                self.console.print(f"[red]Scenario {scenario_id} not found (valid: S1-S{len(scenarios)})[/red]")
+                return
+        except ValueError:
+            self.console.print(f"[red]Invalid scenario ID: {scenario_id}[/red]")
+            return
+
+        scenario = scenarios[idx]
+        content = f"""[bold]ID:[/bold] S{idx + 1}
+[bold]Type:[/bold] {scenario.scenario_type.value.replace('_', ' ').title()}
+[bold]Description:[/bold] {scenario.description}
+[bold]Context:[/bold] {scenario.context or 'N/A'}
+[bold]Target Rules:[/bold] {', '.join(scenario.target_rule_ids) if scenario.target_rule_ids else 'None'}
+[bold]Expected Outcome:[/bold] {scenario.expected_outcome}"""
+
+        self.console.print(Panel(content, title=f"Scenario S{idx + 1}", border_style="green"))
+
+    def display_scenario_diff(
+        self,
+        before: list["GoldenScenario"],
+        after: list["GoldenScenario"],
+    ) -> None:
+        """Display all scenarios with changes highlighted in different colors."""
+        from rich.panel import Panel
+        from rich.tree import Tree
+
+        # Create simple ID comparison
+        before_descs = {s.description for s in before}
+        after_descs = {s.description for s in after}
+
+        added_descs = after_descs - before_descs
+        removed_descs = before_descs - after_descs
+
+        if not added_descs and not removed_descs:
+            self.console.print("[dim]No changes detected[/dim]")
+            return
+
+        # Build tree view grouped by type
+        tree = Tree("[bold cyan]Scenarios[/bold cyan]")
+
+        # Group by type
+        by_type: dict[str, list[tuple[int, "GoldenScenario", bool]]] = {}
+        for i, scenario in enumerate(after, start=1):
+            type_key = scenario.scenario_type.value
+            if type_key not in by_type:
+                by_type[type_key] = []
+            is_added = scenario.description in added_descs
+            by_type[type_key].append((i, scenario, is_added))
+
+        # Add each type as a branch
+        for type_name in ["positive", "negative", "edge_case", "irrelevant"]:
+            if type_name in by_type:
+                type_display = type_name.replace("_", " ").title()
+                branch = tree.add(f"[bold]{type_display}[/bold] ({len(by_type[type_name])})")
+                for idx, scenario, is_added in by_type[type_name]:
+                    desc = scenario.description[:50] + "..." if len(scenario.description) > 50 else scenario.description
+
+                    if is_added:
+                        prefix = "[green]+ "
+                        style_close = "[/green]"
+                        id_style = "[green]"
+                    else:
+                        prefix = ""
+                        style_close = ""
+                        id_style = "[cyan]"
+
+                    rules = ", ".join(scenario.target_rule_ids[:3]) if scenario.target_rule_ids else "None"
+                    branch.add(f"{prefix}{id_style}S{idx}[/]: {desc}{style_close} [dim]→ {rules}[/dim]")
+
+        # Add removed scenarios at bottom
+        if removed_descs:
+            removed_branch = tree.add("[red][bold]REMOVED[/bold][/red]")
+            for scenario in before:
+                if scenario.description in removed_descs:
+                    desc = scenario.description[:50] + "..." if len(scenario.description) > 50 else scenario.description
+                    removed_branch.add(f"[red][strike]- {desc}[/strike][/red]")
+
+        # Build legend
+        legend = "[dim]Legend: [green]+ Added[/green] | [red][strike]- Removed[/strike][/red][/dim]"
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                tree,
+                title=f"[bold]📋 Scenarios ({len(after)} total)[/bold]",
+                subtitle=legend,
+                border_style="green",
+            )
+        )
+
+    def display_full_session_state(
+        self,
+        plan: "Plan",
+        logic_map: "LogicMap",
+        current_turns: int,
+        scenarios: list["GoldenScenario"] | None,
+        distribution: dict[str, int] | None,
+    ) -> None:
+        """Display logic map, scenarios, and session details (at bottom)."""
+        from rich.panel import Panel
+
+        # Display logic map first
+        self.display_full(logic_map)
+
+        # Display scenarios if available
+        if scenarios:
+            self.display_scenarios(scenarios)
+
+        # Session Details panel at bottom (instructions + settings)
+        session_details = f"""[bold]Commands:[/bold] [cyan]done[/cyan] | [cyan]undo[/cyan] | [cyan]reset[/cyan] | [cyan]show R001[/cyan] | [cyan]show S3[/cyan] | [cyan]help[/cyan]
+
+[bold]Feedback:[/bold] [yellow]"shorter"[/yellow] [yellow]"5 turns"[/yellow] [yellow]"remove R005"[/yellow] [yellow]"add scenario for..."[/yellow] [yellow]"delete S3"[/yellow]
+
+[dim]Complexity:[/dim] [cyan]{plan.complexity_level.title()}[/cyan]    [dim]Turns:[/dim] [green]{current_turns}[/green]"""
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                session_details,
+                title="[bold cyan]Session Details[/bold cyan]",
+                border_style="cyan",
+            )
+        )
+
+
+class InteractivePrompt:
+    """Handles user input for HITL sessions."""
+
+    def __init__(self) -> None:
+        from rich.console import Console
+
+        self.console = Console()
+
+    def show_instructions(self) -> None:
+        """Display instructions for the HITL session."""
+        from rich.panel import Panel
+
+        instructions = """[bold]Commands:[/bold]
+  • Type feedback to modify the Logic Map (e.g., "add a rule for...", "remove R005")
+  • [cyan]done[/cyan] - Continue with current Logic Map
+  • [cyan]undo[/cyan] - Revert last change
+  • [cyan]reset[/cyan] - Restore original Logic Map
+  • [cyan]show R001[/cyan] - Show details of a specific rule
+  • [cyan]help[/cyan] - Show this message"""
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                instructions,
+                title="[bold cyan]Interactive Logic Map Editor[/bold cyan]",
+                border_style="cyan",
+            )
+        )
+
+    def show_unified_instructions(self) -> None:
+        """Display instructions for the unified HITL session (turns + rules + scenarios)."""
+        from rich.panel import Panel
+
+        instructions = """[bold]Commands:[/bold]
+  • [cyan]done[/cyan] - Continue with current settings
+  • [cyan]undo[/cyan] - Revert last change
+  • [cyan]reset[/cyan] - Restore original state
+  • [cyan]show R001[/cyan] - Show details of a specific rule
+  • [cyan]show S3[/cyan] - Show details of a specific scenario
+  • [cyan]help[/cyan] - Show this message
+
+[bold]Feedback examples:[/bold]
+  [dim]Turns:[/dim]
+  • [yellow]"shorter conversations"[/yellow] - Adjust conversation turns
+  • [yellow]"I want 5 turns"[/yellow] - Set specific turn count
+  [dim]Rules:[/dim]
+  • [yellow]"remove R005"[/yellow] - Delete a rule
+  • [yellow]"add rule for late submissions"[/yellow] - Add a new rule
+  [dim]Scenarios:[/dim]
+  • [yellow]"add scenario for expenses at $50 limit"[/yellow] - Add edge case
+  • [yellow]"delete S3"[/yellow] - Remove a scenario
+  • [yellow]"more negative scenarios"[/yellow] - Adjust distribution"""
+
+        self.console.print()
+        self.console.print(
+            Panel(
+                instructions,
+                title="[bold cyan]Interactive Session[/bold cyan]",
+                border_style="cyan",
+            )
+        )
+
+    def get_feedback(self) -> str:
+        """Prompt user for feedback on the Logic Map."""
+        from rich.prompt import Prompt
+
+        self.console.print()
+        return Prompt.ask("[cyan]Enter feedback[/cyan]")
+
+    def confirm_continue(self) -> bool:
+        """Ask user if they want to continue with current Logic Map."""
+        from rich.prompt import Confirm
+
+        return Confirm.ask("Continue with this Logic Map?", default=True)

synkro/interactive/scenario_editor.py

@@ -0,0 +1,198 @@
+"""Scenario Editor - LLM-powered interactive refinement of golden scenarios."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from synkro.llm.client import LLM
+from synkro.models import Model, OpenAI
+from synkro.schemas import RefinedScenariosOutput
+from synkro.types.logic_map import LogicMap, GoldenScenario, ScenarioType
+from synkro.prompts.interactive_templates import SCENARIO_REFINEMENT_PROMPT
+
+if TYPE_CHECKING:
+    pass
+
+
+class ScenarioEditor:
+    """
+    LLM-powered scenario editor that interprets natural language feedback.
+
+    The editor takes user feedback in natural language (e.g., "add a scenario for...",
+    "delete S3", "more edge cases") and uses an LLM to interpret and apply
+    the changes to the scenario list.
+
+    Examples:
+        >>> editor = ScenarioEditor(llm=LLM(model=OpenAI.GPT_4O))
+        >>> new_scenarios, distribution, summary = await editor.refine(
+        ...     scenarios=current_scenarios,
+        ...     distribution=current_distribution,
+        ...     user_feedback="Add a scenario for expenses at exactly $50",
+        ...     policy_text=policy.text,
+        ...     logic_map=logic_map,
+        ... )
+    """
+
+    def __init__(
+        self,
+        llm: LLM | None = None,
+        model: Model = OpenAI.GPT_4O,
+    ):
+        """
+        Initialize the Scenario Editor.
+
+        Args:
+            llm: LLM client to use (creates one if not provided)
+            model: Model to use if creating LLM (default: GPT-4O for accuracy)
+        """
+        self.llm = llm or LLM(model=model, temperature=0.3)
+
+    async def refine(
+        self,
+        scenarios: list[GoldenScenario],
+        distribution: dict[str, int],
+        user_feedback: str,
+        policy_text: str,
+        logic_map: LogicMap,
+        conversation_history: str = "No previous feedback in this session.",
+    ) -> tuple[list[GoldenScenario], dict[str, int], str]:
+        """
+        Refine scenarios based on natural language feedback.
+
+        Args:
+            scenarios: Current list of golden scenarios
+            distribution: Current type distribution (e.g., {"positive": 5, "negative": 3})
+            user_feedback: Natural language instruction from user
+            policy_text: Original policy text for context
+            logic_map: Logic Map for rule references
+            conversation_history: Formatted history of previous feedback in this session
+
+        Returns:
+            Tuple of (refined scenarios, updated distribution, changes summary)
+        """
+        # Format current scenarios for prompt
+        scenarios_str = self._format_scenarios_for_prompt(scenarios)
+        distribution_str = self._format_distribution(distribution)
+        logic_map_str = self._format_logic_map_for_prompt(logic_map)
+
+        # Format the prompt
+        prompt = SCENARIO_REFINEMENT_PROMPT.format(
+            logic_map=logic_map_str,
+            scenarios_formatted=scenarios_str,
+            distribution=distribution_str,
+            policy_text=policy_text,
+            user_feedback=user_feedback,
+            conversation_history=conversation_history,
+        )
+
+        # Generate structured output
+        result = await self.llm.generate_structured(prompt, RefinedScenariosOutput)
+
+        # Convert to domain model
+        refined_scenarios = self._convert_to_scenarios(result.scenarios)
+
+        # Calculate new distribution
+        new_distribution = self._calculate_distribution(refined_scenarios)
+
+        return refined_scenarios, new_distribution, result.changes_summary
+
+    def _format_scenarios_for_prompt(self, scenarios: list[GoldenScenario]) -> str:
+        """Format scenarios with S1, S2... IDs for the LLM prompt."""
+        lines = []
+        for i, scenario in enumerate(scenarios, start=1):
+            lines.append(f"S{i}:")
+            lines.append(f"  Description: {scenario.description}")
+            lines.append(f"  Type: {scenario.scenario_type.value}")
+            lines.append(f"  Target Rules: {', '.join(scenario.target_rule_ids) or 'None'}")
+            lines.append(f"  Expected Outcome: {scenario.expected_outcome}")
+            if scenario.context:
+                lines.append(f"  Context: {scenario.context}")
+            lines.append("")
+        return "\n".join(lines)
+
+    def _format_distribution(self, distribution: dict[str, int]) -> str:
+        """Format distribution as a string."""
+        lines = []
+        for type_name, count in sorted(distribution.items()):
+            lines.append(f"  {type_name}: {count}")
+        return "\n".join(lines)
+
+    def _format_logic_map_for_prompt(self, logic_map: LogicMap) -> str:
+        """Format Logic Map rules for context."""
+        lines = []
+        lines.append(f"Total Rules: {len(logic_map.rules)}")
+        lines.append("Rules:")
+        for rule in logic_map.rules:
+            lines.append(f"  {rule.rule_id}: {rule.text}")
+        return "\n".join(lines)
+
+    def _convert_to_scenarios(self, schema_scenarios: list) -> list[GoldenScenario]:
+        """Convert schema output to domain model."""
+        scenarios = []
+        for s in schema_scenarios:
+            # Handle scenario_type as string or enum
+            if isinstance(s.scenario_type, str):
+                scenario_type = ScenarioType(s.scenario_type)
+            else:
+                scenario_type = s.scenario_type
+
+            scenario = GoldenScenario(
+                description=s.description,
+                context=getattr(s, 'context', ''),
+                category=getattr(s, 'category', ''),
+                scenario_type=scenario_type,
+                target_rule_ids=s.target_rule_ids,
+                expected_outcome=s.expected_outcome,
+            )
+            scenarios.append(scenario)
+        return scenarios
+
+    def _calculate_distribution(self, scenarios: list[GoldenScenario]) -> dict[str, int]:
+        """Calculate type distribution from scenarios."""
+        distribution: dict[str, int] = {
+            "positive": 0,
+            "negative": 0,
+            "edge_case": 0,
+            "irrelevant": 0,
+        }
+        for scenario in scenarios:
+            type_key = scenario.scenario_type.value
+            distribution[type_key] = distribution.get(type_key, 0) + 1
+        return distribution
+
+    def validate_scenarios(
+        self,
+        scenarios: list[GoldenScenario],
+        logic_map: LogicMap,
+    ) -> tuple[bool, list[str]]:
+        """
+        Validate scenarios against the Logic Map.
+
+        Args:
+            scenarios: List of scenarios to validate
+            logic_map: Logic Map for rule reference validation
+
+        Returns:
+            Tuple of (is_valid, list of issue descriptions)
+        """
+        issues = []
+        rule_ids = {r.rule_id for r in logic_map.rules}
+
+        for i, scenario in enumerate(scenarios, start=1):
+            # Check target_rule_ids reference existing rules
+            for rule_id in scenario.target_rule_ids:
+                if rule_id not in rule_ids:
+                    issues.append(f"S{i} references non-existent rule {rule_id}")
+
+            # Check scenario_type is valid
+            if scenario.scenario_type.value not in ["positive", "negative", "edge_case", "irrelevant"]:
+                issues.append(f"S{i} has invalid scenario_type: {scenario.scenario_type}")
+
+            # Check expected_outcome is not empty
+            if not scenario.expected_outcome.strip():
+                issues.append(f"S{i} has empty expected_outcome")
+
+        return len(issues) == 0, issues
+
+
+__all__ = ["ScenarioEditor"]

synkro/llm/__init__.py

@@ -0,0 +1,7 @@
+"""LLM client wrapper for multiple providers via LiteLLM."""
+
+from synkro.llm.client import LLM
+from synkro.llm.rate_limits import auto_workers, get_provider
+
+__all__ = ["LLM", "auto_workers", "get_provider"]
+