vbagent 0.1.0__tar.gz

vbagent-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: vbagent
+Version: 0.1.0
+Summary: CLI tool for physics question image scanning, categorization, and variant generation
+Author: vaibhavblayer
+Author-email: vaibhavblayer@gmail.com
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: dev
+Requires-Dist: click (>=8.1.0)
+Requires-Dist: hypothesis (>=6.0.0) ; extra == "dev"
+Requires-Dist: openai-agents (>=0.6.2)
+Requires-Dist: pillow (>=10.0.0)
+Requires-Dist: pydantic (>=2.0.0)
+Requires-Dist: pytest (>=8.0.0) ; extra == "dev"
+Requires-Dist: rich (>=13.0.0)
+Description-Content-Type: text/markdown
+
+

vbagent-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "vbagent"
+version = "0.1.0"
+description = "CLI tool for physics question image scanning, categorization, and variant generation"
+authors = [
+    {name = "vaibhavblayer", email = "vaibhavblayer@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "openai-agents>=0.6.2",
+    "pydantic>=2.0.0",
+    "click>=8.1.0",
+    "pillow>=10.0.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "hypothesis>=6.0.0",
+]
+
+[project.scripts]
+vbagent = "vbagent.cli.main:main"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

vbagent-0.1.0/vbagent/__init__.py

@@ -0,0 +1,3 @@
+"""VBAgent - Physics question processing pipeline using OpenAI."""
+
+__version__ = "0.1.0"

vbagent-0.1.0/vbagent/agents/__init__.py

@@ -0,0 +1,127 @@
+"""Agent modules for vbagent using openai-agents SDK.
+
+Uses lazy imports to avoid loading heavy dependencies (openai, agents, mcp, pydantic)
+until they are actually needed. This significantly improves CLI startup time.
+"""
+
+from typing import TYPE_CHECKING
+
+# Only import for type checking - avoids heavy runtime imports
+if TYPE_CHECKING:
+    from .base import (
+        encode_image,
+        create_image_message,
+        create_agent,
+        run_agent,
+        run_agent_sync,
+    )
+    from .classifier import classifier_agent, classify
+    from .idea import idea_agent_json, idea_agent_latex, extract_ideas, generate_idea_latex
+    from .alternate import alternate_agent, generate_alternate, extract_answer
+    from .selector import (
+        ProblemContext,
+        discover_problems,
+        select_random,
+        load_problem_context,
+    )
+    from .solution_checker import (
+        solution_checker_agent,
+        check_solution,
+        has_solution_passed,
+    )
+    from .grammar_checker import (
+        grammar_checker_agent,
+        check_grammar,
+        has_grammar_passed,
+    )
+    from .clarity_checker import (
+        clarity_checker_agent,
+        check_clarity,
+        has_clarity_passed,
+    )
+    from .tikz_checker import (
+        tikz_checker_agent,
+        check_tikz,
+        has_tikz_passed,
+        has_tikz_environment,
+    )
+
+
+__all__ = [
+    "encode_image",
+    "create_image_message",
+    "create_agent",
+    "run_agent",
+    "run_agent_sync",
+    "classifier_agent",
+    "classify",
+    "idea_agent_json",
+    "idea_agent_latex",
+    "extract_ideas",
+    "generate_idea_latex",
+    "alternate_agent",
+    "generate_alternate",
+    "extract_answer",
+    "ProblemContext",
+    "discover_problems",
+    "select_random",
+    "load_problem_context",
+    # Solution checker
+    "solution_checker_agent",
+    "check_solution",
+    "has_solution_passed",
+    # Grammar checker
+    "grammar_checker_agent",
+    "check_grammar",
+    "has_grammar_passed",
+    # Clarity checker
+    "clarity_checker_agent",
+    "check_clarity",
+    "has_clarity_passed",
+    # TikZ checker
+    "tikz_checker_agent",
+    "check_tikz",
+    "has_tikz_passed",
+    "has_tikz_environment",
+]
+
+
+def __getattr__(name: str):
+    """Lazy import of agent modules to speed up CLI startup."""
+    if name in ("encode_image", "create_image_message", "create_agent", "run_agent", "run_agent_sync"):
+        from . import base
+        return getattr(base, name)
+    
+    if name in ("classifier_agent", "classify"):
+        from . import classifier
+        return getattr(classifier, name)
+    
+    if name in ("idea_agent_json", "idea_agent_latex", "extract_ideas", "generate_idea_latex"):
+        from . import idea
+        return getattr(idea, name)
+    
+    if name in ("alternate_agent", "generate_alternate", "extract_answer"):
+        from . import alternate
+        return getattr(alternate, name)
+    
+    if name in ("ProblemContext", "discover_problems", "select_random", "load_problem_context"):
+        from . import selector
+        return getattr(selector, name)
+    
+    if name in ("solution_checker_agent", "check_solution", "has_solution_passed"):
+        from . import solution_checker
+        return getattr(solution_checker, name)
+    
+    if name in ("grammar_checker_agent", "check_grammar", "has_grammar_passed"):
+        from . import grammar_checker
+        return getattr(grammar_checker, name)
+    
+    if name in ("clarity_checker_agent", "check_clarity", "has_clarity_passed"):
+        from . import clarity_checker
+        return getattr(clarity_checker, name)
+    
+    if name in ("tikz_checker_agent", "check_tikz", "has_tikz_passed", "has_tikz_environment"):
+        from . import tikz_checker
+        return getattr(tikz_checker, name)
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

vbagent-0.1.0/vbagent/agents/alternate.py

@@ -0,0 +1,178 @@
+"""Alternate solution agent for physics problems.
+
+Uses openai-agents SDK to generate alternative solution methods
+while maintaining the same final answer.
+"""
+
+import re
+from typing import Optional
+
+from vbagent.agents.base import create_agent, run_agent_sync
+
+
+def clean_latex_output(latex: str) -> str:
+    """Clean up LaTeX output by removing markdown code block markers.
+    
+    Removes patterns like:
+    - ```latex ... ```
+    - ``` ... ```
+    - Leading/trailing whitespace
+    
+    Args:
+        latex: Raw LaTeX output from LLM
+        
+    Returns:
+        Cleaned LaTeX without markdown artifacts
+    """
+    if not latex:
+        return latex
+    
+    # Remove markdown code block markers with language specifier
+    # Matches: ```latex, ```tex, ```LaTeX, etc.
+    latex = re.sub(r'^```(?:latex|tex|LaTeX)?\s*\n?', '', latex, flags=re.IGNORECASE)
+    
+    # Remove closing code block marker
+    latex = re.sub(r'\n?```\s*$', '', latex)
+    
+    # Also handle case where ``` appears at the start without newline
+    latex = re.sub(r'^```\s*', '', latex)
+    
+    return latex.strip()
+
+
+from vbagent.models.idea import IdeaResult
+from vbagent.prompts.alternate import (
+    SYSTEM_PROMPT,
+    USER_TEMPLATE,
+    USER_TEMPLATE_WITH_EXISTING,
+)
+
+
+# Create the alternate solution agent
+alternate_agent = create_agent(
+    name="AlternateSolution",
+    instructions=SYSTEM_PROMPT,
+    agent_type="alternate",
+)
+
+
+def extract_answer(solution: str) -> str:
+    """Extract the final numerical answer from a solution.
+    
+    Looks for common answer patterns in LaTeX solutions.
+    
+    Args:
+        solution: The solution text in LaTeX format
+        
+    Returns:
+        The extracted answer string, or empty string if not found
+    """
+    # Common patterns for final answers in physics solutions
+    patterns = [
+        # Boxed answers: \boxed{...} - handle nested braces
+        r'\\boxed\{((?:[^{}]|\{[^{}]*\})*)\}',
+        # Answer environment or explicit answer markers
+        r'(?:answer|ans|result)\s*[:=]\s*([^\n\\]+)',
+        # Final equals in solution: = X (with optional units in \text{})
+        r'=\s*([-+]?\d+(?:\.\d+)?(?:\s*\\times\s*10\^?\{?[-+]?\d+\}?)?)\s*(?:\\text\{[^}]*\}|\\[a-zA-Z]+|[a-zA-Z/]+)?(?:\s*$|\s*\\\\|\s*\n)',
+    ]
+    
+    for pattern in patterns:
+        matches = re.findall(pattern, solution, re.IGNORECASE | re.MULTILINE)
+        if matches:
+            # Return the last match (usually the final answer)
+            return matches[-1].strip()
+    
+    return ""
+
+
+def extract_existing_alternates(content: str) -> list[str]:
+    """Extract existing alternate solutions from LaTeX content.
+    
+    Args:
+        content: Full LaTeX content of the problem file
+        
+    Returns:
+        List of existing alternate solution contents
+    """
+    pattern = r'\\begin\{alternatesolution\}(.*?)\\end\{alternatesolution\}'
+    matches = re.findall(pattern, content, re.DOTALL)
+    return [m.strip() for m in matches]
+
+
+def has_alternate_solution(content: str) -> bool:
+    """Check if content already has an alternate solution.
+    
+    Args:
+        content: Full LaTeX content of the problem file
+        
+    Returns:
+        True if alternatesolution environment exists
+    """
+    return r'\begin{alternatesolution}' in content
+
+
+def count_alternate_solutions(content: str) -> int:
+    """Count the number of alternate solutions in content.
+    
+    Args:
+        content: Full LaTeX content of the problem file
+        
+    Returns:
+        Number of alternatesolution environments
+    """
+    return content.count(r'\begin{alternatesolution}')
+
+
+def generate_alternate(
+    problem: str,
+    solution: str,
+    ideas: Optional[IdeaResult] = None,
+    existing_alternates: Optional[list[str]] = None,
+    full_content: Optional[str] = None,
+) -> str:
+    """Generate an alternate solution approach for a physics problem.
+    
+    Creates a different valid solution method that arrives at the same
+    final answer as the original solution.
+    
+    Args:
+        problem: The problem statement in LaTeX format (legacy, used if full_content not provided)
+        solution: The original solution in LaTeX format (legacy, used if full_content not provided)
+        ideas: Optional IdeaResult with extracted concepts and techniques
+        existing_alternates: List of existing alternate solutions to avoid repeating
+        full_content: Full LaTeX file content (preferred - pass entire file)
+        
+    Returns:
+        Alternative solution in LaTeX format within alternatesolution environment
+        
+    Raises:
+        ValueError: If content is empty
+    """
+    # Use full_content if provided, otherwise construct from problem/solution
+    if full_content:
+        content_to_use = full_content.strip()
+    else:
+        if not problem.strip():
+            raise ValueError("Problem cannot be empty")
+        if not solution.strip():
+            raise ValueError("Solution cannot be empty")
+        content_to_use = f"{problem}\n\n\\begin{{solution}}\n{solution}\n\\end{{solution}}"
+    
+    if not content_to_use:
+        raise ValueError("Content cannot be empty")
+    
+    # Check if there are existing alternates in the content
+    has_existing = r'\begin{alternatesolution}' in content_to_use
+    
+    # Choose template based on whether existing alternates exist
+    # Use string replace instead of .format() to avoid issues with LaTeX curly braces
+    if has_existing or existing_alternates:
+        message = USER_TEMPLATE_WITH_EXISTING.replace('{full_content}', content_to_use)
+    else:
+        message = USER_TEMPLATE.replace('{full_content}', content_to_use)
+    
+    raw_result = run_agent_sync(alternate_agent, message)
+    
+    # Clean up markdown artifacts from LLM output
+    return clean_latex_output(raw_result)

vbagent-0.1.0/vbagent/agents/base.py

@@ -0,0 +1,214 @@
+"""Base agent utilities using OpenAI Agents SDK."""
+
+import base64
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional
+
+# Lazy import for heavy agents SDK - only import at runtime when needed
+if TYPE_CHECKING:
+    from agents import Agent, ModelSettings
+
+from vbagent.config import get_model, get_model_settings
+
+
+def _get_agent_class():
+    """Lazy import of Agent class."""
+    from agents import Agent
+    return Agent
+
+
+def _get_runner_class():
+    """Lazy import of Runner class."""
+    from agents import Runner
+    return Runner
+
+
+def _get_model_settings_class():
+    """Lazy import of ModelSettings class."""
+    from agents import ModelSettings
+    return ModelSettings
+
+
+def encode_image(image_path: str) -> tuple[str, str]:
+    """Encode an image file to base64.
+    
+    Args:
+        image_path: Path to the image file
+        
+    Returns:
+        Tuple of (base64_data, media_type)
+    """
+    path = Path(image_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Image not found: {image_path}")
+    
+    with open(path, "rb") as f:
+        image_bytes = f.read()
+    
+    image_data = base64.b64encode(image_bytes).decode("utf-8")
+    
+    suffix = path.suffix.lower()
+    media_type_map = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+    }
+    media_type = media_type_map.get(suffix, "image/jpeg")
+    
+    return image_data, media_type
+
+
+def create_image_message(image_path: str, text: str) -> list[dict[str, Any]]:
+    """Create a message with image and text for the agent.
+    
+    Uses the OpenAI Responses API format for image input.
+    
+    Args:
+        image_path: Path to the image file
+        text: Text message to accompany the image
+        
+    Returns:
+        List containing a single message dict in Responses API format
+    """
+    image_data, media_type = encode_image(image_path)
+    # Responses API format: message with content list containing input_image and input_text
+    return [
+        {
+            "type": "message",
+            "role": "user",
+            "content": [
+                {
+                    "type": "input_image",
+                    "image_url": f"data:{media_type};base64,{image_data}",
+                    "detail": "auto"
+                },
+                {"type": "input_text", "text": text}
+            ]
+        }
+    ]
+
+
+def create_agent(
+    name: str,
+    instructions: str,
+    model: Optional[str] = None,
+    model_settings: Optional["ModelSettings"] = None,
+    output_type: Optional[type] = None,
+    tools: Optional[list] = None,
+    agent_type: Optional[str] = None,
+) -> "Agent":
+    """Create an agent with default configuration.
+    
+    Args:
+        name: Agent name
+        instructions: System prompt / instructions
+        model: Model to use (if None, uses config for agent_type)
+        model_settings: Optional ModelSettings for temperature, max_tokens, etc.
+        output_type: Optional Pydantic model for structured output
+        tools: Optional list of tools (@function_tool decorated functions)
+        agent_type: Agent type for config lookup (classifier, scanner, tikz, etc.)
+        
+    Returns:
+        Configured Agent instance
+    """
+    Agent = _get_agent_class()
+    
+    # Get model and settings from config if not explicitly provided
+    if model is None:
+        model = get_model(agent_type or "default")
+    if model_settings is None:
+        model_settings = get_model_settings(agent_type or "default")
+    
+    return Agent(
+        name=name,
+        instructions=instructions,
+        model=model,
+        model_settings=model_settings,
+        output_type=output_type,
+        tools=tools or [],
+    )
+
+
+def _print_agent_info(agent: "Agent") -> None:
+    """Print agent information when running.
+    
+    Args:
+        agent: The Agent instance being run
+    """
+    model = agent.model or "default"
+    reasoning = "unknown"
+    
+    # Extract reasoning effort from model_settings if available
+    if agent.model_settings:
+        settings = agent.model_settings
+        if hasattr(settings, 'reasoning') and settings.reasoning:
+            reasoning_obj = settings.reasoning
+            # Handle both dict and Reasoning object
+            if isinstance(reasoning_obj, dict):
+                reasoning = reasoning_obj.get('effort', 'unknown')
+            elif hasattr(reasoning_obj, 'effort'):
+                reasoning = reasoning_obj.effort or 'unknown'
+    
+    # Use dim styling for subtle output
+    print(f"\033[2m⚡ {agent.name} | model: {model} | reasoning: {reasoning}\033[0m")
+
+
+async def run_agent(agent: "Agent", input_text: str | list) -> Any:
+    """Run an agent asynchronously and return the final output.
+    
+    Args:
+        agent: The Agent instance to run
+        input_text: The input text or message (can be string or list for images)
+        
+    Returns:
+        The agent's final output (string or structured type)
+    """
+    Runner = _get_runner_class()
+    _print_agent_info(agent)
+    result = await Runner.run(agent, input=input_text)
+    return result.final_output
+
+
+def run_agent_sync(agent: "Agent", input_text: str | list) -> Any:
+    """Run an agent synchronously and return the final output.
+    
+    Uses a thread to allow immediate Ctrl+C interruption.
+    
+    Args:
+        agent: The Agent instance to run
+        input_text: The input text or message (can be string or list for images)
+        
+    Returns:
+        The agent's final output (string or structured type)
+        
+    Raises:
+        KeyboardInterrupt: If user presses Ctrl+C
+    """
+    import concurrent.futures
+    import threading
+    
+    Runner = _get_runner_class()
+    _print_agent_info(agent)
+    
+    # Use a thread pool to run the agent, allowing Ctrl+C to interrupt
+    result_holder = {"result": None, "error": None}
+    
+    def run_in_thread():
+        try:
+            result_holder["result"] = Runner.run_sync(agent, input=input_text)
+        except Exception as e:
+            result_holder["error"] = e
+    
+    thread = threading.Thread(target=run_in_thread, daemon=True)
+    thread.start()
+    
+    # Wait for thread with small intervals to allow Ctrl+C handling
+    while thread.is_alive():
+        thread.join(timeout=0.1)  # Check every 100ms for interrupt
+    
+    if result_holder["error"]:
+        raise result_holder["error"]
+    
+    return result_holder["result"].final_output