DeepFabric 4.9.0__py3-none-any.whl → 4.10.0__py3-none-any.whl

deepfabric/builders.py

@@ -83,12 +83,14 @@ class BuilderType(BaseModel):
 # Builder type constants
 SINGLE_SHOT_BUILDER = BuilderType(name="single_shot", requires_tools=False)
 SINGLE_TURN_AGENT_BUILDER = BuilderType(name="single_turn_agent", requires_tools=True)
-MULTI_TURN_AGENT_BUILDER = BuilderType(name="multi_turn_agent", requires_tools=True)
 
 
 def determine_builder_type(config: "DataSetGeneratorConfig") -> BuilderType:
     """Determine the appropriate builder type from configuration.
 
+    Agent mode is implicit when tools are configured (tool_components or custom_tools).
+    Single-turn agent mode is used for tool-calling conversations.
+
     Args:
         config: Generator configuration (Pydantic model)
 
@@ -98,20 +100,10 @@ def determine_builder_type(config: "DataSetGeneratorConfig") -> BuilderType:
     Raises:
         ValueError: If configuration is invalid or unsupported
     """
-    # Agent mode with tools requires specialized builder
-    if config.agent_mode:
-        # Check that tools are configured via tool_components or custom_tools
-        has_tools = config.tool_components or config.custom_tools
-        if not has_tools:
-            msg = "agent_mode requires tools to be configured via tool_components or custom_tools"
-            raise ValueError(msg)
-
-        if config.agent_mode == "multi_turn":
-            return MULTI_TURN_AGENT_BUILDER
-        if config.agent_mode == "single_turn":
-            return SINGLE_TURN_AGENT_BUILDER
-        msg = f"Unknown agent_mode: {config.agent_mode}"
-        raise ValueError(msg)
+    # Agent mode is implicit when tools are configured
+    has_tools = config.tool_components or config.custom_tools
+    if has_tools:
+        return SINGLE_TURN_AGENT_BUILDER
 
     # Non-agent conversations use single-shot generation
     if config.conversation_type in ("basic", "cot"):
@@ -293,11 +285,5 @@ class ConversationBuilderFactory:
             return SingleTurnAgentBuilder(
                 llm, config, cast("ToolRegistry", tool_registry), progress_reporter
             )
-        if builder_type == MULTI_TURN_AGENT_BUILDER:
-            from .builders_agent import MultiTurnAgentBuilder  # noqa: PLC0415
-
-            return MultiTurnAgentBuilder(
-                llm, config, cast("ToolRegistry", tool_registry), progress_reporter
-            )
         msg = f"Unknown builder type: {builder_type.name}"
         raise ValueError(msg)

deepfabric/builders_agent.py

@@ -1,6 +1,5 @@
 import json
 import logging
-import random
 import uuid
 
 from typing import TYPE_CHECKING, Any
@@ -77,15 +76,6 @@ class UserQuestion(BaseModel):
     )
 
 
-class Scenario(BaseModel):
-    """Multi-turn scenario description."""
-
-    description: str = Field(
-        description="Brief scenario description requiring multiple turns",
-        min_length=20,
-    )
-
-
 class AgentResponse(BaseModel):
     """Agent's response to user."""
 
@@ -101,54 +91,6 @@ class ToolOutput(BaseModel):
     result: str = Field(description="The tool's output/result", min_length=1)
 
 
