recursive-llm-ts 2.0.12 → 3.0.2

package/recursive-llm/src/rlm/core.py

@@ -1,322 +0,0 @@
-"""Core RLM implementation."""
-
-import asyncio
-import re
-from typing import Optional, Dict, Any, List
-
-import litellm
-
-from .types import Message
-from .repl import REPLExecutor, REPLError
-from .prompts import build_system_prompt
-from .parser import parse_response, is_final
-
-
-class RLMError(Exception):
-    """Base error for RLM."""
-    pass
-
-
-class MaxIterationsError(RLMError):
-    """Max iterations exceeded."""
-    pass
-
-
-class MaxDepthError(RLMError):
-    """Max recursion depth exceeded."""
-    pass
-
-
-class RLM:
-    """Recursive Language Model."""
-
-    def __init__(
-        self,
-        model: str,
-        recursive_model: Optional[str] = None,
-        api_base: Optional[str] = None,
-        api_key: Optional[str] = None,
-        max_depth: int = 5,
-        max_iterations: int = 30,
-        _current_depth: int = 0,
-        **llm_kwargs: Any
-    ):
-        """
-        Initialize RLM.
-
-        Args:
-            model: Model name (e.g., "gpt-4o", "claude-sonnet-4", "ollama/llama3.2")
-            recursive_model: Optional cheaper model for recursive calls
-            api_base: Optional API base URL
-            api_key: Optional API key
-            max_depth: Maximum recursion depth
-            max_iterations: Maximum REPL iterations per call
-            _current_depth: Internal current depth tracker
-            **llm_kwargs: Additional LiteLLM parameters
-        """
-        # Patch for recursive-llm-ts bug where config is passed as 2nd positional arg
-        if isinstance(recursive_model, dict):
-            config = recursive_model
-            # Reset recursive_model default
-            self.recursive_model = config.get('recursive_model', model)
-            self.api_base = config.get('api_base', api_base)
-            self.api_key = config.get('api_key', api_key)
-            self.max_depth = int(config.get('max_depth', max_depth))
-            self.max_iterations = int(config.get('max_iterations', max_iterations))
-            
-            # Extract other llm kwargs
-            excluded = {'recursive_model', 'api_base', 'api_key', 'max_depth', 'max_iterations'}
-            self.llm_kwargs = {k: v for k, v in config.items() if k not in excluded}
-            # Merge with any actual kwargs passed
-            self.llm_kwargs.update(llm_kwargs)
-        else:
-            self.recursive_model = recursive_model or model
-            self.api_base = api_base
-            self.api_key = api_key
-            self.max_depth = max_depth
-            self.max_iterations = max_iterations
-            self.llm_kwargs = llm_kwargs
-
-        self._current_depth = _current_depth
-        self.model = model
-
-        self.repl = REPLExecutor()
-
-        # Stats
-        self._llm_calls = 0
-        self._iterations = 0
-
-    def completion(
-        self,
-        query: str = "",
-        context: str = "",
-        **kwargs: Any
-    ) -> str:
-        """
-        Sync wrapper for acompletion.
-
-        Args:
-            query: User query (optional if query is in context)
-            context: Context to process (optional, can pass query here)
-            **kwargs: Additional LiteLLM parameters
-
-        Returns:
-            Final answer string
-
-        Examples:
-            # Standard usage
-            rlm.completion(query="Summarize this", context=document)
-
-            # Query in context (RLM will extract task)
-            rlm.completion(context="Summarize this document: ...")
-
-            # Single string (treat as context)
-            rlm.completion("Process this text and extract dates")
-        """
-        # If only one argument provided, treat it as context
-        if query and not context:
-            context = query
-            query = ""
-
-        return asyncio.run(self.acompletion(query, context, **kwargs))
-
-    async def acompletion(
-        self,
-        query: str = "",
-        context: str = "",
-        **kwargs: Any
-    ) -> str:
-        """
-        Main async completion method.
-
-        Args:
-            query: User query (optional if query is in context)
-            context: Context to process (optional, can pass query here)
-            **kwargs: Additional LiteLLM parameters
-
-        Returns:
-            Final answer string
-
-        Raises:
-            MaxIterationsError: If max iterations exceeded
-            MaxDepthError: If max recursion depth exceeded
-
-        Examples:
-            # Explicit query and context
-            await rlm.acompletion(query="What is this?", context=doc)
-
-            # Query embedded in context
-            await rlm.acompletion(context="Extract all dates from: ...")
-
-            # LLM will figure out the task
-            await rlm.acompletion(context=document_with_instructions)
-        """
-        # If only query provided, treat it as context
-        if query and not context:
-            context = query
-            query = ""
-        if self._current_depth >= self.max_depth:
-            raise MaxDepthError(f"Max recursion depth ({self.max_depth}) exceeded")
-
-        # Initialize REPL environment
-        repl_env = self._build_repl_env(query, context)
-
-        # Build initial messages
-        system_prompt = build_system_prompt(len(context), self._current_depth)
-        messages: List[Message] = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": query}
-        ]
-
-        # Main loop
-        for iteration in range(self.max_iterations):
-            self._iterations = iteration + 1
-
-            # Call LLM
-            response = await self._call_llm(messages, **kwargs)
-
-            # Check for FINAL
-            if is_final(response):
-                answer = parse_response(response, repl_env)
-                if answer is not None:
-                    return answer
-
-            # Execute code in REPL
-            try:
-                exec_result = self.repl.execute(response, repl_env)
-            except REPLError as e:
-                exec_result = f"Error: {str(e)}"
-            except Exception as e:
-                exec_result = f"Unexpected error: {str(e)}"
-
-            # Add to conversation
-            messages.append({"role": "assistant", "content": response})
-            messages.append({"role": "user", "content": exec_result})
-
-        raise MaxIterationsError(
-            f"Max iterations ({self.max_iterations}) exceeded without FINAL()"
-        )
-
-    async def _call_llm(
-        self,
-        messages: List[Message],
-        **kwargs: Any
-    ) -> str:
-        """
-        Call LLM API.
-
-        Args:
-            messages: Conversation messages
-            **kwargs: Additional parameters (can override model here)
-
-        Returns:
-            LLM response text
-        """
-        self._llm_calls += 1
-
-        # Choose model based on depth
-        default_model = self.model if self._current_depth == 0 else self.recursive_model
-
-        # Allow override via kwargs
-        model = kwargs.pop('model', default_model)
-
-        # Merge kwargs
-        call_kwargs = {**self.llm_kwargs, **kwargs}
-        if self.api_base:
-            call_kwargs['api_base'] = self.api_base
-        if self.api_key:
-            call_kwargs['api_key'] = self.api_key
-
-        # Call LiteLLM
-        response = await litellm.acompletion(
-            model=model,
-            messages=messages,
-            **call_kwargs
-        )
-
-        # Extract text
-        return response.choices[0].message.content
-
-    def _build_repl_env(self, query: str, context: str) -> Dict[str, Any]:
-        """
-        Build REPL environment.
-
-        Args:
-            query: User query
-            context: Context string
-
-        Returns:
-            Environment dict
-        """
-        env: Dict[str, Any] = {
-            'context': context,
-            'query': query,
-            'recursive_llm': self._make_recursive_fn(),
-            're': re,  # Whitelist re module
-        }
-        return env
-
-    def _make_recursive_fn(self) -> Any:
-        """
-        Create recursive LLM function for REPL.
-
-        Returns:
-            Async function that can be called from REPL
-        """
-        async def recursive_llm(sub_query: str, sub_context: str) -> str:
-            """
-            Recursively process sub-context.
-
-            Args:
-                sub_query: Query for sub-context
-                sub_context: Sub-context to process
-
-            Returns:
-                Answer from recursive call
-            """
-            if self._current_depth + 1 >= self.max_depth:
-                return f"Max recursion depth ({self.max_depth}) reached"
-
-            # Create sub-RLM with increased depth
-            sub_rlm = RLM(
-                model=self.recursive_model,
-                recursive_model=self.recursive_model,
-                api_base=self.api_base,
-                api_key=self.api_key,
-                max_depth=self.max_depth,
-                max_iterations=self.max_iterations,
-                _current_depth=self._current_depth + 1,
-                **self.llm_kwargs
-            )
-
-            return await sub_rlm.acompletion(sub_query, sub_context)
-
-        # Wrap in sync function for REPL compatibility
-        def sync_recursive_llm(sub_query: str, sub_context: str) -> str:
-            """Sync wrapper for recursive_llm."""
-            # Check if we're in an async context
-            try:
-                loop = asyncio.get_running_loop()
-                # We're in async context, but REPL is sync
-                # Create a new thread to run async code
-                import concurrent.futures
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(
-                        asyncio.run,
-                        recursive_llm(sub_query, sub_context)
-                    )
-                    return future.result()
-            except RuntimeError:
-                # No running loop, safe to use asyncio.run
-                return asyncio.run(recursive_llm(sub_query, sub_context))
-
-        return sync_recursive_llm
-
-    @property
-    def stats(self) -> Dict[str, int]:
-        """Get execution statistics."""
-        return {
-            'llm_calls': self._llm_calls,
-            'iterations': self._iterations,
-            'depth': self._current_depth,
-        }

