recursive-llm-ts 2.0.12 → 3.0.1

package/go/internal/rlm/benchmark_test.go

@@ -0,0 +1,168 @@
+package rlm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Benchmark parser performance
+func BenchmarkIsFinal(b *testing.B) {
+	responses := []string{
+		`FINAL("answer")`,
+		`FINAL_VAR(result)`,
+		`x = 1`,
+		`console.log("test")`,
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		IsFinal(responses[i%len(responses)])
+	}
+}
+
+func BenchmarkExtractFinal(b *testing.B) {
+	response := `FINAL("This is a test answer with some content")`
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		extractFinal(response)
+	}
+}
+
+func BenchmarkParseResponse(b *testing.B) {
+	response := `FINAL("Test answer")`
+	env := map[string]interface{}{
+		"result": "test",
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ParseResponse(response, env)
+	}
+}
+
+// Benchmark REPL performance
+func BenchmarkREPLSimpleExecution(b *testing.B) {
+	repl := NewREPLExecutor()
+	code := `console.log("Hello World")`
+	env := map[string]interface{}{}
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = repl.Execute(code, env)
+	}
+}
+
+func BenchmarkREPLContextAccess(b *testing.B) {
+	repl := NewREPLExecutor()
+	code := `console.log(context.slice(0, 10))`
+	env := map[string]interface{}{
+		"context": strings.Repeat("Lorem ipsum dolor sit amet. ", 1000),
+	}
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = repl.Execute(code, env)
+	}
+}
+
+func BenchmarkREPLRegex(b *testing.B) {
+	repl := NewREPLExecutor()
+	code := `const matches = re.findall("ERROR", context); console.log(matches.length)`
+	context := strings.Repeat("INFO ERROR WARNING ", 100)
+	env := map[string]interface{}{
+		"context": context,
+		"re":      NewRegexHelper(),
+	}
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = repl.Execute(code, env)
+	}
+}
+
+func BenchmarkREPLJSBootstrap(b *testing.B) {
+	repl := NewREPLExecutor()
+	code := `const arr = range(100); const s = sum(arr); console.log(s)`
+	env := map[string]interface{}{}
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = repl.Execute(code, env)
+	}
+}
+
+// Benchmark regex helper
+func BenchmarkRegexFindall(b *testing.B) {
+	re := NewRegexHelper()
+	text := strings.Repeat("ERROR INFO WARNING ERROR ", 100)
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		re["findall"]("ERROR", text)
+	}
+}
+
+func BenchmarkRegexSearch(b *testing.B) {
+	re := NewRegexHelper()
+	text := strings.Repeat("INFO WARNING ", 50) + "ERROR" + strings.Repeat(" INFO WARNING", 50)
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		re["search"]("ERROR", text)
+	}
+}
+
+// Benchmark config parsing
+func BenchmarkConfigFromMap(b *testing.B) {
+	config := map[string]interface{}{
+		"recursive_model": "gpt-4o-mini",
+		"api_base":        "https://api.openai.com/v1",
+		"api_key":         "sk-test",
+		"max_depth":       5,
+		"max_iterations":  30,
+		"temperature":     0.7,
+		"extra_param":     "value",
+	}
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ConfigFromMap(config)
+	}
+}
+
+// Benchmark code extraction
+func BenchmarkExtractCode(b *testing.B) {
+	code := "```javascript\nconsole.log('test')\nconst x = 42\n```"
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		extractCode(code)
+	}
+}
+
+// Memory allocation benchmarks
+func BenchmarkREPLMemoryAllocation(b *testing.B) {
+	repl := NewREPLExecutor()
+	code := `const arr = []; for (let i = 0; i < 1000; i++) arr.push(i); console.log(arr.length)`
+	env := map[string]interface{}{}
+	
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = repl.Execute(code, env)
+	}
+}
+
+func BenchmarkLargeContextAccess(b *testing.B) {
+	repl := NewREPLExecutor()
+	// Simulate 100KB context
+	largeContext := strings.Repeat("Lorem ipsum dolor sit amet, consectetur adipiscing elit. ", 2000)
+	code := `const first = context.slice(0, 100); const last = context.slice(-100); console.log(first.length + last.length)`
+	env := map[string]interface{}{
+		"context": largeContext,
+	}
+	
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = repl.Execute(code, env)
+	}
+}

package/go/internal/rlm/errors.go