-class ConclusionDecision(BaseModel):
-    """Decision on whether to conclude conversation."""
-
-    should_conclude: bool = Field(
-        description="True if conversation task is complete, False if more turns needed"
-    )
-
-
-class StepWithResults(BaseModel):
-    """A ReAct step paired with its execution results.
-
-    Preserves the step-by-step structure for proper conversation formatting.
-    """
-
-    step: AgentStep = Field(description="The original step with thought and pending tool calls")
-    results: list[ToolExecution] = Field(
-        default_factory=list, description="Tool execution results for this step"
-    )
-
-
-class AgentTurnData(BaseModel):
-    """Typed data for a single turn in an agent conversation.
-
-    This model ensures type safety when building multi-turn conversations.
-    Stores steps with their results to preserve ReAct structure.
-    """
-
-    user_message: ChatMessage = Field(description="User's message for this turn")
-    steps_with_results: list[StepWithResults] = Field(
-        description="ReAct steps with their execution results, preserving step-by-step order"
-    )
-    agent_response: ChatMessage = Field(description="Agent's final response for this turn")
-
-    @property
-    def reasoning_steps(self) -> list[ReasoningStep]:
-        """Convert steps to ReasoningSteps for backward compatibility."""
-        steps = [swr.step for swr in self.steps_with_results]
-        return _convert_steps_to_reasoning(steps)
-
-    @property
-    def tool_calls(self) -> list[ToolExecution]:
-        """Get all tool executions for backward compatibility."""
-        result = []
-        for swr in self.steps_with_results:
-            result.extend(swr.results)
-        return result
-
-
 class SingleTurnAgentBuilder(ConversationBuilder):
     """Builder for single-turn agent conversations with tool calling.
 
@@ -830,487 +772,3 @@ Remember: You have access to the tools listed above and have used them in this c
                 0,
                 ChatMessage(role="system", content=self.config.dataset_system_prompt or ""),
             )
-
-
-class MultiTurnAgentBuilder(SingleTurnAgentBuilder):
-    """Builder for multi-turn agent conversations.
-
-    Extends SingleTurnAgentBuilder to generate conversations with multiple
-    user-agent interaction turns. Each turn can involve different tools
-    and builds on previous context.
-    """
-
-    async def generate(
-        self,
-        topic_prompt: str,
-        error_feedback: str | None = None,  # noqa: ARG002
-    ) -> Conversation:
-        """Generate multi-turn agent conversation using ReAct loop.
-
-        Args:
-            topic_prompt: Topic or scenario to generate conversation about
-            error_feedback: Unused, kept for interface consistency with ConversationBuilder
-
-        Returns:
-            Complete multi-turn Conversation
-
-        Raises:
-            ValueError: If generation fails or config is invalid
-        """
-        try:
-            # Initialize Spin session if configured
-            await self._ensure_spin_session()
-
-            # Determine number of turns (from config range)
-            num_turns = random.randint(self.config.min_turns, self.config.max_turns)  # noqa: S311 # nosec
-
-            # Track conversation context
-            turns: list[AgentTurnData] = []
-            all_messages: list[ChatMessage] = []
-
-            # Reset duplicate tracking for this conversation
-            self._seen_tool_signatures.clear()
-
-            # Generate scenario overview
-            scenario = await self._generate_scenario(topic_prompt, num_turns)
-
-            for turn_idx in range(num_turns):
-                # Generate this turn using ReAct loop
-                turn_data = await self._generate_turn(turn_idx, scenario, all_messages)
-                turns.append(turn_data)
-
-                # Accumulate messages for context
-                all_messages.extend(
-                    [
-                        turn_data.user_message,
-                        turn_data.agent_response,
-                    ]
-                )
-
-                # Count total tool calls so far
-                total_tool_calls = sum(len(t.tool_calls) for t in turns)
-
-                # Check if we should conclude early
-                if turn_idx >= self.config.min_turns - 1 and await self._should_conclude_early(
-                    all_messages, scenario, turn_idx + 1, total_tool_calls
-                ):
-                    break
-
-            # Assemble into complete conversation
-            return self._build_multi_turn_conversation(turns, scenario, topic_prompt)
-        finally:
-            # Always cleanup Spin session
-            await self._cleanup_spin_session()
-
-    async def _generate_scenario(self, topic_prompt: str, num_turns: int) -> str:
-        """Generate a multi-turn scenario description.
-
-        Args:
-            topic_prompt: Original topic
-            num_turns: Number of turns to plan for
-
-        Returns:
-            Scenario description that requires multiple interactions
-        """
-        tools_info = self._format_tools_for_prompt()
-
-        prompt = (
-            f"Generate a realistic scenario for this topic that requires {num_turns} user-agent interaction turns:\n"
-            f"{topic_prompt}\n\n"
-            f"Available tools:\n"
-            f"{tools_info}\n\n"
-            f"The scenario MUST:\n"
-            f"- Require at least {num_turns} distinct tool calls across different turns\n"
-            f"- Have tool dependencies (e.g., read before modify, search before create, fetch before analyze)\n"
-            f"- Build progressively - each turn depends on results from previous turns\n"
-            f"- NOT be completable in a single turn\n\n"
-            f"Example structure for a {num_turns}-turn scenario:\n"
-            f"- Turn 1: User asks to find/read/search something\n"
-            f"- Turn 2: User asks to modify/create based on what was found\n"
-            f"- Turn 3+: User asks to verify, take action, or build further on previous results\n\n"
-            f"Keep it brief (2-3 sentences) but ensure multi-step complexity with clear tool dependencies."
-        )
-
-        # Always use non-streaming for reliable structured output
-        response = await self.llm.generate_async(
-            prompt=prompt,
-            schema=Scenario,
-            max_tokens=self.config.max_tokens,
-            temperature=self.config.temperature,
-        )
-
-        # Fire-and-forget: simulate streaming for TUI preview (non-blocking)
-        simulate_stream(
-            self.progress_reporter,
-            response.model_dump_json(),
-            source="scenario_gen",
-        )
-
-        return response.description
-
-    async def _generate_turn(
-        self,
-        turn_idx: int,
-        scenario: str,
-        previous_messages: list[ChatMessage],
-    ) -> AgentTurnData:
-        """Generate a single turn of the conversation using ReAct loop.
-
-        Args:
-            turn_idx: Index of this turn (0-based)
-            scenario: Overall scenario description
-            previous_messages: Messages from previous turns
-
-        Returns:
-            Complete turn data with step-by-step structure preserved
-        """
-        # Build context from previous messages
-        context_text = self._format_message_context(previous_messages)
-
-        # Generate user message for this turn
-        user_message = await self._generate_turn_user_message(turn_idx, scenario, context_text)
-
-        # ReAct loop for this turn - preserve step structure
-        steps_with_results: list[StepWithResults] = []
-        all_steps: list[AgentStep] = []  # For passing to next step generation
-        all_tool_results: list[ToolExecution] = []  # For passing to next step generation
-        max_steps = getattr(self.config, "max_agent_steps", 5)
-
-        for step_num in range(max_steps):
-            if self.progress_reporter:
-                self.progress_reporter.emit_step_start(
-                    f"Turn {turn_idx + 1}, ReAct step {step_num + 1}/{max_steps}"
-                )
-
-            # Generate next step based on observations so far
-            step = await self._generate_next_step_with_context(
-                user_message,
-                all_steps,
-                all_tool_results,
-                context_text,
-            )
-            all_steps.append(step)
-
-            # Check if agent is done
-            if step.is_final or not step.tool_calls:
-                # Add final step with no results
-                steps_with_results.append(StepWithResults(step=step, results=[]))
-                if self.progress_reporter:
-                    self.progress_reporter.emit_step_complete(
-                        f"Turn {turn_idx + 1}: Agent concluded after {step_num + 1} steps"
-                    )
-                break
-
-            # Execute THIS step's tools via Spin
-            step_results = await self._execute_step_tools(step.tool_calls)
-
-            # Store step with its results
-            steps_with_results.append(StepWithResults(step=step, results=step_results))
-            all_tool_results.extend(step_results)
-
-            if self.progress_reporter:
-                self.progress_reporter.emit_step_complete(
-                    f"Turn {turn_idx + 1}: Executed {len(step.tool_calls)} tool(s)"
-                )
-
-        # Generate agent response based on all observations
-        agent_response = await self._generate_agent_conclusion(
-            user_message, all_steps, all_tool_results, context=context_text
-        )
-
-        return AgentTurnData(
-            user_message=user_message,
-            steps_with_results=steps_with_results,
-            agent_response=agent_response,
-        )
-
-    async def _generate_next_step_with_context(
-        self,
-        user_message: ChatMessage,
-        previous_steps: list[AgentStep],
-        previous_results: list[ToolExecution],
-        conversation_context: str,
-    ) -> AgentStep:
-        """Generate the next ReAct step with conversation context.
-
-        Similar to _generate_next_step but includes multi-turn conversation context.
-        """
-        tools_info = self._format_tools_for_prompt()
-        history = self._format_step_history(previous_steps, previous_results)
-
-        prompt_parts = [
-            "## Conversation Context",
-            conversation_context if conversation_context else "(No previous conversation)",
-            "",
-            "## Current User Request",
-            user_message.content or "",
-            "",
-            "## Available Tools",
-            tools_info,
-            "",
-            "## Previous Actions & Results (this turn)",
-            history if history else "None yet - this is your first action for this turn.",
-            "",
-            "## Instructions",
-            "Based on the conversation context and what you've observed so far, decide your next action:",
-            "- If you need more information, specify tool_calls for THIS step only",
-            "- If you have enough information to answer, set is_final=true and leave tool_calls empty",
-            "- IMPORTANT: Do NOT call write/modify operations until you've confirmed current state via read operations",
-            "- Tool arguments must use concrete values (no placeholders like '<user_input>' or null)",
-            "",
-            "What is your next step?",
-        ]
-
-        prompt = "\n".join(prompt_parts)
-
-        # Always use non-streaming for reliable structured output
-        response = await self.llm.generate_async(
-            prompt=prompt,
-            schema=AgentStep,
-            max_tokens=self.config.max_tokens,
-            temperature=self.config.temperature,
-        )
-
-        # Fire-and-forget: simulate streaming for TUI preview (non-blocking)
-        simulate_stream(
-            self.progress_reporter,
-            response.model_dump_json(),
-            source="agent_step_mt",
-        )
-
-        return response
-
-    async def _generate_turn_user_message(
-        self,
-        turn_idx: int,
-        scenario: str,
-        context: str,
-    ) -> ChatMessage:
-        """Generate user message for a specific turn.
-
-        Args:
-            turn_idx: Turn index
-            scenario: Overall scenario
-            context: Previous conversation context
-
-        Returns:
-            User message for this turn
-        """
-        turn_guidance = {
-            0: "Start with the initial request or question",
-            1: "Request a follow-up action or ask for more information",
-            2: "Request another related action or verify results",
-            3: "Final request or verification",
-        }
-
-        guidance = turn_guidance.get(turn_idx, "Continue the conversation naturally")
-
-        prompt = f"""Scenario: {scenario}
-
-Previous conversation:
-{context if context else "(No previous conversation)"}
-
-Generate the user's message for turn {turn_idx + 1}.
-Guidance: {guidance}
-
-The message should reference or build upon previous conversation if applicable.
-Keep it concise and natural."""
-
-        # Always use non-streaming for reliable structured output
-        response = await self.llm.generate_async(
-            prompt=prompt,
-            schema=UserQuestion,
-            max_tokens=self.config.max_tokens,
-            temperature=self.config.temperature,
-        )
-
-        # Fire-and-forget: simulate streaming for TUI preview (non-blocking)
-        simulate_stream(
-            self.progress_reporter,
-            response.model_dump_json(),
-            source=f"turn_{turn_idx}_user",
-            turn=turn_idx + 1,
-        )
-
-        return ChatMessage(role="user", content=response.content)
-
-    async def _should_conclude_early(
-        self, messages: list[ChatMessage], scenario: str, current_turn: int, total_tool_calls: int
-    ) -> bool:
-        """Determine if conversation should conclude before max_turns.
-
-        Args:
-            messages: All messages so far
-            scenario: Original scenario
-            current_turn: Current turn number
-            total_tool_calls: Total number of tool calls made so far
-
-        Returns:
-            True if conversation should end
-        """
-        # Don't conclude early if we haven't met the minimum tool calls requirement
-        if total_tool_calls < self.config.min_tool_calls:
-            return False
-
-        # Format conversation so far
-        conversation_text = self._format_message_context(messages)
-
-        prompt = f"""Scenario: {scenario}
-
-Conversation so far (after {current_turn} turns):
-{conversation_text}
-
-Is the user's original task/goal from the scenario fully completed?
-- True: Task is complete, conversation can end naturally
-- False: Task incomplete, more turns needed"""
-
-        response = await self.llm.generate_async(
-            prompt=prompt,
-            schema=ConclusionDecision,
-            max_tokens=100,
-            temperature=0.3,
-        )
-
-        return response.should_conclude
-
-    def _format_message_context(self, messages: list[ChatMessage]) -> str:
-        """Format messages as readable context.
-
-        Args:
-            messages: List of chat messages
-
-        Returns:
-            Formatted string of messages
-        """
-        if not messages:
-            return ""
-
-        lines = []
-        for msg in messages:
-            lines.append(f"{msg.role}: {msg.content}")
-
-        return "\n".join(lines)
-
-    def _build_multi_turn_conversation(
-        self, turns: list[AgentTurnData], scenario: str, topic_prompt: str = ""
-    ) -> Conversation:
-        """Assemble multi-turn conversation from turn data.
-
-        Preserves ReAct step-by-step structure: each step's tool calls become
-        a separate assistant message followed by tool responses. This ensures
-        training data shows the agent making decisions AFTER observing results.
-
-        Args:
-            turns: List of turn data
-            scenario: Scenario description
-            topic_prompt: Topic used to generate this conversation (for metadata)
-
-        Returns:
-            Complete Conversation object
-        """
-        messages = []
-
-        # Don't add system message for agent mode - it interferes with tool calling
-        # The system prompt teaches models to explain tool usage instead of executing tools
-        # For tool calling, the tool definitions themselves serve as instructions
-
-        # Collect all reasoning steps and tool executions
-        all_reasoning: list[ReasoningStep] = []
-        all_executions: list[ToolExecution] = []
-
-        # Add messages from each turn in correct order:
-        # For each turn: user -> [step: assistant(tool_calls) -> tool(responses)]* -> assistant(final)
-        for turn in turns:
-            # User message
-            messages.append(turn.user_message)
-
-            # Process each ReAct step separately to preserve step-by-step structure
-            # This is critical: agent should see results from step N before deciding step N+1
-            for step_with_results in turn.steps_with_results:
-                step = step_with_results.step
-                step_results = step_with_results.results
-
-                # Skip steps with no tool calls (e.g., final "is_final=true" step)
-                if not step.tool_calls:
-                    continue
-
-                # Build tool_calls for THIS step only
-                step_tool_calls: list[ToolCall] = []
-                step_tool_call_ids: list[str] = []
-                for result in step_results:
-                    tool_call_id = generate_tool_call_id()
-                    step_tool_call_ids.append(tool_call_id)
-                    step_tool_calls.append(result.to_tool_call(tool_call_id))
-
-                # Assistant message with tool_calls for this step
-                messages.append(
-                    ChatMessage(
-                        role="assistant",
-                        content="",
-                        tool_calls=step_tool_calls,
-                    )
-                )
-
-                # Tool response messages for this step
-                for idx, result in enumerate(step_results):
-                    messages.append(
-                        ChatMessage(
-                            role="tool",
-                            content=result.result,
-                            tool_call_id=step_tool_call_ids[idx],
-                        )
-                    )
-
-                # Accumulate executions for this step
-                all_executions.extend(step_results)
-
-            # Final assistant response with the answer for this turn
-            messages.append(turn.agent_response)
-
-            # Accumulate reasoning across all turns
-            all_reasoning.extend(turn.reasoning_steps)
-
-        # Build tool context (executions only - tools are in top-level 'tools' field)
-        tool_context = ToolContext(
-            executions=all_executions,
-        )
-
-        # Build reasoning trace
-        reasoning_trace = ReasoningTrace(
-            style=self.config.reasoning_style or "agent",  # type: ignore
-            content=all_reasoning,
-        )
-
-        # Build agent context
-        agent_context = AgentContext(
-            mode="multi_turn",
-            planning_trace=scenario,
-            execution_summary=f"Completed {len(turns)}-turn conversation",
-        )
-
-        # Build metadata
-        metadata = {
-            "conversation_type": "cot" if reasoning_trace else "basic",
-            "topic": topic_prompt if topic_prompt else "general",
-        }
-
-        # Insert system message if configured
-        self._insert_system_message_if_configured(messages)
-
-        # Convert tools to OpenAI format, filtering based on inclusion strategy
-        if self.config.tool_inclusion_strategy == "used_only" and all_executions:
-            used_names = {te.function_name for te in all_executions}
-            tools_openai = [
-                tool.to_openai() for tool in self.tool_registry.tools if tool.name in used_names
-            ]
-        else:
-            tools_openai = [tool.to_openai() for tool in self.tool_registry.tools]
-
-        return Conversation(
-            messages=messages,
-            reasoning=reasoning_trace,
-            tool_context=tool_context,
-            tools=tools_openai,
-            agent_context=agent_context,
-            metadata=metadata,
-        )