package/recursive-llm/src/rlm/parser.py

@@ -1,93 +0,0 @@
-"""Parse FINAL() and FINAL_VAR() statements from LLM responses."""
-
-import re
-from typing import Optional, Dict, Any
-
-
-def extract_final(response: str) -> Optional[str]:
-    """
-    Extract answer from FINAL() statement.
-
-    Args:
-        response: LLM response text
-
-    Returns:
-        Extracted answer or None if not found
-    """
-    # Look for FINAL("answer") or FINAL('answer')
-    patterns = [
-        r'FINAL\s*\(\s*"""(.*)"""',  # FINAL("""answer""") - triple double quotes
-        r"FINAL\s*\(\s*'''(.*)'''",  # FINAL('''answer''') - triple single quotes
-        r'FINAL\s*\(\s*"([^"]*)"',  # FINAL("answer") - double quotes
-        r"FINAL\s*\(\s*'([^']*)'",  # FINAL('answer') - single quotes
-    ]
-
-    for pattern in patterns:
-        match = re.search(pattern, response, re.DOTALL)
-        if match:
-            return match.group(1).strip()
-
-    return None
-
-
-def extract_final_var(response: str, env: Dict[str, Any]) -> Optional[str]:
-    """
-    Extract answer from FINAL_VAR() statement.
-
-    Args:
-        response: LLM response text
-        env: REPL environment with variables
-
-    Returns:
-        Variable value as string or None if not found
-    """
-    # Look for FINAL_VAR(var_name)
-    match = re.search(r'FINAL_VAR\s*\(\s*(\w+)\s*\)', response)
-    if not match:
-        return None
-
-    var_name = match.group(1)
-
-    # Get variable from environment
-    if var_name in env:
-        value = env[var_name]
-        return str(value)
-
-    return None
-
-
-def is_final(response: str) -> bool:
-    """
-    Check if response contains FINAL() or FINAL_VAR().
-
-    Args:
-        response: LLM response text
-
-    Returns:
-        True if response contains final statement
-    """
-    return 'FINAL(' in response or 'FINAL_VAR(' in response
-
-
-def parse_response(response: str, env: Dict[str, Any]) -> Optional[str]:
-    """
-    Parse response for any final statement.
-
-    Args:
-        response: LLM response text
-        env: REPL environment
-
-    Returns:
-        Final answer or None
-    """
-    # Try FINAL() first
-    answer = extract_final(response)
-    if answer is not None:
-        return answer
-
-    # Try FINAL_VAR()
-    answer = extract_final_var(response, env)
-    if answer is not None:
-        return answer
-
-    return None

