synkro 0.4.36__py3-none-any.whl

synkro/generation/tool_simulator.py

@@ -0,0 +1,114 @@
+"""Tool response simulator for training data generation."""
+
+import json
+import uuid
+from typing import TYPE_CHECKING
+
+from synkro.prompts.tool_templates import TOOL_SIMULATION_PROMPT
+
+if TYPE_CHECKING:
+    from synkro.llm.client import LLM
+    from synkro.types.tool import ToolDefinition, ToolCall
+
+
+class ToolSimulator:
+    """
+    Simulates tool responses for training data generation.
+    
+    Uses an LLM to generate realistic, contextual tool responses
+    based on tool definitions and call arguments.
+    
+    Example:
+        >>> from synkro.types.tool import ToolDefinition, ToolCall, ToolFunction
+        >>> simulator = ToolSimulator(tools=[web_search_tool], llm=llm)
+        >>> call = ToolCall(
+        ...     id="call_1",
+        ...     function=ToolFunction(name="web_search", arguments='{"query": "weather NYC"}')
+        ... )
+        >>> response = await simulator.simulate(call)
+        >>> print(response)
+        "NYC: 72°F, sunny with a high of 75°F expected"
+    """
+    
+    def __init__(self, tools: list["ToolDefinition"], llm: "LLM"):
+        """
+        Initialize the simulator.
+        
+        Args:
+            tools: List of available tool definitions
+            llm: LLM client for generating responses
+        """
+        self.tools = {t.name: t for t in tools}
+        self.llm = llm
+    
+    async def simulate(self, tool_call: "ToolCall") -> str:
+        """
+        Simulate a tool response for the given call.
+        
+        Args:
+            tool_call: The tool call to simulate
+            
+        Returns:
+            Simulated tool response content
+        """
+        tool_name = tool_call.function.name
+        
+        if tool_name not in self.tools:
+            return json.dumps({"error": f"Unknown tool: {tool_name}"})
+        
+        tool = self.tools[tool_name]
+        
+        # Format mock responses for the prompt
+        mock_responses = "\n".join(
+            f"- {r}" for r in tool.mock_responses
+        ) if tool.mock_responses else "No example responses provided"
+        
+        prompt = TOOL_SIMULATION_PROMPT.format(
+            TOOL_NAME=tool.name,
+            TOOL_DESCRIPTION=tool.description,
+            TOOL_PARAMETERS=json.dumps(tool.parameters, indent=2),
+            ARGUMENTS=tool_call.function.arguments,
+            MOCK_RESPONSES=mock_responses,
+        )
+        
+        response = await self.llm.generate(prompt)
+        return response.strip()
+    
+    async def simulate_batch(self, tool_calls: list["ToolCall"]) -> list[str]:
+        """
+        Simulate responses for multiple tool calls.
+        
+        Args:
+            tool_calls: List of tool calls to simulate
+            
+        Returns:
+            List of simulated responses in order
+        """
+        import asyncio
+        return await asyncio.gather(*[self.simulate(tc) for tc in tool_calls])
+    
+    def generate_call_id(self) -> str:
+        """Generate a unique tool call ID."""
+        return f"call_{uuid.uuid4().hex[:12]}"
+    
+    def get_tools_description(self) -> str:
+        """
+        Get a formatted description of all available tools.
+        
+        Returns:
+            Formatted string describing all tools
+        """
+        descriptions = []
+        for tool in self.tools.values():
+            descriptions.append(tool.to_system_prompt())
+        return "\n\n".join(descriptions)
+    
+    def get_tools_json(self) -> list[dict]:
+        """
+        Get tools in OpenAI function format.
+        
+        Returns:
+            List of tool definitions in OpenAI format
+        """
+        return [tool.to_openai_format() for tool in self.tools.values()]
+

synkro/interactive/__init__.py

