recursive-llm-ts 1.0.3 → 1.0.5

package/README.md

@@ -87,6 +87,7 @@ interface RLMConfig {
   // Execution limits
   max_depth?: number;            // Maximum recursion depth (default: 5)
   max_iterations?: number;       // Maximum REPL iterations per call (default: 30)
+  pythonia_timeout?: number;     // Python bridge timeout in ms (default: 100000ms = 100s)
   
   // LiteLLM parameters - pass any additional parameters supported by LiteLLM
   api_version?: string;          // API version (e.g., for Azure)
@@ -174,6 +175,24 @@ const rlm = new RLM('openai/your-model', {
 });
 ```
 
+### Long-Running Processes
+
+For large documents or queue-based processing that may take longer than the default 100s timeout:
+
+```typescript
+const rlm = new RLM('gpt-4o-mini', {
+  max_iterations: 50,           // Allow more iterations for complex processing
+  pythonia_timeout: 600000,     // 10 minutes timeout for Python bridge
+  timeout: 300                  // 5 minutes timeout for LLM API calls
+});
+
+// Process very large document
+const result = await rlm.completion(
+  'Summarize all key points from this document',
+  veryLargeDocument
+);
+```
+
 ### Other Providers
 
 See the [LiteLLM documentation](https://docs.litellm.ai/docs/providers) for the complete list of supported providers and their configuration.

package/dist/rlm-bridge.d.ts

@@ -16,6 +16,7 @@ export interface RLMConfig {
     api_key?: string;
     max_depth?: number;
     max_iterations?: number;
+    pythonia_timeout?: number;
     [key: string]: any;
 }
 export declare class RLMBridge {

package/dist/rlm-bridge.js

@@ -41,6 +41,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RLMBridge = void 0;
 const pythonia_1 = require("pythonia");
@@ -67,11 +78,15 @@ class RLMBridge {
         return __awaiter(this, arguments, void 0, function* (model, query, context, rlmConfig = {}) {
             yield this.ensureRLMModule();
             try {
-                // Create RLM instance with config
+                // Extract pythonia timeout (default: 100000ms)
+                const pythoniaTimeout = rlmConfig.pythonia_timeout || 100000;
+                // Remove pythonia_timeout from config passed to Python
+                const { pythonia_timeout } = rlmConfig, pythonConfig = __rest(rlmConfig, ["pythonia_timeout"]);
+                // Create RLM instance with config, passing timeout to pythonia
                 const RLMClass = yield this.rlmModule.RLM;
-                const rlmInstance = yield RLMClass(model, rlmConfig);
-                // Call completion method
-                const result = yield rlmInstance.completion(query, context);
+                const rlmInstance = yield RLMClass(model, Object.assign(Object.assign({}, pythonConfig), { $timeout: pythoniaTimeout }));
+                // Call completion method with timeout
+                const result = yield rlmInstance.completion(query, context, { $timeout: pythoniaTimeout });
                 const stats = yield rlmInstance.stats;
                 // Convert Python stats dict to JS object
                 const statsObj = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recursive-llm-ts",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "TypeScript bridge for recursive-llm: Recursive Language Models for unbounded context processing",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,9 @@
     "dist",
     "recursive-llm/src",
     "recursive-llm/pyproject.toml",
-    "scripts/install-python-deps.js"
+    "scripts/install-python-deps.js",
+    "scripts/apply-patches.js",
+    "patches/core.py.patch"
   ],
   "scripts": {
     "build": "tsc",

package/patches/core.py.patch

@@ -0,0 +1,40 @@
+--- a/src/rlm/core.py
++++ b/src/rlm/core.py
+@@ -54,14 +54,31 @@ class RLM:
+             _current_depth: Internal current depth tracker
+             **llm_kwargs: Additional LiteLLM parameters
+         """
+-        self.model = model
+-        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
++        # 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.llm_kwargs = llm_kwargs
++        self.model = model
+ 
+         self.repl = REPLExecutor()

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

@@ -61,8 +61,8 @@ class RLM:
             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 = config.get('max_depth', max_depth)
-            self.max_iterations = config.get('max_iterations', max_iterations)
+            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'}

package/scripts/apply-patches.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const corePyPath = path.join(__dirname, '..', 'recursive-llm', 'src', 'rlm', 'core.py');
+const patchPath = path.join(__dirname, '..', 'patches', 'core.py.patch');
+
+// Check if core.py exists
+if (!fs.existsSync(corePyPath)) {
+  console.error('Error: core.py not found at', corePyPath);
+  process.exit(1);
+}
+
+// Check if patch exists
+if (!fs.existsSync(patchPath)) {
+  console.error('Error: patch file not found at', patchPath);
+  process.exit(1);
+}
+
+console.log('Applying patches to recursive-llm Python package...');
+
+// Check if patch is already applied by looking for the patch marker
+const coreContent = fs.readFileSync(corePyPath, 'utf8');
+if (coreContent.includes('# Patch for recursive-llm-ts bug where config is passed as 2nd positional arg')) {
+  console.log('✓ Patch already applied to core.py');
+  process.exit(0);
+}
+
+// Apply the patch
+const pythonPackagePath = path.join(__dirname, '..', 'recursive-llm');
+
+try {
+  // Try to apply patch
+  execSync(`patch -p1 -i "${patchPath}"`, {
+    cwd: pythonPackagePath,
+    stdio: 'inherit'
+  });
+  console.log('✓ Successfully applied core.py patch');
+} catch (error) {
+  console.error('Failed to apply patch using patch command.');
+  console.error('Attempting manual patch application...');
+  
+  // Fallback: manually apply the patch by replacing the constructor
+  try {
+    const updatedContent = coreContent.replace(
+      /(\s+)self\.model = model\n(\s+)self\.recursive_model = recursive_model or model\n(\s+)self\.api_base = api_base\n(\s+)self\.api_key = api_key\n(\s+)self\.max_depth = max_depth\n(\s+)self\.max_iterations = max_iterations\n(\s+)self\._current_depth = _current_depth\n(\s+)self\.llm_kwargs = llm_kwargs/,
+      `$1# Patch for recursive-llm-ts bug where config is passed as 2nd positional arg
+$1if isinstance(recursive_model, dict):
+$1    config = recursive_model
+$1    # Reset recursive_model default
+$1    self.recursive_model = config.get('recursive_model', model)
+$1    self.api_base = config.get('api_base', api_base)
+$1    self.api_key = config.get('api_key', api_key)
+$1    self.max_depth = int(config.get('max_depth', max_depth))
+$1    self.max_iterations = int(config.get('max_iterations', max_iterations))
+$1    
+$1    # Extract other llm kwargs
+$1    excluded = {'recursive_model', 'api_base', 'api_key', 'max_depth', 'max_iterations'}
+$1    self.llm_kwargs = {k: v for k, v in config.items() if k not in excluded}
+$1    # Merge with any actual kwargs passed
+$1    self.llm_kwargs.update(llm_kwargs)
+$1else:
+$1    self.recursive_model = recursive_model or model
+$1    self.api_base = api_base
+$1    self.api_key = api_key
+$1    self.max_depth = max_depth
+$1    self.max_iterations = max_iterations
+$1    self.llm_kwargs = llm_kwargs
+
+$1self._current_depth = _current_depth
+$1self.model = model`
+    );
+    
+    if (updatedContent === coreContent) {
+      console.error('Manual patch failed: pattern not found in core.py');
+      console.error('The file may have been updated upstream.');
+      console.error('Please manually apply the patch from patches/core.py.patch');
+      process.exit(1);
+    }
+    
+    fs.writeFileSync(corePyPath, updatedContent, 'utf8');
+    console.log('✓ Successfully applied patch manually');
+  } catch (manualError) {
+    console.error('Manual patch application failed:', manualError.message);
+    process.exit(1);
+  }
+}

package/scripts/install-python-deps.js

@@ -12,6 +12,14 @@ if (!fs.existsSync(pyprojectPath)) {
   process.exit(1);
 }
 
+// Apply patches first
+console.log('Applying patches to Python package...');
+try {
+  execSync('node "' + path.join(__dirname, 'apply-patches.js') + '"', { stdio: 'inherit' });
+} catch (error) {
+  console.error('Warning: Failed to apply patches. Continuing with installation...');
+}
+
 console.log('Installing Python dependencies for recursive-llm...');
 
 try {