package/recursive-llm/src/rlm/prompts.py

@@ -1,50 +0,0 @@
-"""System prompt templates for RLM."""
-
-
-def build_system_prompt(context_size: int, depth: int = 0) -> str:
-    """
-    Build system prompt for RLM.
-
-    Args:
-        context_size: Size of context in characters
-        depth: Current recursion depth
-
-    Returns:
-        System prompt string
-    """
-    # Minimal prompt (paper-style)
-    prompt = f"""You are a Recursive Language Model. You interact with context through a Python REPL environment.
-
-The context is stored in variable `context` (not in this prompt). Size: {context_size:,} characters.
-
-Available in environment:
-- context: str (the document to analyze)
-- query: str (the question: "{"{"}query{"}"}")
-- recursive_llm(sub_query, sub_context) -> str (recursively process sub-context)
-- re: already imported regex module (use re.findall, re.search, etc.)
-
-Write Python code to answer the query. The last expression or print() output will be shown to you.
-
-Examples:
-- print(context[:100])  # See first 100 chars
-- errors = re.findall(r'ERROR', context)  # Find all ERROR
-- count = len(errors); print(count)  # Count and show
-
-When you have the answer, use FINAL("answer") - this is NOT a function, just write it as text.
-
-Depth: {depth}"""
-
-    return prompt
-
-
-def build_user_prompt(query: str) -> str:
-    """
-    Build user prompt.
-
-    Args:
-        query: User's question
-
-    Returns:
-        User prompt string
-    """
-    return query

