recursive-llm-ts 5.0.1 → 5.0.2

package/go/rlm/meta_agent_test.go

@@ -1,270 +0,0 @@
-package rlm
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestMetaAgentCreation(t *testing.T) {
-	config := Config{
-		APIKey:        "test-key",
-		MaxDepth:      5,
-		MaxIterations: 30,
-	}
-	engine := New("gpt-4o-mini", config)
-
-	maConfig := MetaAgentConfig{
-		Enabled: true,
-		Model:   "gpt-4o",
-	}
-
-	obs := NewNoopObserver()
-	ma := NewMetaAgent(engine, maConfig, obs)
-
-	if ma == nil {
-		t.Fatal("expected non-nil meta agent")
-	}
-	if ma.config.Model != "gpt-4o" {
-		t.Errorf("expected model 'gpt-4o', got '%s'", ma.config.Model)
-	}
-}
-
-func TestMetaAgentDefaultModel(t *testing.T) {
-	config := Config{
-		APIKey:        "test-key",
-		MaxDepth:      5,
-		MaxIterations: 30,
-	}
-	engine := New("gpt-4o-mini", config)
-
-	maConfig := MetaAgentConfig{
-		Enabled: true,
-		// No model specified - should default to engine model
-	}
-
-	obs := NewNoopObserver()
-	ma := NewMetaAgent(engine, maConfig, obs)
-
-	if ma.config.Model != "gpt-4o-mini" {
-		t.Errorf("expected default model 'gpt-4o-mini', got '%s'", ma.config.Model)
-	}
-}
-
-func TestMetaAgentNeedsOptimization(t *testing.T) {
-	config := Config{
-		APIKey:        "test-key",
-		MaxDepth:      5,
-		MaxIterations: 30,
-	}
-	engine := New("gpt-4o-mini", config)
-
-	tests := []struct {
-		name        string
-		maConfig    MetaAgentConfig
-		query       string
-		context     string
-		shouldNeed  bool
-	}{
-		{
-			name: "short vague query should need optimization",
-			maConfig: MetaAgentConfig{
-				Enabled: true,
-			},
-			query:      "what?",
-			context:    "some context",
-			shouldNeed: true,
-		},
-		{
-			name: "specific query with length limit should not need optimization",
-			maConfig: MetaAgentConfig{
-				Enabled:        true,
-				MaxOptimizeLen: 10000, // Non-zero enables specificity check
-			},
-			query:      "Extract all the email addresses from the document and list them",
-			context:    "some context",
-			shouldNeed: false,
-		},
-		{
-			name: "long context triggers optimization",
-			maConfig: MetaAgentConfig{
-				Enabled:        true,
-				MaxOptimizeLen: 100,
-			},
-			query:      "Find all errors and summarize the root causes from the log file",
-			context:    string(make([]byte, 200)), // 200 bytes > 100 threshold
-			shouldNeed: true,
-		},
-		{
-			name: "always optimize when MaxOptimizeLen is 0",
-			maConfig: MetaAgentConfig{
-				Enabled:        true,
-				MaxOptimizeLen: 0,
-			},
-			query:      "Extract the key takeaways and provide a comprehensive analysis of the conversation",
-			context:    "short",
-			shouldNeed: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			obs := NewNoopObserver()
-			ma := NewMetaAgent(engine, tt.maConfig, obs)
-
-			result := ma.needsOptimization(tt.query, tt.context)
-			if result != tt.shouldNeed {
-				t.Errorf("needsOptimization = %v, want %v", result, tt.shouldNeed)
-			}
-		})
-	}
-}
-
-func TestMetaAgentBuildOptimizePrompt(t *testing.T) {
-	config := Config{
-		APIKey:        "test-key",
-		MaxDepth:      5,
-		MaxIterations: 30,
-	}
-	engine := New("gpt-4o-mini", config)
-
-	obs := NewNoopObserver()
-	ma := NewMetaAgent(engine, MetaAgentConfig{Enabled: true}, obs)
-
-	prompt := ma.buildOptimizePrompt("what are the key points?", "some long context here")
-
-	if prompt == "" {
-		t.Error("expected non-empty prompt")
-	}
-
-	// Should contain the original query
-	if !strings.Contains(prompt, "what are the key points?") {
-		t.Error("prompt should contain the original query")
-	}
-}
-
-func TestTruncateStr(t *testing.T) {
-	tests := []struct {
-		input    string
-		maxLen   int
-		expected string
-	}{
-		{"hello", 10, "hello"},
-		{"hello world", 5, "hello..."},
-		{"", 5, ""},
-		{"abc", 3, "abc"},
-		{"abcd", 3, "abc..."},
-	}
-
-	for _, tt := range tests {
-		result := truncateStr(tt.input, tt.maxLen)
-		if result != tt.expected {
-			t.Errorf("truncateStr(%q, %d) = %q, want %q", tt.input, tt.maxLen, result, tt.expected)
-		}
-	}
-}
-
-func TestMetaAgentConfigParsing(t *testing.T) {
-	config := map[string]interface{}{
-		"api_key": "test-key",
-		"meta_agent": map[string]interface{}{
-			"enabled":          true,
-			"model":            "gpt-4o",
-			"max_optimize_len": 5000,
-		},
-	}
-
-	parsed := ConfigFromMap(config)
-
-	if parsed.MetaAgent == nil {
-		t.Fatal("expected non-nil MetaAgent config")
-	}
-	if !parsed.MetaAgent.Enabled {
-		t.Error("expected meta_agent.enabled to be true")
-	}
-	if parsed.MetaAgent.Model != "gpt-4o" {
-		t.Errorf("expected model 'gpt-4o', got '%s'", parsed.MetaAgent.Model)
-	}
-	if parsed.MetaAgent.MaxOptimizeLen != 5000 {
-		t.Errorf("expected max_optimize_len 5000, got %d", parsed.MetaAgent.MaxOptimizeLen)
-	}
-}
-
-func TestConfigWithObservability(t *testing.T) {
-	config := map[string]interface{}{
-		"api_key": "test-key",
-		"debug":   true,
-		"observability": map[string]interface{}{
-			"trace_enabled": true,
-			"service_name":  "test-rlm",
-		},
-	}
-
-	parsed := ConfigFromMap(config)
-
-	if parsed.Observability == nil {
-		t.Fatal("expected non-nil Observability config")
-	}
-	if !parsed.Observability.Debug {
-		t.Error("expected debug to be true")
-	}
-	if !parsed.Observability.TraceEnabled {
-		t.Error("expected trace_enabled to be true")
-	}
-	if parsed.Observability.ServiceName != "test-rlm" {
-		t.Errorf("expected service_name 'test-rlm', got '%s'", parsed.Observability.ServiceName)
-	}
-}
-
-func TestEngineWithMetaAgent(t *testing.T) {
-	config := Config{
-		APIKey:        "test-key",
-		MaxDepth:      5,
-		MaxIterations: 30,
-		MetaAgent: &MetaAgentConfig{
-			Enabled: true,
-			Model:   "gpt-4o",
-		},
-	}
-
-	engine := New("gpt-4o-mini", config)
-
-	if engine.metaAgent == nil {
-		t.Error("expected meta agent to be initialized")
-	}
-}
-
-func TestEngineWithObservability(t *testing.T) {
-	config := Config{
-		APIKey:        "test-key",
-		MaxDepth:      5,
-		MaxIterations: 30,
-		Observability: &ObservabilityConfig{
-			Debug: true,
-		},
-	}
-
-	engine := New("gpt-4o-mini", config)
-	defer engine.Shutdown()
-
-	obs := engine.GetObserver()
-	if obs == nil {
-		t.Fatal("expected non-nil observer")
-	}
-	if !obs.config.Debug {
-		t.Error("expected debug mode enabled")
-	}
-}
-
-func TestEngineWithoutMetaAgent(t *testing.T) {
-	config := Config{
-		APIKey:        "test-key",
-		MaxDepth:      5,
-		MaxIterations: 30,
-	}
-
-	engine := New("gpt-4o-mini", config)
-
-	if engine.metaAgent != nil {
-		t.Error("expected meta agent to be nil when not configured")
-	}
-}

