ai-rlm 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Joe Hsu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,366 @@
+# RLM (Recursive Language Model) - TypeScript Implementation
+
+A TypeScript implementation of the RLM (Recursive Language Model) inference strategy using the Vercel AI SDK.
+
+Based on the paper "Recursive Language Models" by Zhang, Kraska, and Khattab (2025).
+
+## Overview
+
+RLM is an inference strategy where LLMs treat long contexts as part of an external environment rather than feeding them directly to the model. The LLM writes JavaScript code to programmatically examine, decompose, and recursively call sub-LLMs over snippets.
+
+### Key Features
+
+- **Iterative Code Execution**: The model writes JavaScript code, sees output, then writes more code
+- **Sub-LLM Queries**: Access to `llm_query()` and `llm_query_batched()` for semantic analysis
+- **Context Management**: Efficient handling of large contexts through chunking
+- **Sandboxed REPL**: JavaScript execution in a sandboxed `node:vm` context
+- **AI SDK Integration**: Works as an Agent or Tool with the Vercel AI SDK
+- **Multiple Usage Patterns**: Use as standalone agent or as a tool in larger workflows
+
+## Installation
+
+```bash
+npm install ai-rlm @ai-sdk/openai
+```
+
+The `model` and `subModel` settings accept any AI SDK `LanguageModel` — use any provider ([OpenAI](https://sdk.vercel.ai/providers/ai-sdk-providers/openai), [Anthropic](https://sdk.vercel.ai/providers/ai-sdk-providers/anthropic), [Google](https://sdk.vercel.ai/providers/ai-sdk-providers/google-generative-ai), etc.).
+
+## Usage
+
+### As Agent (Recommended)
+
+The **RLMAgent** class provides a clean, agent-based API that integrates seamlessly with the AI SDK:
+
+```typescript
+import { RLMAgent } from 'ai-rlm';
+import { openai } from '@ai-sdk/openai';
+
+// Create agent
+const agent = new RLMAgent({
+  model: openai('gpt-4.1'),              // Root agent model
+  subModel: openai('gpt-4.1-mini'),      // Sub-LLM model for queries
+  maxIterations: 20,                      // Max REPL iterations
+  maxLLMCalls: 50,                        // Max sub-LLM calls
+});
+
+// Process a context
+const context = `
+  The quick brown fox jumps over the lazy dog.
+  The magic number is 42.
+`;
+
+const query = 'What is the magic number?';
+
+const result = await agent.generate({
+  context,
+  query,
+});
+
+console.log('Answer:', result.text);
+console.log('Iterations:', result.iterations);
+console.log('LLM Calls:', result.llmCallCount);
+console.log('Steps:', result.steps); // Full trajectory
+```
+
+### As Tool
+
+Use **createRLMTool** to create an AI SDK-compatible tool for use with `generateText` or `ToolLoopAgent`:
+
+```typescript
+import { createRLMTool } from 'ai-rlm';
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+
+// Create the tool
+const rlmTool = createRLMTool({
+  model: openai('gpt-4.1'),
+  subModel: openai('gpt-4.1-mini'),
+});
+
+// Use in generateText
+const result = await generateText({
+  model: openai('gpt-4.1'),
+  tools: { analyzeLargeContext: rlmTool },
+  prompt: 'Analyze this large codebase for security vulnerabilities',
+});
+```
+
+### With ToolLoopAgent
+
+```typescript
+import { ToolLoopAgent } from 'ai';
+import { createRLMTool } from 'ai-rlm';
+import { openai } from '@ai-sdk/openai';
+
+const agent = new ToolLoopAgent({
+  model: openai('gpt-4.1'),
+  tools: {
+    analyzeLargeContext: createRLMTool({
+      model: openai('gpt-4.1'),
+      subModel: openai('gpt-4.1-mini'),
+    }),
+    // ... other tools
+  },
+});
+
+const result = await agent.generate({
+  prompt: 'Check this document for compliance issues',
+});
+```
+
+### Streaming Support
+
+```typescript
+const stream = await agent.stream({
+  context: largeDocument,
+  query: 'Analyze this',
+});
+
+// Read from the stream
+const reader = stream.textStream.getReader();
+while (true) {
+  const { done, value } = await reader.read();
+  if (done) break;
+  process.stdout.write(value);
+}
+```
+
+## How It Works
+
+The RLM agent writes JavaScript code to explore the context in an iterative loop:
+
+```javascript
+// First, explore the context
+console.log('Context length:', context.length);
+console.log('First 200 chars:', context.substring(0, 200));
+
+// Search for specific patterns
+const lines = context.split('\n');
+const targetLine = lines.find(line => line.includes('magic number'));
+console.log('Found:', targetLine);
+
+// Store result for later
+const answer = targetLine?.match(/magic number is (\d+)/)?.[1];
+
+// Submit answer
+FINAL_VAR(answer)
+```
+
+1. **Context Loading**: The context is loaded into a sandboxed JavaScript REPL environment
+2. **Iterative Reasoning**: The root LLM writes JavaScript code to explore the context
+3. **Code Execution**: Code is executed in a `node:vm` sandbox with a 30s timeout
+4. **Sub-LLM Queries**: For semantic analysis, `llm_query()` delegates to a sub-model
+5. **Result Accumulation**: The model iterates until it finds an answer
+6. **Final Answer**: The model submits an answer using `FINAL(answer)` or `FINAL_VAR(variable_name)`
+
+### System Prompt
+
+The RLM system prompt instructs the model to:
+- EXPLORE FIRST - Look at data before processing
+- ITERATE - Write small code snippets, observe outputs
+- VERIFY BEFORE SUBMITTING - Check results are correct
+- USE llm_query FOR SEMANTICS - Code finds WHERE; LLM understands WHAT
+- CHUNK SMARTLY - Feed substantial chunks to sub-LLMs (~500K chars)
+
+## REPL Sandbox
+
+The JavaScript REPL runs code in a `node:vm` sandboxed context:
+
+### Available in the Sandbox:
+
+- **`context`**: The input context (string or object)
+- **`console.log()` / `console.error()`**: Output logging
+- **`llm_query(prompt)`**: Query a sub-LLM for semantic analysis
+- **`llm_query_batched(prompts)`**: Query multiple sub-LLMs
+- **`FINAL(answer)`**: Submit final answer directly
+- **`FINAL_VAR(varName)`**: Submit a variable from the REPL
+- **Standard JavaScript**: All ES6+ features, Array methods, String methods, Math, JSON, etc.
+
+### Security Features:
+
+- 30-second timeout on code execution
+- No access to Node.js built-in modules or file system
+- No network access
+- Sandboxed console output capture
+
+## API Reference
+
+### RLMAgent
+
+The primary class for using RLM as an agent.
+
+#### `constructor(settings: RLMAgentSettings)`
+
+```typescript
+import type { LanguageModel } from 'ai';
+
+interface RLMAgentSettings {
+  model: LanguageModel;     // Required: Root agent model
+  subModel?: LanguageModel; // Optional: Sub-LLM model (defaults to model)
+  maxIterations?: number;   // Max REPL iterations (default: 20)
+  maxLLMCalls?: number;     // Max sub-LLM calls (default: 50)
+  maxOutputChars?: number;  // Max REPL output chars (default: 100000)
+  verbose?: boolean;        // Enable verbose logging (default: false)
+}
+```
+
+#### `async generate(options): Promise<RLMGenerateResult>`
+
+Generate an answer by iteratively analyzing the context.
+
+**Parameters:**
+```typescript
+interface RLMAgentCallParameters {
+  context: RLMContext;                    // The large context to analyze
+  query: string;                          // The question or task
+  abortSignal?: AbortSignal;              // Optional abort signal
+  timeout?: number;                       // Optional timeout in ms
+  onStepFinish?: (step: REPLStep) => void; // Callback for each step
+}
+```
+
+**Returns:**
+```typescript
+interface RLMGenerateResult {
+  text: string;             // The generated answer
+  steps: REPLStep[];        // Array of REPL steps taken
+  llmCallCount: number;     // Total LLM calls made
+  iterations: number;       // Total iterations performed
+}
+
+interface REPLStep {
+  iteration: number;
+  reasoning: string;        // The model's reasoning before code
+  code: string;             // JavaScript code executed
+  output: string;           // Console output and results
+}
+```
+
+#### `async stream(options): Promise<RLMStreamResult>`
+
+Stream the answer generation process.
+
+**Returns:**
+```typescript
+interface RLMStreamResult extends RLMGenerateResult {
+  textStream: ReadableStream<string>;  // Readable stream of text
+}
+```
+
+### createRLMTool
+
+Factory function to create RLM as an AI SDK-compatible tool.
+
+#### `createRLMTool(config?: RLMToolConfig)`
+
+```typescript
+import type { LanguageModel } from 'ai';
+
+function createRLMTool(config?: {
+  model?: LanguageModel;    // Root agent model
+  subModel?: LanguageModel; // Sub-LLM model
+  maxIterations?: number;   // Max iterations (default: 20)
+  maxLLMCalls?: number;     // Max LLM calls (default: 50)
+  maxOutputChars?: number;  // Max output chars (default: 100000)
+}): Tool
+```
+
+**Tool Input Schema:**
+```typescript
+{
+  context: string | string[] | Record<string, unknown>;
+  query: string;
+  maxIterations?: number;   // Optional override
+  maxLLMCalls?: number;     // Optional override
+}
+```
+
+**Tool Output:**
+```typescript
+{
+  answer: string;           // The generated answer
+  iterations: number;       // Number of iterations
+  stepsTaken: number;       // Number of steps executed
+}
+```
+
+### RLMContext
+
+Context can be any of these formats:
+```typescript
+type RLMContext = string | string[] | Record<string, unknown>;
+```
+
+- `string`: Raw text document
+- `string[]`: Array of lines or documents
+- `Record<string, unknown>`: JSON/structured data
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      RLMAgent Class                         │
+├─────────────────────────────────────────────────────────────┤
+│  ┌───────────────────────────────────────────────────────┐  │
+│  │              REPL Environment (node:vm)               │  │
+│  │  - Sandboxed JavaScript execution                     │  │
+│  │  - llm_query() for sub-LLM semantic analysis          │  │
+│  │  - 30s timeout protection                             │  │
+│  └───────────────────────────────────────────────────────┘  │
+│                                                             │
+│  ┌───────────────────────────────────────────────────────┐  │
+│  │              generate() Method                        │  │
+│  │  1. Generate reasoning + JS code                      │  │
+│  │  2. Execute in sandboxed context                      │  │
+│  │  3. Process llm_query markers → real LLM calls        │  │
+│  │  4. Check for FINAL() answer                          │  │
+│  │  5. Repeat or return answer                           │  │
+│  └───────────────────────────────────────────────────────┘  │
+│                                                             │
+│  ┌───────────────────────────────────────────────────────┐  │
+│  │              stream() Method                          │  │
+│  │  - Same as generate() with streaming                  │  │
+│  │  - Returns ReadableStream for real-time output        │  │
+│  └───────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              │ createRLMTool()
+                              ▼
+                    ┌──────────────────────┐
+                    │    AI SDK Tool        │
+                    │ - Tool interface      │
+                    │ - Input validation    │
+                    │ - Auto-execution      │
+                    └──────────────────────┘
+```
+
+## Examples
+
+Run the examples:
+
+```bash
+# Basic agent examples
+bun run examples/basic-usage.ts
+
+# Tool integration examples
+bun run examples/tool-usage.ts
+
+# Individual examples
+bun run -e "import { example1SimpleTextSearch } from './examples/basic-usage.ts'; example1SimpleTextSearch()"
+```
+
+### Example Files
+
+- **`examples/basic-usage.ts`**: Agent API examples (generate, stream, callbacks)
+- **`examples/tool-usage.ts`**: Tool API examples (with generateText, ToolLoopAgent)
+- **`examples/document-comparison.ts`**: Document diffing example
+- **`examples/data-transformation.ts`**: Data extraction and transformation
+
+## License
+
+MIT
+
+## References
+
+- Paper: "Recursive Language Models" (Zhang, Kraska, Khattab, 2025)
+- AI SDK Documentation: https://sdk.vercel.ai/docs

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AI RLM - Recursive Language Model for the Vercel AI SDK
+ *
+ * @module ai-rlm
+ * @description Process long contexts through iterative code execution and sub-LLM queries
+ */
+export { RLMAgent } from "./rlm.js";
+export type { RLMAgentSettings, RLMAgentCallParameters, REPLStep, RLMGenerateResult, RLMStreamResult, RLMResult, RLMContext, } from "./rlm.js";
+export { createRLMTool } from "./rlm-tool.js";
+export type { RLMToolConfig } from "./rlm-tool.js";
+export { RLMAgent as default } from "./rlm.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,QAAQ,EACR,iBAAiB,EACjB,eAAe,EACf,SAAS,EACT,UAAU,GACX,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * AI RLM - Recursive Language Model for the Vercel AI SDK
+ *
+ * @module ai-rlm
+ * @description Process long contexts through iterative code execution and sub-LLM queries
+ */
+// Main exports
+export { RLMAgent } from "./rlm.js";
+// Tool exports
+export { createRLMTool } from "./rlm-tool.js";
+// Default export
+export { RLMAgent as default } from "./rlm.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAe;AACf,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAWpC,eAAe;AACf,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C,iBAAiB;AACjB,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC"}

package/dist/rlm-tool.d.ts

@@ -0,0 +1,128 @@
+/**
+ * RLM Tool - Tool Factory for Recursive Language Model
+ *
+ * This module provides a factory function to create RLM tools that can be used
+ * with the Vercel AI SDK's generateText, ToolLoopAgent, or any tool-compatible API.
+ */
+import { type LanguageModel } from "ai";
+import { type RLMAgentSettings } from "./rlm.js";
+/**
+ * Configuration options for the RLM tool
+ */
+export interface RLMToolConfig extends Partial<RLMAgentSettings> {
+    /** Model for the root agent */
+    model: LanguageModel;
+    /** Model for sub-LLM queries (defaults to model) */
+    subModel: LanguageModel;
+    /** Maximum iterations for the REPL loop (default: 20) */
+    maxIterations?: number;
+    /** Maximum sub-LLM calls per execution (default: 50) */
+    maxLLMCalls?: number;
+    /** Maximum characters in REPL output (default: 100000) */
+    maxOutputChars?: number;
+}
+/**
+ * Create an RLM tool for use with AI SDK functions.
+ *
+ * This tool allows models to analyze large contexts iteratively using JavaScript
+ * code execution and sub-LLM queries. It's particularly useful for:
+ * - Searching through large documents
+ * - Analyzing datasets that exceed context limits
+ * - Extracting structured information from unstructured data
+ * - Performing complex multi-step analysis
+ *
+ * @example
+ * ```typescript
+ * import { createRLMTool } from './rlm-tool.js';
+ * import { generateText } from 'ai';
+ *
+ * const rlmTool = createRLMTool({
+ *   model: 'gpt-4.1',
+ *   subModel: 'gpt-4.1-mini',
+ * });
+ *
+ * const result = await generateText({
+ *   model: 'gpt-4.1',
+ *   tools: { analyzeLargeContext: rlmTool },
+ *   prompt: 'Find all security issues in this codebase',
+ * });
+ * ```
+ */
+export declare function createRLMTool(config: RLMToolConfig): import("ai").Tool<{
+    context: string | string[] | Record<string, unknown>;
+    query: string;
+    maxIterations?: number | undefined;
+    maxLLMCalls?: number | undefined;
+}, {
+    answer: string;
+    iterations: number;
+    stepsTaken: number;
+}>;
+/**
+ * Create a pre-configured RLM tool for specific use cases.
+ *
+ * @example
+ * ```typescript
+ * // Create a tool optimized for code analysis
+ * const codeAnalyzer = createRLMTool({
+ *   model: 'gpt-4.1',
+ *   subModel: 'gpt-4.1-mini',
+ *   maxIterations: 30,
+ *   maxLLMCalls: 50,
+ * });
+ * ```
+ */
+export declare function createRLMToolForCodeAnalysis(config: RLMToolConfig): import("ai").Tool<{
+    context: string | string[] | Record<string, unknown>;
+    query: string;
+    maxIterations?: number | undefined;
+    maxLLMCalls?: number | undefined;
+}, {
+    answer: string;
+    iterations: number;
+    stepsTaken: number;
+}>;
+/**
+ * Create a pre-configured RLM tool optimized for log analysis.
+ *
+ * @example
+ * ```typescript
+ * const logAnalyzer = createRLMToolForLogAnalysis({
+ *   model: 'gpt-4.1',
+ *   maxIterations: 25,
+ * });
+ * ```
+ */
+export declare function createRLMToolForLogAnalysis(config: RLMToolConfig): import("ai").Tool<{
+    context: string | string[] | Record<string, unknown>;
+    query: string;
+    maxIterations?: number | undefined;
+    maxLLMCalls?: number | undefined;
+}, {
+    answer: string;
+    iterations: number;
+    stepsTaken: number;
+}>;
+/**
+ * Create a pre-configured RLM tool optimized for document search.
+ *
+ * @example
+ * ```typescript
+ * const documentSearcher = createRLMToolForDocumentSearch({
+ *   model: 'gpt-4.1',
+ *   maxIterations: 20,
+ * });
+ * ```
+ */
+export declare function createRLMToolForDocumentSearch(config: RLMToolConfig): import("ai").Tool<{
+    context: string | string[] | Record<string, unknown>;
+    query: string;
+    maxIterations?: number | undefined;
+    maxLLMCalls?: number | undefined;
+}, {
+    answer: string;
+    iterations: number;
+    stepsTaken: number;
+}>;
+export default createRLMTool;
+//# sourceMappingURL=rlm-tool.d.ts.map

package/dist/rlm-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rlm-tool.d.ts","sourceRoot":"","sources":["../src/rlm-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAQ,KAAK,aAAa,EAAE,MAAM,IAAI,CAAC;AAE9C,OAAO,EAAY,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,OAAO,CAAC,gBAAgB,CAAC;IAC9D,+BAA+B;IAC/B,KAAK,EAAE,aAAa,CAAC;IACrB,oDAAoD;IACpD,QAAQ,EAAE,aAAa,CAAC;IACxB,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa;;;;;;;;;GA6ElD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,aAAa;;;;;;;;;GAQjE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,aAAa;;;;;;;;;GAQhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,aAAa;;;;;;;;;GAQnE;AAED,eAAe,aAAa,CAAC"}

package/dist/rlm-tool.js

@@ -0,0 +1,167 @@
+/**
+ * RLM Tool - Tool Factory for Recursive Language Model
+ *
+ * This module provides a factory function to create RLM tools that can be used
+ * with the Vercel AI SDK's generateText, ToolLoopAgent, or any tool-compatible API.
+ */
+import { tool } from "ai";
+import { z } from "zod";
+import { RLMAgent } from "./rlm.js";
+/**
+ * Create an RLM tool for use with AI SDK functions.
+ *
+ * This tool allows models to analyze large contexts iteratively using JavaScript
+ * code execution and sub-LLM queries. It's particularly useful for:
+ * - Searching through large documents
+ * - Analyzing datasets that exceed context limits
+ * - Extracting structured information from unstructured data
+ * - Performing complex multi-step analysis
+ *
+ * @example
+ * ```typescript
+ * import { createRLMTool } from './rlm-tool.js';
+ * import { generateText } from 'ai';
+ *
+ * const rlmTool = createRLMTool({
+ *   model: 'gpt-4.1',
+ *   subModel: 'gpt-4.1-mini',
+ * });
+ *
+ * const result = await generateText({
+ *   model: 'gpt-4.1',
+ *   tools: { analyzeLargeContext: rlmTool },
+ *   prompt: 'Find all security issues in this codebase',
+ * });
+ * ```
+ */
+export function createRLMTool(config) {
+    return tool({
+        description: `Analyze large contexts iteratively using JavaScript code execution.
+
+Use this tool when you need to:
+- Search through or analyze documents/datasets too large for direct processing
+- Extract structured information from unstructured text
+- Perform complex multi-step analysis requiring code execution
+- Answer questions about large codebases, logs, or datasets
+
+The tool will:
+1. Write JavaScript code to explore the context
+2. Execute the code in a secure sandbox (vm2)
+3. Use sub-LLM calls for semantic understanding when needed
+4. Iterate until it finds the answer
+
+Provide the context (string, array of strings, or JSON object) and your query/question.`,
+        inputSchema: z.object({
+            context: z
+                .union([
+                z.string().describe("Text document or content to analyze"),
+                z.array(z.string()).describe("Array of text lines or documents"),
+                z.record(z.unknown()).describe("JSON object or structured data"),
+            ])
+                .describe("The large context, document, or dataset to analyze"),
+            query: z
+                .string()
+                .describe("The specific question, task, or instruction to perform on the context. Be clear and specific."),
+            maxIterations: z
+                .number()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("Maximum number of REPL iterations (default: 20)"),
+            maxLLMCalls: z
+                .number()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe("Maximum sub-LLM calls allowed (default: 50)"),
+        }),
+        execute: async ({ context, query, maxIterations, maxLLMCalls }, { abortSignal }) => {
+            // Create RLMAgent with merged config
+            const agent = new RLMAgent({
+                model: config.model ?? "gpt-4.1",
+                subModel: config.subModel,
+                maxIterations: maxIterations ?? config.maxIterations ?? 20,
+                maxLLMCalls: maxLLMCalls ?? config.maxLLMCalls ?? 50,
+                maxOutputChars: config.maxOutputChars ?? 100000,
+                verbose: false,
+            });
+            // Execute the analysis
+            const result = await agent.generate({
+                context,
+                query,
+                abortSignal,
+            });
+            // Return just the essential information
+            return {
+                answer: result.text,
+                iterations: result.iterations,
+                stepsTaken: result.steps.length,
+            };
+        },
+    });
+}
+/**
+ * Create a pre-configured RLM tool for specific use cases.
+ *
+ * @example
+ * ```typescript
+ * // Create a tool optimized for code analysis
+ * const codeAnalyzer = createRLMTool({
+ *   model: 'gpt-4.1',
+ *   subModel: 'gpt-4.1-mini',
+ *   maxIterations: 30,
+ *   maxLLMCalls: 50,
+ * });
+ * ```
+ */
+export function createRLMToolForCodeAnalysis(config) {
+    return createRLMTool({
+        model: config.model,
+        subModel: config.subModel,
+        maxIterations: config.maxIterations ?? 30,
+        maxLLMCalls: config.maxLLMCalls ?? 50,
+        maxOutputChars: config.maxOutputChars ?? 100000,
+    });
+}
+/**
+ * Create a pre-configured RLM tool optimized for log analysis.
+ *
+ * @example
+ * ```typescript
+ * const logAnalyzer = createRLMToolForLogAnalysis({
+ *   model: 'gpt-4.1',
+ *   maxIterations: 25,
+ * });
+ * ```
+ */
+export function createRLMToolForLogAnalysis(config) {
+    return createRLMTool({
+        model: config.model ?? "gpt-4.1",
+        subModel: config.subModel ?? "gpt-4.1-mini",
+        maxIterations: config.maxIterations ?? 25,
+        maxLLMCalls: config.maxLLMCalls ?? 30,
+        maxOutputChars: config.maxOutputChars ?? 100000,
+    });
+}
+/**
+ * Create a pre-configured RLM tool optimized for document search.
+ *
+ * @example
+ * ```typescript
+ * const documentSearcher = createRLMToolForDocumentSearch({
+ *   model: 'gpt-4.1',
+ *   maxIterations: 20,
+ * });
+ * ```
+ */
+export function createRLMToolForDocumentSearch(config) {
+    return createRLMTool({
+        model: config.model ?? "gpt-4.1",
+        subModel: config.subModel ?? "gpt-4.1-mini",
+        maxIterations: config.maxIterations ?? 20,
+        maxLLMCalls: config.maxLLMCalls ?? 20,
+        maxOutputChars: config.maxOutputChars ?? 100000,
+    });
+}
+export default createRLMTool;
+//# sourceMappingURL=rlm-tool.js.map

package/dist/rlm-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rlm-tool.js","sourceRoot":"","sources":["../src/rlm-tool.ts"],"names":[],"mappings":"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"}

package/dist/rlm.d.ts

@@ -0,0 +1,99 @@
+/**
+ * RLM (Recursive Language Model) - TypeScript Implementation
+ *
+ * Based on the paper "Recursive Language Models" (Zhang, Kraska, Khattab, 2025)
+ * Uses the Vercel AI SDK for the implementation.
+ *
+ * REPL Environment: JavaScript with node:vm sandbox
+ */
+import type { LanguageModel } from "ai";
+/**
+ * Settings for RLMAgent
+ */
+export interface RLMAgentSettings {
+    /** Model for the root agent */
+    model: LanguageModel;
+    /** Model for sub-LLM queries (defaults to model) */
+    subModel?: LanguageModel;
+    /** Maximum iterations for the REPL loop (default: 20) */
+    maxIterations?: number;
+    /** Maximum sub-LLM calls per execution (default: 50) */
+    maxLLMCalls?: number;
+    /** Maximum characters in REPL output (default: 100000) */
+    maxOutputChars?: number;
+    /** Enable verbose logging (default: false) */
+    verbose?: boolean;
+}
+/**
+ * Parameters for RLMAgent.generate() and RLMAgent.stream()
+ */
+export interface RLMAgentCallParameters {
+    /** The large context, document, or dataset to analyze */
+    context: RLMContext;
+    /** The specific question or task to perform on the context */
+    query: string;
+    /** Optional abort signal */
+    abortSignal?: AbortSignal;
+    /** Optional timeout in milliseconds */
+    timeout?: number;
+    /** Callback for each step completion */
+    onStepFinish?: (step: REPLStep) => void | Promise<void>;
+}
+/**
+ * A single step in the REPL trajectory
+ */
+export interface REPLStep {
+    iteration: number;
+    reasoning: string;
+    code: string;
+    output: string;
+}
+/**
+ * Result from RLMAgent.generate()
+ */
+export interface RLMGenerateResult {
+    /** The generated answer text */
+    text: string;
+    /** Array of REPL steps taken during generation */
+    steps: REPLStep[];
+    /** Total number of LLM calls made */
+    llmCallCount: number;
+    /** Total iterations performed */
+    iterations: number;
+}
+/**
+ * Result from RLMAgent.stream() - extends generate result with streaming capabilities
+ */
+export interface RLMStreamResult extends RLMGenerateResult {
+    /** Readable stream of text chunks */
+    textStream: ReadableStream<string>;
+}
+/**
+ * @deprecated Use the new RLMAgent API instead. This interface is kept for backward compatibility.
+ */
+export interface RLMResult {
+    answer: string;
+    trajectory: REPLStep[];
+    llmCallCount: number;
+    iterations: number;
+}
+/**
+ * Context can be a string, array of strings, or structured data
+ */
+export type RLMContext = string | string[] | Record<string, unknown>;
+export declare class RLMAgent {
+    private settings;
+    constructor(settings: RLMAgentSettings);
+    /**
+     * Generate an answer by iteratively analyzing the context.
+     * This is the primary method for using RLMAgent.
+     */
+    generate({ context, query, abortSignal, timeout, onStepFinish, }: RLMAgentCallParameters): Promise<RLMGenerateResult>;
+    /**
+     * Stream the answer generation process.
+     * Each step is yielded as it's completed.
+     */
+    stream({ context, query, abortSignal, timeout, onStepFinish, }: RLMAgentCallParameters): Promise<RLMStreamResult>;
+}
+export default RLMAgent;
+//# sourceMappingURL=rlm.d.ts.map

package/dist/rlm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rlm.d.ts","sourceRoot":"","sources":["../src/rlm.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,IAAI,CAAC;AAGtD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,KAAK,EAAE,aAAa,CAAC;IACrB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,yDAAyD;IACzD,OAAO,EAAE,UAAU,CAAC;IACpB,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;IACxD,qCAAqC;IACrC,UAAU,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAyPrE,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAA6B;gBAEjC,QAAQ,EAAE,gBAAgB;IAWtC;;;OAGG;IACG,QAAQ,CAAC,EACb,OAAO,EACP,KAAK,EACL,WAAW,EACX,OAAO,EACP,YAAY,GACb,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA6MtD;;;OAGG;IACG,MAAM,CAAC,EACX,OAAO,EACP,KAAK,EACL,WAAW,EACX,OAAO,EACP,YAAY,GACb,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC;CAwBrD;AAED,eAAe,QAAQ,CAAC"}

package/dist/rlm.js

@@ -0,0 +1,406 @@
+/**
+ * RLM (Recursive Language Model) - TypeScript Implementation
+ *
+ * Based on the paper "Recursive Language Models" (Zhang, Kraska, Khattab, 2025)
+ * Uses the Vercel AI SDK for the implementation.
+ *
+ * REPL Environment: JavaScript with node:vm sandbox
+ */
+import { generateText } from "ai";
+import * as vm from "node:vm";
+/**
+ * Sandbox environment for executing JavaScript code safely
+ * Uses node:vm (Bun/Node)
+ */
+class REPLEnvironment {
+    vmContext;
+    llmCallCount;
+    maxLLMCalls;
+    subModel;
+    contextLoaded = false;
+    consoleOutput = [];
+    timeout;
+    constructor(subModel, maxLLMCalls, timeout = 30000) {
+        this.llmCallCount = 0;
+        this.maxLLMCalls = maxLLMCalls;
+        this.subModel = subModel;
+        this.timeout = timeout;
+    }
+    /**
+     * Load context into the REPL environment
+     */
+    loadContext(context) {
+        if (this.contextLoaded) {
+            throw new Error("Context already loaded");
+        }
+        let contextData;
+        if (typeof context === "string") {
+            contextData = context;
+        }
+        else if (Array.isArray(context)) {
+            contextData = context.join("\n");
+        }
+        else {
+            contextData = context;
+        }
+        // Create sandbox with all necessary functions
+        const sandbox = {
+            console: {
+                log: (...args) => {
+                    this.consoleOutput.push(args.map((a) => String(a)).join(" "));
+                },
+                error: (...args) => {
+                    this.consoleOutput.push("ERROR: " + args.map((a) => String(a)).join(" "));
+                },
+            },
+            context: contextData,
+            llm_query: (prompt) => {
+                return `<<<LLM_QUERY_START>>>\n${prompt}\n<<<LLM_QUERY_END>>>`;
+            },
+            llm_query_batched: (prompts) => {
+                return prompts.map((p) => `<<<LLM_QUERY_START>>>\n${p}\n<<<LLM_QUERY_END>>>`);
+            },
+            FINAL: (answer) => {
+                return { type: "final", value: answer };
+            },
+            FINAL_VAR: (varName) => {
+                return { type: "final_var", value: varName };
+            },
+        };
+        this.vmContext = vm.createContext(sandbox);
+        this.contextLoaded = true;
+    }
+    /**
+     * Query a sub-LLM
+     */
+    async llmQuery(prompt) {
+        if (this.llmCallCount >= this.maxLLMCalls) {
+            throw new Error(`LLM call limit exceeded: ${this.llmCallCount}/${this.maxLLMCalls}`);
+        }
+        this.llmCallCount++;
+        const result = await generateText({
+            model: this.subModel,
+            prompt: prompt,
+        });
+        return result.text;
+    }
+    /**
+     * Execute JavaScript code in the sandbox with timeout protection
+     */
+    executeJavaScript(code) {
+        this.consoleOutput = [];
+        try {
+            let result;
+            const script = new vm.Script(code);
+            if (this.vmContext) {
+                result = script.runInContext(this.vmContext, { timeout: this.timeout });
+            }
+            const stdout = this.consoleOutput.join("\n");
+            return {
+                stdout,
+                stderr: "",
+                result: result !== undefined ? result : undefined,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return {
+                    stdout: this.consoleOutput.join("\n"),
+                    stderr: error.message,
+                    error: error.message,
+                };
+            }
+            return {
+                stdout: this.consoleOutput.join("\n"),
+                stderr: "Unknown error",
+                error: "Unknown error",
+            };
+        }
+    }
+    /**
+     * Get a variable value from the VM
+     */
+    getVariable(name) {
+        try {
+            if (this.vmContext) {
+                const script = new vm.Script(name);
+                return script.runInContext(this.vmContext, { timeout: 1000 });
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get current LLM call count
+     */
+    getLLMCallCount() {
+        return this.llmCallCount;
+    }
+    /**
+     * Clean up
+     */
+    cleanup() {
+        this.consoleOutput = [];
+        this.vmContext = undefined;
+    }
+}
+function extractCodeBlocks(text) {
+    const codeBlockRegex = /```(?:javascript|js)?\s*\n([\s\S]*?)\n```/g;
+    const blocks = [];
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        const code = match[1];
+        if (code) {
+            blocks.push(code.trim());
+        }
+    }
+    return blocks;
+}
+function extractFinalAnswer(text) {
+    const finalVarMatch = text.match(/FINAL_VAR\s*\(\s*["']?([^"')\s]+)["']?\s*\)/i);
+    if (finalVarMatch) {
+        const content = finalVarMatch[1];
+        if (content) {
+            return { type: "variable", content };
+        }
+    }
+    const finalMatch = text.match(/FINAL\s*\(\s*["']?([^"')]+)["']?\s*\)/i);
+    if (finalMatch) {
+        const content = finalMatch[1];
+        if (content) {
+            return { type: "direct", content };
+        }
+    }
+    return null;
+}
+// ============================================================================
+// System Prompts
+// ============================================================================
+const RLM_SYSTEM_PROMPT = `You are a Recursive Language Model (RLM) agent. You have access to a JavaScript REPL environment to analyze and process large contexts iteratively.
+
+Your task is to answer queries by:
+1. EXPLORING the context through code execution
+2. ITERATING with small code snippets to understand the data
+3. USING llm_query() for semantic analysis when needed
+4. SUBMITTING your final answer when complete
+
+Available in the REPL environment:
+- context variable: Contains the input context (loaded as string or object)
+- llm_query(prompt): Query a sub-LLM (~500K char capacity) for semantic analysis
+- llm_query_batched(prompts): Query multiple prompts concurrently (returns array)
+- console.log(): ALWAYS log to see results
+- Standard JavaScript: JSON, Array methods, String methods, Math, etc.
+
+IMPORTANT GUIDELINES:
+1. EXPLORE FIRST - Look at your data before processing it. Log samples, check types/lengths, understand the structure.
+2. ITERATE - Write small code snippets, observe outputs, then decide next steps. State persists between iterations.
+3. VERIFY BEFORE SUBMITTING - If results seem wrong, reconsider your approach.
+4. USE llm_query FOR SEMANTICS - Code finds WHERE things are; llm_query understands WHAT things mean.
+5. CHUNK SMARTLY - The sub-LLM can handle ~500K characters. Feed it substantial chunks, not tiny pieces.
+
+When done, provide your final answer using:
+- FINAL(your_answer) - to submit directly
+- FINAL_VAR(variable_name) - to submit a variable from the REPL
+
+Think step-by-step and show your reasoning before each code block.`;
+export class RLMAgent {
+    settings;
+    constructor(settings) {
+        this.settings = {
+            model: settings.model,
+            subModel: settings.subModel ?? settings.model,
+            maxIterations: settings.maxIterations ?? 20,
+            maxLLMCalls: settings.maxLLMCalls ?? 50,
+            maxOutputChars: settings.maxOutputChars ?? 100000,
+            verbose: settings.verbose ?? false,
+        };
+    }
+    /**
+     * Generate an answer by iteratively analyzing the context.
+     * This is the primary method for using RLMAgent.
+     */
+    async generate({ context, query, abortSignal, timeout, onStepFinish, }) {
+        const repl = new REPLEnvironment(this.settings.subModel, this.settings.maxLLMCalls, timeout ?? 30000);
+        const steps = [];
+        let mainLLMCallCount = 0; // Track main agent LLM calls
+        try {
+            repl.loadContext(context);
+            const messages = [
+                { role: "system", content: RLM_SYSTEM_PROMPT },
+                {
+                    role: "user",
+                    content: `Context loaded. Answer the following query: "${query}"`,
+                },
+            ];
+            for (let iteration = 0; iteration < this.settings.maxIterations; iteration++) {
+                if (this.settings.verbose) {
+                    console.log(`\n=== Iteration ${iteration + 1}/${this.settings.maxIterations} ===`);
+                }
+                // Generate next action
+                const result = await generateText({
+                    model: this.settings.model,
+                    messages,
+                    abortSignal,
+                });
+                mainLLMCallCount++; // Track main LLM call
+                const response = result.text;
+                if (this.settings.verbose) {
+                    console.log("LLM Response:", response.substring(0, 500));
+                }
+                // Check for final answer
+                const finalAnswer = extractFinalAnswer(response);
+                if (finalAnswer && finalAnswer.content) {
+                    let answer;
+                    if (finalAnswer.type === "direct") {
+                        answer = finalAnswer.content;
+                    }
+                    else {
+                        const varValue = repl.getVariable(finalAnswer.content);
+                        answer =
+                            varValue !== undefined
+                                ? String(varValue)
+                                : `[Variable ${finalAnswer.content} not found]`;
+                    }
+                    // Return RLMGenerateResult
+                    return {
+                        text: answer,
+                        steps: steps,
+                        llmCallCount: mainLLMCallCount + repl.getLLMCallCount(),
+                        iterations: iteration + 1,
+                    };
+                }
+                // Execute code
+                const codeBlocks = extractCodeBlocks(response);
+                if (codeBlocks.length > 0 && codeBlocks[0]) {
+                    const code = codeBlocks[0];
+                    const executionResult = repl.executeJavaScript(code);
+                    // Process llm_query calls
+                    let processedOutput = executionResult.stdout;
+                    const llmQueryRegex = /<<<LLM_QUERY_START>>>\n([\s\S]*?)\n<<<LLM_QUERY_END>>>/g;
+                    let llmMatch;
+                    while ((llmMatch = llmQueryRegex.exec(executionResult.stdout)) !== null) {
+                        const prompt = llmMatch[1];
+                        if (prompt) {
+                            try {
+                                const llmResult = await repl.llmQuery(prompt);
+                                processedOutput = processedOutput.replace(llmMatch[0], `\n[LLM Result]: ${llmResult}\n`);
+                            }
+                            catch (e) {
+                                const errorMessage = e instanceof Error ? e.message : String(e);
+                                processedOutput = processedOutput.replace(llmMatch[0], `\n[LLM Error]: ${errorMessage}\n`);
+                            }
+                        }
+                    }
+                    // Build full output
+                    let fullOutput = processedOutput;
+                    if (executionResult.result !== undefined &&
+                        executionResult.result !== null) {
+                        fullOutput += `\n[Return value]: ${JSON.stringify(executionResult.result)}`;
+                    }
+                    if (executionResult.error) {
+                        fullOutput += `\n[Error]: ${executionResult.error}`;
+                    }
+                    // Truncate
+                    const truncatedOutput = fullOutput.length > this.settings.maxOutputChars
+                        ? fullOutput.substring(0, this.settings.maxOutputChars) +
+                            "\n...[truncated]"
+                        : fullOutput;
+                    // Get reasoning
+                    const reasoningParts = response.split("```");
+                    const reasoning = reasoningParts.length > 0 ? (reasoningParts[0] ?? "").trim() : "";
+                    // Create step result
+                    const step = {
+                        iteration: iteration + 1,
+                        reasoning,
+                        code,
+                        output: truncatedOutput,
+                    };
+                    // Add to steps array
+                    steps.push(step);
+                    // Call onStepFinish callback if provided
+                    if (onStepFinish) {
+                        await onStepFinish(step);
+                    }
+                    // Add to messages
+                    messages.push({ role: "assistant", content: response }, {
+                        role: "user",
+                        content: `Code executed:\n\`\`\`javascript\n${code}\n\`\`\`\n\nOutput:\n${truncatedOutput}\n\nContinue with the next step.`,
+                    });
+                }
+                else {
+                    messages.push({ role: "assistant", content: response }, {
+                        role: "user",
+                        content: "Please write JavaScript code in a ```javascript block to explore the context and answer the query.",
+                    });
+                }
+            }
+            // Max iterations reached
+            messages.push({
+                role: "user",
+                content: "Maximum iterations reached. Based on all the information gathered, provide your final answer using FINAL(your_answer).",
+            });
+            const finalResult = await generateText({
+                model: this.settings.model,
+                messages,
+                abortSignal,
+            });
+            mainLLMCallCount++; // Track final LLM call
+            const finalAnswer = extractFinalAnswer(finalResult.text);
+            let answer;
+            if (finalAnswer && finalAnswer.content) {
+                if (finalAnswer.type === "direct") {
+                    answer = finalAnswer.content;
+                }
+                else {
+                    const varValue = repl.getVariable(finalAnswer.content);
+                    answer =
+                        varValue !== undefined
+                            ? String(varValue)
+                            : `[Variable ${finalAnswer.content} not found]`;
+                }
+            }
+            else {
+                answer = finalResult.text;
+            }
+            return {
+                text: answer,
+                steps: steps,
+                llmCallCount: mainLLMCallCount + repl.getLLMCallCount(),
+                iterations: this.settings.maxIterations,
+            };
+        }
+        finally {
+            repl.cleanup();
+        }
+    }
+    /**
+     * Stream the answer generation process.
+     * Each step is yielded as it's completed.
+     */
+    async stream({ context, query, abortSignal, timeout, onStepFinish, }) {
+        // For now, delegate to generate() and create a simple stream wrapper
+        // Full streaming implementation would require more complex handling
+        const result = await this.generate({
+            context,
+            query,
+            abortSignal,
+            timeout,
+            onStepFinish,
+        });
+        // Create a simple text stream from the result
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(result.text);
+                controller.close();
+            },
+        });
+        return {
+            textStream: stream,
+            ...result,
+        };
+    }
+}
+export default RLMAgent;
+//# sourceMappingURL=rlm.js.map