@@ -0,0 +1,16 @@
+"""Interactive Human-in-the-Loop components for Logic Map and Scenario editing."""
+
+from synkro.interactive.logic_map_editor import LogicMapEditor
+from synkro.interactive.scenario_editor import ScenarioEditor
+from synkro.interactive.hitl_session import HITLSession
+from synkro.interactive.rich_ui import LogicMapDisplay, InteractivePrompt
+from synkro.interactive.intent_classifier import HITLIntentClassifier
+
+__all__ = [
+    "LogicMapEditor",
+    "ScenarioEditor",
+    "HITLSession",
+    "LogicMapDisplay",
+    "InteractivePrompt",
+    "HITLIntentClassifier",
+]

synkro/interactive/hitl_session.py

@@ -0,0 +1,205 @@
+"""Human-in-the-Loop session state management."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from synkro.types.logic_map import LogicMap, GoldenScenario
+
+
+@dataclass
+class FeedbackEntry:
+    """Single feedback entry in conversation history."""
+
+    user_feedback: str
+    intent_type: str  # "turns", "rules", "scenarios"
+    action_summary: str  # "Added R015: No smoking policy"
+
+
+@dataclass
+class HITLSession:
+    """
+    Tracks state of an interactive Logic Map and Scenario editing session.
+
+    Supports undo/reset operations and maintains edit history for both
+    Logic Map changes and scenario changes.
+
+    Example:
+        >>> session = HITLSession(original_logic_map=logic_map)
+        >>> session.apply_change("Added rule R009", new_logic_map)
+        >>> session.set_scenarios(scenarios, distribution)
+        >>> session.apply_scenario_change("Added S21", new_scenarios, new_distribution)
+        >>> session.undo()  # Reverts last change (rule or scenario)
+        >>> session.reset()  # Reverts to original
+    """
+
+    original_logic_map: "LogicMap"
+    current_logic_map: "LogicMap" = field(init=False)
+    history: list[tuple[str, "LogicMap"]] = field(default_factory=list)
+
+    # Scenario tracking
+    original_scenarios: list["GoldenScenario"] | None = field(default=None)
+    current_scenarios: list["GoldenScenario"] | None = field(default=None)
+    original_distribution: dict[str, int] | None = field(default=None)
+    current_distribution: dict[str, int] | None = field(default=None)
+    scenario_history: list[tuple[str, list["GoldenScenario"], dict[str, int]]] = field(
+        default_factory=list
+    )
+
+    # Conversation history for context-aware feedback
+    conversation_history: list[FeedbackEntry] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        """Initialize current_logic_map from original."""
+        self.current_logic_map = self.original_logic_map
+
+    def set_scenarios(
+        self,
+        scenarios: list["GoldenScenario"],
+        distribution: dict[str, int],
+    ) -> None:
+        """
+        Initialize scenarios after they're generated.
+
+        Args:
+            scenarios: List of generated golden scenarios
+            distribution: Type distribution dict
+        """
+        self.original_scenarios = scenarios
+        self.current_scenarios = scenarios
+        self.original_distribution = distribution
+        self.current_distribution = distribution
+
+    def apply_change(self, feedback: str, new_map: "LogicMap") -> None:
+        """
+        Record a Logic Map change in history and update current state.
+
+        Args:
+            feedback: The user feedback that triggered this change
+            new_map: The new Logic Map after applying the change
+        """
+        self.history.append((feedback, self.current_logic_map))
+        self.current_logic_map = new_map
+
+    def apply_scenario_change(
+        self,
+        feedback: str,
+        new_scenarios: list["GoldenScenario"],
+        new_distribution: dict[str, int],
+    ) -> None:
+        """
+        Record a scenario change in history and update current state.
+
+        Args:
+            feedback: The user feedback that triggered this change
+            new_scenarios: The updated scenario list
+            new_distribution: The updated distribution dict
+        """
+        if self.current_scenarios is not None and self.current_distribution is not None:
+            self.scenario_history.append(
+                (feedback, self.current_scenarios, self.current_distribution)
+            )
+        self.current_scenarios = new_scenarios
+        self.current_distribution = new_distribution
+
+    def undo(self) -> tuple["LogicMap | None", list["GoldenScenario"] | None, dict[str, int] | None]:
+        """
+        Undo the last change (either rule or scenario).
+
+        Returns:
+            Tuple of (logic_map or None, scenarios or None, distribution or None)
+            indicating which was restored
+        """
+        # Check which has the most recent change
+        rule_has_history = len(self.history) > 0
+        scenario_has_history = len(self.scenario_history) > 0
+
+        if not rule_has_history and not scenario_has_history:
+            return None, None, None
+
+        # For simplicity, undo the most recent change of either type
+        # In practice, we could track a unified history with timestamps
+        if scenario_has_history:
+            _, prev_scenarios, prev_distribution = self.scenario_history.pop()
+            self.current_scenarios = prev_scenarios
+            self.current_distribution = prev_distribution
+            return None, prev_scenarios, prev_distribution
+
+        if rule_has_history:
+            _, previous_map = self.history.pop()
+            self.current_logic_map = previous_map
+            return previous_map, None, None
+
+        return None, None, None
+
+    def reset(self) -> tuple["LogicMap", list["GoldenScenario"] | None, dict[str, int] | None]:
+        """
+        Reset to the original state, clearing all history.
+
+        Returns:
+            Tuple of (original LogicMap, original scenarios, original distribution)
+        """
+        self.history.clear()
+        self.scenario_history.clear()
+        self.conversation_history.clear()
+        self.current_logic_map = self.original_logic_map
+        self.current_scenarios = self.original_scenarios
+        self.current_distribution = self.original_distribution
+        return self.original_logic_map, self.original_scenarios, self.original_distribution
+
+    @property
+    def can_undo(self) -> bool:
+        """Check if undo is available."""
+        return len(self.history) > 0 or len(self.scenario_history) > 0
+
+    @property
+    def change_count(self) -> int:
+        """Number of changes made in this session (rules + scenarios)."""
+        return len(self.history) + len(self.scenario_history)
+
+    @property
+    def rule_change_count(self) -> int:
+        """Number of rule changes made in this session."""
+        return len(self.history)
+
+    @property
+    def scenario_change_count(self) -> int:
+        """Number of scenario changes made in this session."""
+        return len(self.scenario_history)
+
+    @property
+    def has_scenarios(self) -> bool:
+        """Check if scenarios have been initialized."""
+        return self.current_scenarios is not None
+
+    def record_feedback(self, feedback: str, intent_type: str, summary: str) -> None:
+        """
+        Record feedback for conversation context.
+
+        Args:
+            feedback: The user's original feedback text
+            intent_type: Type of intent ("turns", "rules", "scenarios")
+            summary: Summary of what action was taken
+        """
+        self.conversation_history.append(FeedbackEntry(feedback, intent_type, summary))
+
+    def get_history_for_prompt(self, max_entries: int = 5) -> str:
+        """
+        Format recent history for LLM prompts.
+
+        Args:
+            max_entries: Maximum number of entries to include
+
+        Returns:
+            Formatted string of recent feedback history
+        """
+        if not self.conversation_history:
+            return "No previous feedback in this session."
+
+        lines = []
+        for i, entry in enumerate(self.conversation_history[-max_entries:], 1):
+            lines.append(f"{i}. User: \"{entry.user_feedback}\"")
+            lines.append(f"   Result: {entry.action_summary}")
+        return "\n".join(lines)

synkro/interactive/intent_classifier.py

@@ -0,0 +1,94 @@
+"""HITL Intent Classifier - LLM-powered classification of user feedback."""
+
+from __future__ import annotations
+
+from synkro.llm.client import LLM
+from synkro.models import Model, OpenAI
+from synkro.schemas import HITLIntent
+from synkro.prompts.interactive_templates import HITL_INTENT_CLASSIFIER_PROMPT
+
+
+class HITLIntentClassifier:
+    """
+    LLM-powered classifier for user feedback in unified HITL sessions.
+
+    Classifies user input into one of five intent types:
+    - "turns": User wants to adjust conversation turns
+    - "rules": User wants to modify the Logic Map
+    - "scenarios": User wants to add/delete/modify scenarios or adjust distribution
+    - "command": User typed a built-in command
+    - "unclear": Cannot determine intent
+
+    Examples:
+        >>> classifier = HITLIntentClassifier(llm=LLM(model=OpenAI.GPT_4O))
+        >>> intent = await classifier.classify(
+        ...     user_input="I want shorter conversations",
+        ...     current_turns=3,
+        ...     complexity_level="conditional",
+        ...     rule_count=10,
+        ...     scenario_count=20
+        ... )
+        >>> intent.intent_type
+        'turns'
+        >>> intent.target_turns
+        2
+    """
+
+    def __init__(
+        self,
+        llm: LLM | None = None,
+        model: Model = OpenAI.GPT_4O,
+    ):
+        """
+        Initialize the HITL Intent Classifier.
+
+        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.2)
+
+    async def classify(
+        self,
+        user_input: str,
+        current_turns: int,
+        complexity_level: str,
+        rule_count: int,
+        scenario_count: int = 0,
+        conversation_history: str = "No previous feedback in this session.",
+    ) -> HITLIntent:
+        """
+        Classify user input and extract structured intent.
+
+        Args:
+            user_input: The user's natural language feedback
+            current_turns: Current conversation turns setting
+            complexity_level: Policy complexity level (simple/conditional/complex)
+            rule_count: Number of rules in the Logic Map
+            scenario_count: Number of scenarios generated
+            conversation_history: Formatted history of previous feedback in this session
+
+        Returns:
+            HITLIntent with classified intent_type and relevant fields populated
+        """
+        prompt = HITL_INTENT_CLASSIFIER_PROMPT.format(
+            user_input=user_input,
+            current_turns=current_turns,
+            complexity_level=complexity_level,
+            rule_count=rule_count,
+            scenario_count=scenario_count,
+            conversation_history=conversation_history,
+        )
+
+        try:
+            return await self.llm.generate_structured(prompt, HITLIntent)
+        except Exception:
+            # Default to treating as rule feedback (preserves existing behavior)
+            return HITLIntent(
+                intent_type="rules",
+                confidence=0.5,
+                rule_feedback=user_input,
+            )
+
+
+__all__ = ["HITLIntentClassifier"]