package/go/rlm/observability_test.go

@@ -1,252 +0,0 @@
-package rlm
-
-import (
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestNewObserver(t *testing.T) {
-	t.Run("with debug enabled", func(t *testing.T) {
-		obs := NewObserver(ObservabilityConfig{Debug: true})
-		if obs == nil {
-			t.Fatal("expected non-nil observer")
-		}
-		if !obs.config.Debug {
-			t.Error("expected debug to be enabled")
-		}
-	})
-
-	t.Run("with tracing enabled", func(t *testing.T) {
-		obs := NewObserver(ObservabilityConfig{
-			TraceEnabled: true,
-			ServiceName:  "test-rlm",
-		})
-		if obs == nil {
-			t.Fatal("expected non-nil observer")
-		}
-		if obs.tracer == nil {
-			t.Error("expected tracer to be initialized")
-		}
-		obs.Shutdown()
-	})
-}
-
-func TestNewNoopObserver(t *testing.T) {
-	obs := NewNoopObserver()
-	if obs == nil {
-		t.Fatal("expected non-nil observer")
-	}
-
-	// Should not panic with any operations
-	ctx := obs.StartTrace("test", nil)
-	obs.EndTrace(ctx)
-	obs.Debug("test", "message %s", "arg")
-	obs.Error("test", "error %s", "arg")
-	obs.Event("test", map[string]string{"key": "value"})
-	obs.LLMCall("model", 1, 0, time.Second, nil)
-}
-
-func TestObserverEvents(t *testing.T) {
-	obs := NewObserver(ObservabilityConfig{Debug: true})
-
-	obs.Event("test.event1", map[string]string{"key": "value1"})
-	obs.Event("test.event2", map[string]string{"key": "value2"})
-
-	events := obs.GetEvents()
-	if len(events) != 2 {
-		t.Errorf("expected 2 events, got %d", len(events))
-	}
-
-	if events[0].Name != "test.event1" {
-		t.Errorf("expected first event name 'test.event1', got '%s'", events[0].Name)
-	}
-	if events[1].Name != "test.event2" {
-		t.Errorf("expected second event name 'test.event2', got '%s'", events[1].Name)
-	}
-}
-
-func TestObserverEventsJSON(t *testing.T) {
-	obs := NewObserver(ObservabilityConfig{Debug: true})
-
-	obs.Event("test.event", map[string]string{"key": "value"})
-
-	jsonStr, err := obs.GetEventsJSON()
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if !strings.Contains(jsonStr, "test.event") {
-		t.Error("expected JSON to contain event name")
-	}
-	if !strings.Contains(jsonStr, `"key"`) {
-		t.Error("expected JSON to contain attribute key")
-	}
-}
-
-func TestObserverLLMCall(t *testing.T) {
-	obs := NewObserver(ObservabilityConfig{Debug: true})
-
-	obs.LLMCall("gpt-4o-mini", 3, 150, 2*time.Second, nil)
-
-	events := obs.GetEvents()
-	if len(events) != 1 {
-		t.Fatalf("expected 1 event, got %d", len(events))
-	}
-
-	event := events[0]
-	if event.Type != "llm_call" {
-		t.Errorf("expected type 'llm_call', got '%s'", event.Type)
-	}
-	if event.Attributes["model"] != "gpt-4o-mini" {
-		t.Errorf("expected model 'gpt-4o-mini', got '%s'", event.Attributes["model"])
-	}
-	if event.Attributes["message_count"] != "3" {
-		t.Errorf("expected message_count '3', got '%s'", event.Attributes["message_count"])
-	}
-}
-
-func TestObserverOnEventCallback(t *testing.T) {
-	var receivedEvents []ObservabilityEvent
-
-	obs := NewObserver(ObservabilityConfig{
-		Debug: true,
-		OnEvent: func(event ObservabilityEvent) {
-			receivedEvents = append(receivedEvents, event)
-		},
-	})
-
-	obs.Event("callback.test", map[string]string{"data": "test"})
-
-	if len(receivedEvents) != 1 {
-		t.Fatalf("expected 1 callback event, got %d", len(receivedEvents))
-	}
-	if receivedEvents[0].Name != "callback.test" {
-		t.Errorf("expected event name 'callback.test', got '%s'", receivedEvents[0].Name)
-	}
-}
-
-func TestObserverSpans(t *testing.T) {
-	obs := NewObserver(ObservabilityConfig{
-		TraceEnabled: true,
-		ServiceName:  "test",
-	})
-	defer obs.Shutdown()
-
-	traceCtx := obs.StartTrace("root", map[string]string{"op": "test"})
-	spanCtx := obs.StartSpan("child", map[string]string{"step": "1"})
-	obs.EndSpan(spanCtx)
-	obs.EndTrace(traceCtx)
-
-	events := obs.GetEvents()
-	// Should have at least trace_start and span_start events
-	if len(events) < 2 {
-		t.Errorf("expected at least 2 events, got %d", len(events))
-	}
-}
-
-func TestObservabilityConfigFromMap(t *testing.T) {
-	config := map[string]interface{}{
-		"debug":         true,
-		"trace_enabled": true,
-		"service_name":  "my-service",
-		"log_output":    "stderr",
-	}
-
-	obs := ObservabilityConfigFromMap(config)
-
-	if !obs.Debug {
-		t.Error("expected debug to be true")
-	}
-	if !obs.TraceEnabled {
-		t.Error("expected trace_enabled to be true")
-	}
-	if obs.ServiceName != "my-service" {
-		t.Errorf("expected service_name 'my-service', got '%s'", obs.ServiceName)
-	}
-	if obs.LogOutput != "stderr" {
-		t.Errorf("expected log_output 'stderr', got '%s'", obs.LogOutput)
-	}
-}
-
-func TestObservabilityConfigFromMap_Nil(t *testing.T) {
-	obs := ObservabilityConfigFromMap(nil)
-	if obs.Debug || obs.TraceEnabled {
-		t.Error("expected all defaults for nil config")
-	}
-}
-
-func TestExtractObservabilityConfig(t *testing.T) {
-	fullConfig := map[string]interface{}{
-		"debug":       true,
-		"model":       "gpt-4o",
-		"api_key":     "key",
-		"service_name": "rlm-test",
-		"observability": map[string]interface{}{
-			"langfuse_enabled": true,
-		},
-	}
-
-	obsConfig := ExtractObservabilityConfig(fullConfig)
-
-	if v, ok := obsConfig["debug"].(bool); !ok || !v {
-		t.Error("expected debug to be extracted")
-	}
-	if v, ok := obsConfig["service_name"].(string); !ok || v != "rlm-test" {
-		t.Error("expected service_name to be extracted")
-	}
-	if v, ok := obsConfig["langfuse_enabled"].(bool); !ok || !v {
-		t.Error("expected langfuse_enabled from nested observability config")
-	}
-	if _, ok := obsConfig["model"]; ok {
-		t.Error("model should not be in observability config")
-	}
-}
-
-func TestRedactSensitive(t *testing.T) {
-	attrs := map[string]string{
-		"model":   "gpt-4o",
-		"api_key": "sk-12345",
-		"secret":  "my-secret",
-		"query":   "hello world",
-	}
-
-	redacted := RedactSensitive(attrs)
-
-	if redacted["model"] != "gpt-4o" {
-		t.Error("model should not be redacted")
-	}
-	if redacted["api_key"] != "[REDACTED]" {
-		t.Error("api_key should be redacted")
-	}
-	if redacted["secret"] != "[REDACTED]" {
-		t.Error("secret should be redacted")
-	}
-	if redacted["query"] != "hello world" {
-		t.Error("query should not be redacted")
-	}
-}
-
-func TestFormatStatsWithObservability(t *testing.T) {
-	stats := RLMStats{
-		LlmCalls:       5,
-		Iterations:     3,
-		Depth:          1,
-		ParsingRetries: 2,
-	}
-
-	obs := NewObserver(ObservabilityConfig{Debug: true})
-	obs.Event("test", map[string]string{"data": "value"})
-
-	result := FormatStatsWithObservability(stats, obs)
-
-	if result["llm_calls"] != 5 {
-		t.Errorf("expected llm_calls 5, got %v", result["llm_calls"])
-	}
-	if result["parsing_retries"] != 2 {
-		t.Errorf("expected parsing_retries 2, got %v", result["parsing_retries"])
-	}
-	if _, ok := result["trace_events"]; !ok {
-		t.Error("expected trace_events in debug mode")
-	}
-}

package/go/rlm/parser_test.go

@@ -1,202 +0,0 @@
-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)
-			}
-		})
-	}
-}