package/dist/rlm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rlm.js","sourceRoot":"","sources":["../src/rlm.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "ai-rlm",
+  "version": "0.0.0",
+  "description": "Recursive Language Model (RLM) implementation using the Vercel AI SDK. Process long contexts through iterative code execution and sub-LLM queries.",
+  "author": "Joe Hsu <jhsu.x1@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/ai-rlm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/ai-rlm/issues"
+  },
+  "homepage": "https://github.com/yourusername/ai-rlm#readme",
+  "keywords": [
+    "ai",
+    "rlm",
+    "recursive",
+    "language-model",
+    "llm",
+    "ai-sdk",
+    "context",
+    "large-context",
+    "agent",
+    "tool"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./rlm": {
+      "types": "./dist/rlm.d.ts",
+      "import": "./dist/rlm.js",
+      "require": "./dist/rlm.cjs"
+    },
+    "./rlm-tool": {
+      "types": "./dist/rlm-tool.d.ts",
+      "import": "./dist/rlm-tool.js",
+      "require": "./dist/rlm-tool.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:watch": "tsc -p tsconfig.build.json --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "ai": "^6.0.86",
+    "zod": "^3.23.0"
+  },
+  "optionalDependencies": {
+    "@ai-sdk/openai": "^3.0.29",
+    "vm2": "^3.10.4"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@types/bun": "latest",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}