@@ -0,0 +1,83 @@
+package rlm
+
+import "fmt"
+
+// RLMError is the base error type for all RLM errors
+type RLMError struct {
+	Message string
+	Cause   error
+}
+
+func (e *RLMError) Error() string {
+	if e.Cause != nil {
+		return fmt.Sprintf("%s: %v", e.Message, e.Cause)
+	}
+	return e.Message
+}
+
+func (e *RLMError) Unwrap() error {
+	return e.Cause
+}
+
+// MaxIterationsError is returned when max iterations are exceeded
+type MaxIterationsError struct {
+	MaxIterations int
+	*RLMError
+}
+
+func NewMaxIterationsError(maxIterations int) *MaxIterationsError {
+	return &MaxIterationsError{
+		MaxIterations: maxIterations,
+		RLMError: &RLMError{
+			Message: fmt.Sprintf("max iterations (%d) exceeded without FINAL()", maxIterations),
+		},
+	}
+}
+
+// MaxDepthError is returned when max recursion depth is exceeded
+type MaxDepthError struct {
+	MaxDepth int
+	*RLMError
+}
+
+func NewMaxDepthError(maxDepth int) *MaxDepthError {
+	return &MaxDepthError{
+		MaxDepth: maxDepth,
+		RLMError: &RLMError{
+			Message: fmt.Sprintf("max recursion depth (%d) exceeded", maxDepth),
+		},
+	}
+}
+
+// REPLError is returned when REPL execution fails
+type REPLError struct {
+	Code string
+	*RLMError
+}
+
+func NewREPLError(message string, code string, cause error) *REPLError {
+	return &REPLError{
+		Code: code,
+		RLMError: &RLMError{
+			Message: message,
+			Cause:   cause,
+		},
+	}
+}
+
+// APIError is returned when LLM API calls fail
+type APIError struct {
+	StatusCode int
+	Response   string
+	*RLMError
+}
+
+func NewAPIError(statusCode int, response string) *APIError {
+	return &APIError{
+		StatusCode: statusCode,
+		Response:   response,
+		RLMError: &RLMError{
+			Message: fmt.Sprintf("LLM request failed (%d): %s", statusCode, response),
+		},
+	}
+}

package/go/internal/rlm/openai.go

@@ -0,0 +1,128 @@
+package rlm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type Message struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type ChatRequest struct {
+	Model       string
+	Messages    []Message
+	APIBase     string
+	APIKey      string
+	Timeout     int
+	ExtraParams map[string]interface{}
+}
+
+type chatResponse struct {
+	Choices []struct {
+		Message struct {
+			Content string `json:"content"`
+		} `json:"message"`
+	} `json:"choices"`
+	Error *struct {
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+var (
+	// defaultHTTPClient is a shared HTTP client with connection pooling
+	defaultHTTPClient = &http.Client{
+		Timeout: 60 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:        100,
+			MaxIdleConnsPerHost: 10,
+			IdleConnTimeout:     90 * time.Second,
+		},
+	}
+)
+
+func CallChatCompletion(request ChatRequest) (string, error) {
+	endpoint := buildEndpoint(request.APIBase)
+	payload := map[string]interface{}{
+		"model":    request.Model,
+		"messages": request.Messages,
+	}
+
+	for key, value := range request.ExtraParams {
+		payload[key] = value
+	}
+
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return "", err
+	}
+
+	// Use shared client with connection pooling
+	client := defaultHTTPClient
+	if request.Timeout > 0 {
+		// Create custom client for non-default timeout
+		client = &http.Client{
+			Timeout:   time.Duration(request.Timeout) * time.Second,
+			Transport: defaultHTTPClient.Transport,
+		}
+	}
+
+	req, err := http.NewRequest(http.MethodPost, endpoint, bytes.NewReader(body))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if request.APIKey != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", request.APIKey))
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode >= http.StatusBadRequest {
+		return "", NewAPIError(resp.StatusCode, strings.TrimSpace(string(responseBody)))
+	}
+
+	var parsed chatResponse
+	if err := json.Unmarshal(responseBody, &parsed); err != nil {
+		return "", err
+	}
+
+	if parsed.Error != nil && parsed.Error.Message != "" {
+		return "", errors.New(parsed.Error.Message)
+	}
+
+	if len(parsed.Choices) == 0 {
+		return "", errors.New("no choices returned by LLM")
+	}
+
+	return parsed.Choices[0].Message.Content, nil
+}
+
+func buildEndpoint(apiBase string) string {
+	base := strings.TrimSpace(apiBase)
+	if base == "" {
+		base = "https://api.openai.com/v1"
+	}
+
+	if strings.Contains(base, "/chat/completions") {
+		return base
+	}
+
+	return strings.TrimRight(base, "/") + "/chat/completions"
+}

package/go/internal/rlm/parser.go