synkro/interactive/logic_map_editor.py

@@ -0,0 +1,176 @@
+"""Logic Map Editor - LLM-powered interactive refinement of Logic Maps."""
+
+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 RefinedLogicMapOutput
+from synkro.types.logic_map import LogicMap, Rule, RuleCategory
+from synkro.prompts.interactive_templates import LOGIC_MAP_REFINEMENT_PROMPT
+
+if TYPE_CHECKING:
+    pass
+
+
+class LogicMapEditor:
+    """
+    LLM-powered Logic Map editor that interprets natural language feedback.
+
+    The editor takes user feedback in natural language (e.g., "add a rule for...",
+    "remove R005", "merge R002 and R003") and uses an LLM to interpret and apply
+    the changes to the Logic Map.
+
+    Examples:
+        >>> editor = LogicMapEditor(llm=LLM(model=OpenAI.GPT_4O))
+        >>> new_logic_map = await editor.refine(
+        ...     logic_map=current_map,
+        ...     user_feedback="Add a rule for overtime approval",
+        ...     policy_text=policy.text
+        ... )
+    """
+
+    def __init__(
+        self,
+        llm: LLM | None = None,
+        model: Model = OpenAI.GPT_4O,
+    ):
+        """
+        Initialize the Logic Map 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,
+        logic_map: LogicMap,
+        user_feedback: str,
+        policy_text: str,
+        conversation_history: str = "No previous feedback in this session.",
+    ) -> tuple[LogicMap, str]:
+        """
+        Refine the Logic Map based on natural language feedback.
+
+        Args:
+            logic_map: Current Logic Map to refine
+            user_feedback: Natural language instruction from user
+            policy_text: Original policy text for context
+            conversation_history: Formatted history of previous feedback in this session
+
+        Returns:
+            Tuple of (refined LogicMap, changes summary string)
+
+        Raises:
+            ValueError: If refinement produces invalid DAG
+        """
+        # Format current Logic Map as string for prompt
+        current_map_str = self._format_logic_map_for_prompt(logic_map)
+
+        # Format the prompt
+        prompt = LOGIC_MAP_REFINEMENT_PROMPT.format(
+            current_logic_map=current_map_str,
+            policy_text=policy_text,
+            user_feedback=user_feedback,
+            conversation_history=conversation_history,
+        )
+
+        # Generate structured output
+        result = await self.llm.generate_structured(prompt, RefinedLogicMapOutput)
+
+        # Convert to domain model
+        refined_map = self._convert_to_logic_map(result)
+
+        # Validate DAG properties
+        if not refined_map.validate_dag():
+            raise ValueError(
+                "Refined Logic Map contains circular dependencies. "
+                "Please try a different modification."
+            )
+
+        return refined_map, result.changes_summary
+
+    def _format_logic_map_for_prompt(self, logic_map: LogicMap) -> str:
+        """Format a Logic Map as a string for the LLM prompt."""
+        lines = []
+        lines.append(f"Total Rules: {len(logic_map.rules)}")
+        lines.append(f"Root Rules: {', '.join(logic_map.root_rules)}")
+        lines.append("")
+        lines.append("Rules:")
+
+        for rule in logic_map.rules:
+            deps = f" -> {', '.join(rule.dependencies)}" if rule.dependencies else ""
+            lines.append(f"  {rule.rule_id}: {rule.text}")
+            lines.append(f"    Category: {rule.category.value}")
+            lines.append(f"    Condition: {rule.condition}")
+            lines.append(f"    Action: {rule.action}")
+            if deps:
+                lines.append(f"    Dependencies: {', '.join(rule.dependencies)}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def _convert_to_logic_map(self, output: RefinedLogicMapOutput) -> LogicMap:
+        """Convert schema output to domain model."""
+        rules = []
+        for rule_out in output.rules:
+            # Convert category string to enum
+            category = RuleCategory(rule_out.category)
+
+            rule = Rule(
+                rule_id=rule_out.rule_id,
+                text=rule_out.text,
+                condition=rule_out.condition,
+                action=rule_out.action,
+                dependencies=rule_out.dependencies,
+                category=category,
+            )
+            rules.append(rule)
+
+        return LogicMap(
+            rules=rules,
+            root_rules=output.root_rules,
+        )
+
+    def validate_refinement(
+        self,
+        original: LogicMap,
+        refined: LogicMap,
+    ) -> tuple[bool, list[str]]:
+        """
+        Validate that refinement maintains DAG properties and is sensible.
+
+        Args:
+            original: Original Logic Map
+            refined: Refined Logic Map
+
+        Returns:
+            Tuple of (is_valid, list of issue descriptions)
+        """
+        issues = []
+
+        # Check DAG validity
+        if not refined.validate_dag():
+            issues.append("Refined Logic Map has circular dependencies")
+
+        # Check that all dependencies reference existing rules
+        rule_ids = {r.rule_id for r in refined.rules}
+        for rule in refined.rules:
+            for dep in rule.dependencies:
+                if dep not in rule_ids:
+                    issues.append(f"Rule {rule.rule_id} depends on non-existent rule {dep}")
+
+        # Check root_rules consistency
+        for root_id in refined.root_rules:
+            if root_id not in rule_ids:
+                issues.append(f"Root rule {root_id} does not exist")
+
+        # Check that rules with no dependencies are in root_rules
+        for rule in refined.rules:
+            if not rule.dependencies and rule.rule_id not in refined.root_rules:
+                issues.append(f"Rule {rule.rule_id} has no dependencies but is not in root_rules")
+
+        return len(issues) == 0, issues