package/recursive-llm/src/rlm/repl.py

@@ -1,235 +0,0 @@
-"""Safe REPL executor using RestrictedPython."""
-
-import io
-import sys
-from typing import Dict, Any, Optional
-from RestrictedPython import compile_restricted_exec, safe_globals, limited_builtins, utility_builtins
-from RestrictedPython.Guards import guarded_iter_unpack_sequence, safer_getattr
-from RestrictedPython.PrintCollector import PrintCollector
-
-
-class REPLError(Exception):
-    """Error during REPL execution."""
-    pass
-
-
-class REPLExecutor:
-    """Safe Python code executor."""
-
-    def __init__(self, timeout: int = 5, max_output_chars: int = 2000):
-        """
-        Initialize REPL executor.
-
-        Args:
-            timeout: Execution timeout in seconds (not currently enforced)
-            max_output_chars: Maximum characters to return (truncate if longer)
-        """
-        self.timeout = timeout
-        self.max_output_chars = max_output_chars
-
-    def execute(self, code: str, env: Dict[str, Any]) -> str:
-        """
-        Execute Python code in restricted environment.
-
-        Args:
-            code: Python code to execute
-            env: Environment with context, query, recursive_llm, etc.
-
-        Returns:
-            String result of execution (stdout or last expression)
-
-        Raises:
-            REPLError: If code execution fails
-        """
-        # Filter out code blocks if present (LLM might wrap code)
-        code = self._extract_code(code)
-
-        if not code.strip():
-            return "No code to execute"
-
-        # Build restricted globals
-        restricted_globals = self._build_globals(env)
-
-        # Capture stdout
-        old_stdout = sys.stdout
-        sys.stdout = captured_output = io.StringIO()
-
-        try:
-            # Compile with RestrictedPython
-            byte_code = compile_restricted_exec(code)
-
-            if byte_code.errors:
-                raise REPLError(f"Compilation error: {', '.join(byte_code.errors)}")
-
-            # Execute
-            exec(byte_code.code, restricted_globals, env)
-
-            # Get output from stdout
-            output = captured_output.getvalue()
-
-            # Get output from PrintCollector if available
-            if '_print' in env and hasattr(env['_print'], '__call__'):
-                # PrintCollector stores prints in its txt attribute
-                print_collector = env['_print']
-                if hasattr(print_collector, 'txt'):
-                    output += ''.join(print_collector.txt)
-
-            # Check if last line was an expression (try to get its value)
-            # This handles cases like: error_count (should return its value)
-            lines = code.strip().split('\n')
-            if lines:
-                last_line = lines[-1].strip()
-                # If last line is a simple expression (no assignment, no keyword)
-                if last_line and not any(kw in last_line for kw in ['=', 'import', 'def', 'class', 'if', 'for', 'while', 'with']):
-                    try:
-                        # Try to evaluate the last line as expression
-                        result = eval(last_line, restricted_globals, env)
-                        if result is not None:
-                            output += str(result) + '\n'
-                    except:
-                        pass  # Not an expression, ignore
-
-            if not output:
-                return "Code executed successfully (no output)"
-
-            # Truncate output if too long (as per paper: "truncated version of output")
-            if len(output) > self.max_output_chars:
-                truncated = output[:self.max_output_chars]
-                return f"{truncated}\n\n[Output truncated: {len(output)} chars total, showing first {self.max_output_chars}]"
-
-            return output.strip()
-
-        except Exception as e:
-            raise REPLError(f"Execution error: {str(e)}")
-
-        finally:
-            sys.stdout = old_stdout
-
-    def _extract_code(self, text: str) -> str:
-        """
-        Extract code from markdown code blocks if present.
-
-        Args:
-            text: Raw text that might contain code
-
-        Returns:
-            Extracted code
-        """
-        # Check for markdown code blocks
-        if '```python' in text:
-            start = text.find('```python') + len('```python')
-            end = text.find('```', start)
-            if end != -1:
-                return text[start:end].strip()
-
-        if '```' in text:
-            start = text.find('```') + 3
-            end = text.find('```', start)
-            if end != -1:
-                return text[start:end].strip()
-
-        return text
-
-    def _build_globals(self, env: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Build restricted globals for safe execution.
-
-        Args:
-            env: User environment
-
-        Returns:
-            Safe globals dict
-        """
-        restricted_globals = safe_globals.copy()
-        restricted_globals.update(limited_builtins)
-        restricted_globals.update(utility_builtins)
-
-        # Add guards
-        restricted_globals['_iter_unpack_sequence_'] = guarded_iter_unpack_sequence
-        restricted_globals['_getattr_'] = safer_getattr
-        restricted_globals['_getitem_'] = lambda obj, index: obj[index]
-        restricted_globals['_getiter_'] = iter
-        restricted_globals['_print_'] = PrintCollector
-
-        # Add additional safe builtins
-        restricted_globals.update({
-            # Types
-            'len': len,
-            'str': str,
-            'int': int,
-            'float': float,
-            'bool': bool,
-            'list': list,
-            'dict': dict,
-            'tuple': tuple,
-            'set': set,
-            'frozenset': frozenset,
-            'bytes': bytes,
-            'bytearray': bytearray,
-
-            # Iteration
-            'range': range,
-            'enumerate': enumerate,
-            'zip': zip,
-            'map': map,
-            'filter': filter,
-            'reversed': reversed,
-            'iter': iter,
-            'next': next,
-
-            # Aggregation
-            'sorted': sorted,
-            'sum': sum,
-            'min': min,
-            'max': max,
-            'any': any,
-            'all': all,
-
-            # Math
-            'abs': abs,
-            'round': round,
-            'pow': pow,
-            'divmod': divmod,
-
-            # String/repr
-            'chr': chr,
-            'ord': ord,
-            'hex': hex,
-            'oct': oct,
-            'bin': bin,
-            'repr': repr,
-            'ascii': ascii,
-            'format': format,
-
-            # Type checking
-            'isinstance': isinstance,
-            'issubclass': issubclass,
-            'callable': callable,
-            'type': type,
-            'hasattr': hasattr,
-
-            # Constants
-            'True': True,
-            'False': False,
-            'None': None,
-        })
-
-        # Add safe standard library modules
-        # These are read-only and don't allow file/network access
-        import re
-        import json
-        import math
-        from datetime import datetime, timedelta
-        from collections import Counter, defaultdict
-
-        restricted_globals.update({
-            're': re,               # Regex (read-only)
-            'json': json,           # JSON parsing (read-only)
-            'math': math,           # Math functions
-            'datetime': datetime,   # Date parsing
-            'timedelta': timedelta, # Time deltas
-            'Counter': Counter,     # Counting helper
-            'defaultdict': defaultdict,  # Dict with defaults
-        })
-
-        return restricted_globals