@@ -0,0 +1,53 @@
+package rlm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var (
+	finalTripleDouble = regexp.MustCompile(`(?s)FINAL\s*\(\s*"""(.*)"""`)
+	finalTripleSingle = regexp.MustCompile(`(?s)FINAL\s*\(\s*'''(.*)'''`)
+	finalDouble       = regexp.MustCompile(`(?s)FINAL\s*\(\s*"([^"]*)"`)
+	finalSingle       = regexp.MustCompile(`(?s)FINAL\s*\(\s*'([^']*)'`)
+	finalVar          = regexp.MustCompile(`FINAL_VAR\s*\(\s*(\w+)\s*\)`)
+	finalAny          = regexp.MustCompile(`FINAL\(|FINAL_VAR\(`)
+)
+
+func IsFinal(response string) bool {
+	return finalAny.MatchString(response)
+}
+
+func ParseResponse(response string, env map[string]interface{}) (string, bool) {
+	answer, ok := extractFinal(response)
+	if ok {
+		return answer, true
+	}
+
+	return extractFinalVar(response, env)
+}
+
+func extractFinal(response string) (string, bool) {
+	matchers := []*regexp.Regexp{finalTripleDouble, finalTripleSingle, finalDouble, finalSingle}
+	for _, matcher := range matchers {
+		match := matcher.FindStringSubmatch(response)
+		if len(match) > 1 {
+			return strings.TrimSpace(match[1]), true
+		}
+	}
+	return "", false
+}
+
+func extractFinalVar(response string, env map[string]interface{}) (string, bool) {
+	match := finalVar.FindStringSubmatch(response)
+	if len(match) < 2 {
+		return "", false
+	}
+
+	value, ok := env[match[1]]
+	if !ok {
+		return "", false
+	}
+	return fmt.Sprint(value), true
+}

package/go/internal/rlm/parser_test.go

