recursive-llm-ts 2.0.11 → 3.0.1

package/go/integration_test.sh

@@ -0,0 +1,169 @@
+#!/bin/bash
+# Integration test with real LLM API
+# Set OPENAI_API_KEY environment variable before running
+
+set -e
+
+echo "🧪 RLM Go Integration Tests"
+echo "================================"
+echo ""
+
+# Check if binary exists
+if [ ! -f "./rlm" ]; then
+    echo "❌ Binary not found. Building..."
+    go build -o rlm ./cmd/rlm
+    echo "✅ Built binary"
+fi
+
+# Check for API key
+if [ -z "$OPENAI_API_KEY" ]; then
+    echo "❌ OPENAI_API_KEY environment variable not set"
+    echo ""
+    echo "Usage:"
+    echo "  export OPENAI_API_KEY='sk-...'"
+    echo "  ./integration_test.sh"
+    exit 1
+fi
+
+echo "✅ API key found"
+echo ""
+
+# Test 1: Simple query
+echo "📝 Test 1: Simple context analysis"
+echo "-----------------------------------"
+RESULT=$(cat <<EOF | ./rlm
+{
+  "model": "gpt-4o-mini",
+  "query": "How many times does the word 'test' appear?",
+  "context": "This is a test. Another test here. Final test.",
+  "config": {
+    "api_key": "$OPENAI_API_KEY",
+    "max_iterations": 10
+  }
+}
+EOF
+)
+
+if [ $? -eq 0 ]; then
+    echo "✅ Test 1 passed"
+    echo "Result: $(echo $RESULT | jq -r '.result')"
+    echo "Stats: $(echo $RESULT | jq '.stats')"
+else
+    echo "❌ Test 1 failed"
+    exit 1
+fi
+echo ""
+
+# Test 2: Count/aggregation
+echo "📝 Test 2: Counting errors in logs"
+echo "-----------------------------------"
+LOG_CONTEXT='2024-01-01 INFO: System started
+2024-01-01 ERROR: Connection failed
+2024-01-01 INFO: Retrying
+2024-01-01 ERROR: Timeout
+2024-01-01 ERROR: Failed again
+2024-01-01 INFO: Success'
+
+RESULT=$(./rlm <<EOF
+{
+  "model": "gpt-4o-mini",
+  "query": "Count how many ERROR entries are in the logs",
+  "context": "$LOG_CONTEXT",
+  "config": {
+    "api_key": "$OPENAI_API_KEY",
+    "max_iterations": 10
+  }
+}
+EOF
+)
+
+if [ $? -eq 0 ]; then
+    echo "✅ Test 2 passed"
+    echo "Result: $(echo $RESULT | jq -r '.result')"
+    ITERATIONS=$(echo $RESULT | jq '.stats.iterations')
+    echo "Iterations: $ITERATIONS"
+else
+    echo "❌ Test 2 failed"
+    exit 1
+fi
+echo ""
+
+# Test 3: Long context
+echo "📝 Test 3: Long context processing"
+echo "-----------------------------------"
+LONG_CONTEXT=$(cat <<EOF
+Chapter 1: The Beginning
+
+It was a dark and stormy night. The hero embarked on a journey.
+$(for i in {1..100}; do echo "Line $i of the story continues here with more content."; done)
+
+Chapter 2: The Middle
+
+The hero faced many challenges.
+$(for i in {1..100}; do echo "Line $i describes the adventure."; done)
+
+Chapter 3: The End
+
+Finally, the hero succeeded and returned home triumphant.
+EOF
+)
+
+RESULT=$(cat <<EOF | ./rlm
+{
+  "model": "gpt-4o-mini",
+  "query": "How many chapters are in this document?",
+  "context": "$LONG_CONTEXT",
+  "config": {
+    "api_key": "$OPENAI_API_KEY",
+    "max_iterations": 15
+  }
+}
+EOF
+)
+
+if [ $? -eq 0 ]; then
+    echo "✅ Test 3 passed"
+    echo "Result: $(echo $RESULT | jq -r '.result')"
+    LLM_CALLS=$(echo $RESULT | jq '.stats.llm_calls')
+    echo "LLM calls: $LLM_CALLS"
+else
+    echo "❌ Test 3 failed"
+    exit 1
+fi
+echo ""
+
+# Test 4: Different model configurations
+echo "📝 Test 4: Two-model configuration"
+echo "-----------------------------------"
+RESULT=$(cat <<EOF | ./rlm
+{
+  "model": "gpt-4o",
+  "query": "What is this text about?",
+  "context": "Artificial intelligence and machine learning are transforming technology.",
+  "config": {
+    "recursive_model": "gpt-4o-mini",
+    "api_key": "$OPENAI_API_KEY",
+    "max_iterations": 10,
+    "temperature": 0.3
+  }
+}
+EOF
+)
+
+if [ $? -eq 0 ]; then
+    echo "✅ Test 4 passed"
+    echo "Result: $(echo $RESULT | jq -r '.result')"
+else
+    echo "❌ Test 4 failed"
+    exit 1
+fi
+echo ""
+
+echo "================================"
+echo "✅ All integration tests passed!"
+echo ""
+echo "Summary:"
+echo "  - Simple queries work"
+echo "  - Counting/aggregation works"
+echo "  - Long context works"
+echo "  - Model configuration works"

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
+}