recursive-llm-ts 2.0.11 → 3.0.1

package/go/test_simple.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+# Simple integration tests
+
+set -e
+
+echo "🧪 Simple RLM Integration Tests"
+echo "================================"
+echo ""
+
+if [ -z "$OPENAI_API_KEY" ]; then
+    echo "❌ Set OPENAI_API_KEY first"
+    exit 1
+fi
+
+# Test 1
+echo "Test 1: Count word occurrences"
+cat > /tmp/test1.json <<'JSON'
+{
+  "model": "gpt-4o-mini",
+  "query": "How many times does the word 'test' appear?",
+  "context": "This is a test. Another test here. Final test.",
+  "config": {
+    "max_iterations": 10
+  }
+}
+JSON
+
+echo "Running..."
+RESULT=$(cat /tmp/test1.json | OPENAI_API_KEY="$OPENAI_API_KEY" ./rlm)
+echo "✅ Test 1 Result:"
+echo "$RESULT" | jq -r '.result'
+echo "Stats:" $(echo "$RESULT" | jq '.stats')
+echo ""
+
+# Test 2
+echo "Test 2: Simple counting"
+cat > /tmp/test2.json <<'JSON'
+{
+  "model": "gpt-4o-mini",
+  "query": "How many words are in this text?",
+  "context": "One two three four five",
+  "config": {
+    "max_iterations": 10,
+    "temperature": 0.1
+  }
+}
+JSON
+
+echo "Running..."
+RESULT=$(cat /tmp/test2.json | OPENAI_API_KEY="$OPENAI_API_KEY" ./rlm)
+echo "✅ Test 2 Result:"
+echo "$RESULT" | jq -r '.result'
+echo "Stats:" $(echo "$RESULT" | jq '.stats')
+echo ""
+
+# Test 3
+echo "Test 3: Extract information"
+cat > /tmp/test3.json <<'JSON'
+{
+  "model": "gpt-4o-mini",
+  "query": "List all the numbers mentioned",
+  "context": "I have 5 apples, 10 oranges, and 3 bananas.",
+  "config": {
+    "max_iterations": 10
+  }
+}
+JSON
+
+echo "Running..."
+RESULT=$(cat /tmp/test3.json | OPENAI_API_KEY="$OPENAI_API_KEY" ./rlm)
+echo "✅ Test 3 Result:"
+echo "$RESULT" | jq -r '.result'
+echo "Stats:" $(echo "$RESULT" | jq '.stats')
+echo ""
+
+echo "================================"
+echo "✅ All tests passed!"
+rm -f /tmp/test*.json

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "recursive-llm-ts",
-  "version": "2.0.11",
+  "version": "3.0.1",
   "description": "TypeScript bridge for recursive-llm: Recursive Language Models for unbounded context processing",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist",
-    "recursive-llm/src",
-    "recursive-llm/pyproject.toml",
-    "scripts/install-python-deps.js"
+    "bin",
+    "go",
+    "scripts/build-go-binary.js"
   ],
   "scripts": {
     "build": "tsc",
-    "postinstall": "node scripts/install-python-deps.js",
+    "postinstall": "node scripts/build-go-binary.js",
     "prepublishOnly": "npm run build",
     "release": "./scripts/release.sh",
     "start": "ts-node test/test.ts",
@@ -36,10 +36,7 @@
     "url": "https://github.com/jbeck018/recursive-llm-ts/issues"
   },
   "homepage": "https://github.com/jbeck018/recursive-llm-ts#readme",
-  "dependencies": {
-    "bunpy": "^0.1.0",
-    "pythonia": "^1.2.6"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/node": "^20.11.19",
     "dotenv": "^16.4.5",

package/scripts/build-go-binary.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const repoRoot = path.join(__dirname, '..');
+const goRoot = path.join(repoRoot, 'go');
+const binDir = path.join(repoRoot, 'bin');
+const binaryName = process.platform === 'win32' ? 'rlm-go.exe' : 'rlm-go';
+const binaryPath = path.join(binDir, binaryName);
+
+function goAvailable() {
+  try {
+    execFileSync('go', ['version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (!fs.existsSync(goRoot)) {
+  console.warn('[recursive-llm-ts] Go source directory not found; skipping Go build');
+  process.exit(0);
+}
+
+if (!goAvailable()) {
+  console.warn('[recursive-llm-ts] Go is not installed; skipping Go binary build');
+  console.warn('[recursive-llm-ts] Install Go 1.21+ and rerun: node scripts/build-go-binary.js');
+  process.exit(0);
+}
+
+try {
+  fs.mkdirSync(binDir, { recursive: true });
+  // Build with optimization: -s removes symbol table, -w removes DWARF debug info
+  execFileSync('go', ['build', '-ldflags=-s -w', '-o', binaryPath, './cmd/rlm'], { stdio: 'inherit', cwd: goRoot });
+  console.log(`[recursive-llm-ts] ✓ Go binary built at ${binaryPath}`);
+} catch (error) {
+  console.warn('[recursive-llm-ts] Warning: Failed to build Go binary');
+  console.warn(error.message || error);
+  process.exit(0);
+}

package/recursive-llm/pyproject.toml

@@ -1,70 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "recursive-llm"
-version = "0.1.0"
-description = "Recursive Language Models for unbounded context processing"
-authors = [{name = "Grigori Gvadzabia"}]
-readme = "README.md"
-requires-python = ">=3.9"
-license = {text = "MIT"}
-keywords = ["llm", "ai", "nlp", "recursive", "language-models"]
-classifiers = [
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-]
-
-dependencies = [
-    "litellm>=1.0.0",
-    "RestrictedPython>=6.0",
-    "python-dotenv>=1.0.0",
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=7.0.0",
-    "pytest-asyncio>=0.21.0",
-    "pytest-cov>=4.0.0",
-    "black>=24.0.0",
-    "ruff>=0.1.0",
-    "mypy>=1.0.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/yourusername/recursive-llm"
-Documentation = "https://github.com/yourusername/recursive-llm"
-Repository = "https://github.com/yourusername/recursive-llm"
-Issues = "https://github.com/yourusername/recursive-llm/issues"
-
-[tool.setuptools.packages.find]
-where = ["src"]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-testpaths = ["tests"]
-python_files = ["test_*.py"]
-python_classes = ["Test*"]
-python_functions = ["test_*"]
-addopts = "-v"
-
-[tool.black]
-line-length = 100
-target-version = ['py39']
-
-[tool.ruff]
-line-length = 100
-target-version = "py39"
-
-[tool.mypy]
-python_version = "3.9"
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = true

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

@@ -1,14 +0,0 @@
-"""Recursive Language Models for unbounded context processing."""
-
-from .core import RLM, RLMError, MaxIterationsError, MaxDepthError
-from .repl import REPLError
-
-__version__ = "0.1.0"
-
-__all__ = [
-    "RLM",
-    "RLMError",
-    "MaxIterationsError",
-    "MaxDepthError",
-    "REPLError",
-]

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