@@ -0,0 +1,202 @@
+package rlm
+
+import (
+	"testing"
+)
+
+func TestIsFinal(t *testing.T) {
+	tests := []struct {
+		name     string
+		response string
+		want     bool
+	}{
+		{"FINAL with double quotes", `FINAL("answer")`, true},
+		{"FINAL with single quotes", `FINAL('answer')`, true},
+		{"FINAL with triple double quotes", `FINAL("""answer""")`, true},
+		{"FINAL_VAR", `FINAL_VAR(result)`, true},
+		{"No FINAL", `x = 1`, false},
+		{"Contains FINAL as substring", `This is FINALLY done`, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IsFinal(tt.response); got != tt.want {
+				t.Errorf("IsFinal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestExtractFinal(t *testing.T) {
+	tests := []struct {
+		name     string
+		response string
+		want     string
+		wantOk   bool
+	}{
+		{
+			name:     "Double quotes",
+			response: `FINAL("The answer is 42")`,
+			want:     "The answer is 42",
+			wantOk:   true,
+		},
+		{
+			name:     "Single quotes",
+			response: `FINAL('The answer is 42')`,
+			want:     "The answer is 42",
+			wantOk:   true,
+		},
+		{
+			name:     "Triple double quotes",
+			response: `FINAL("""The answer is 42""")`,
+			want:     "The answer is 42",
+			wantOk:   true,
+		},
+		{
+			name:     "Triple single quotes",
+			response: `FINAL('''The answer is 42''')`,
+			want:     "The answer is 42",
+			wantOk:   true,
+		},
+		{
+			name: "Multiline with triple quotes",
+			response: `FINAL("""Line 1
+Line 2
+Line 3""")`,
+			want:   "Line 1\nLine 2\nLine 3",
+			wantOk: true,
+		},
+		{
+			name:     "With whitespace",
+			response: `FINAL(  "The answer"  )`,
+			want:     "The answer",
+			wantOk:   true,
+		},
+		{
+			name:     "No FINAL",
+			response: `x = 1`,
+			want:     "",
+			wantOk:   false,
+		},
+		{
+			name:     "FINAL_VAR should not match",
+			response: `FINAL_VAR(result)`,
+			want:     "",
+			wantOk:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, gotOk := extractFinal(tt.response)
+			if gotOk != tt.wantOk {
+				t.Errorf("extractFinal() ok = %v, want %v", gotOk, tt.wantOk)
+			}
+			if got != tt.want {
+				t.Errorf("extractFinal() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestExtractFinalVar(t *testing.T) {
+	tests := []struct {
+		name     string
+		response string
+		env      map[string]interface{}
+		want     string
+		wantOk   bool
+	}{
+		{
+			name:     "Simple variable",
+			response: `FINAL_VAR(result)`,
+			env:      map[string]interface{}{"result": "The answer"},
+			want:     "The answer",
+			wantOk:   true,
+		},
+		{
+			name:     "Integer variable",
+			response: `FINAL_VAR(count)`,
+			env:      map[string]interface{}{"count": 42},
+			want:     "42",
+			wantOk:   true,
+		},
+		{
+			name:     "Variable not found",
+			response: `FINAL_VAR(missing)`,
+			env:      map[string]interface{}{"result": "The answer"},
+			want:     "",
+			wantOk:   false,
+		},
+		{
+			name:     "With whitespace",
+			response: `FINAL_VAR( result )`,
+			env:      map[string]interface{}{"result": "The answer"},
+			want:     "The answer",
+			wantOk:   true,
+		},
+		{
+			name:     "No FINAL_VAR",
+			response: `x = 1`,
+			env:      map[string]interface{}{},
+			want:     "",
+			wantOk:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, gotOk := extractFinalVar(tt.response, tt.env)
+			if gotOk != tt.wantOk {
+				t.Errorf("extractFinalVar() ok = %v, want %v", gotOk, tt.wantOk)
+			}
+			if got != tt.want {
+				t.Errorf("extractFinalVar() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestParseResponse(t *testing.T) {
+	tests := []struct {
+		name     string
+		response string
+		env      map[string]interface{}
+		want     string
+		wantOk   bool
+	}{
+		{
+			name:     "FINAL takes precedence",
+			response: `FINAL("Direct answer")`,
+			env:      map[string]interface{}{"result": "Var answer"},
+			want:     "Direct answer",
+			wantOk:   true,
+		},
+		{
+			name:     "FINAL_VAR fallback",
+			response: `FINAL_VAR(result)`,
+			env:      map[string]interface{}{"result": "Var answer"},
+			want:     "Var answer",
+			wantOk:   true,
+		},
+		{
+			name:     "Neither",
+			response: `x = 1`,
+			env:      map[string]interface{}{},
+			want:     "",
+			wantOk:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, gotOk := ParseResponse(tt.response, tt.env)
+			if gotOk != tt.wantOk {
+				t.Errorf("ParseResponse() ok = %v, want %v", gotOk, tt.wantOk)
+			}
+			if got != tt.want {
+				t.Errorf("ParseResponse() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}

package/go/internal/rlm/prompt.go

@@ -0,0 +1,68 @@
+package rlm
+
+import "fmt"
+
+// BuildSystemPrompt creates the system prompt for RLM
+// useMetacognitive enables step-by-step reasoning guidance
+func BuildSystemPrompt(contextSize int, depth int, query string, useMetacognitive bool) string {
+	if useMetacognitive {
+		return buildMetacognitivePrompt(contextSize, depth, query)
+	}
+	return buildMinimalPrompt(contextSize, depth, query)
+}
+
+func buildMinimalPrompt(contextSize int, depth int, query string) string {
+	return fmt.Sprintf(`You are a Recursive Language Model. You interact with context through a JavaScript REPL environment.
+
+The context is stored in variable "context" (not in this prompt). Size: %d characters.
+
+Available in environment:
+- context: string (the document to analyze)
+- query: string (the question: %q)
+- recursive_llm(sub_query, sub_context) -> string (recursively process sub-context)
+- re: regex helper with findall(pattern, text) and search(pattern, text)
+- print(value, ...) -> output text
+- len(value) -> length of arrays/strings
+- json: helper with loads() and dumps()
+- math: Math helper
+- datetime: Date helper
+- Counter(iterable) -> object of counts
+- defaultdict(defaultFactory) -> object with defaults
+
+Write JavaScript code to answer the query. The last expression or console.log output will be shown to you.
+
+Examples:
+- console.log(context.slice(0, 100)); // See first 100 chars
+- const errors = re.findall("ERROR", context);
+- const count = errors.length; console.log(count);
+
+When you have the answer, use FINAL("answer") - this is NOT a function, just write it as text.
+
+Depth: %d`, contextSize, query, depth)
+}
+
+func buildMetacognitivePrompt(contextSize int, depth int, query string) string {
+	return fmt.Sprintf(`You are a Recursive Language Model. You interact with context through a JavaScript REPL environment.
+
+The context is stored in variable "context" (not in this prompt). Size: %d characters.
+
+Available in environment:
+- context: string (the document to analyze)
+- query: string (the question: %q)
+- recursive_llm(sub_query, sub_context) -> string (recursively process sub-context)
+- re: regex helper with findall(pattern, text) and search(pattern, text)
+- print(value, ...) -> output text
+- len(value) -> length of arrays/strings
+- json: helper with loads() and dumps()
+- math: Math helper
+- Counter(iterable) -> object of counts
+
+STRATEGY TIP: You can peek at context first to understand its structure before processing.
+Example: console.log(context.slice(0, 100))
+
+Write JavaScript code to answer the query. The last expression or console.log output will be shown to you.
+
+When you have the answer, use FINAL("answer") - this is NOT a function, just write it as text.
+
+Depth: %d`, contextSize, query, depth)
+}