diff --git a/claudetool/bash.go b/claudetool/bash.go
index ce27ec7..a62892f 100644
--- a/claudetool/bash.go
+++ b/claudetool/bash.go
@@ -324,12 +324,6 @@
 	}, nil
 }
 
-// BashRun is the legacy function for testing compatibility
-func BashRun(ctx context.Context, m json.RawMessage) ([]llm.Content, error) {
-	// Use the default Bash tool which has no permission callback
-	return Bash.Run(ctx, m)
-}
-
 // checkAndInstallMissingTools analyzes a bash command and attempts to automatically install any missing tools.
 func (b *BashTool) checkAndInstallMissingTools(ctx context.Context, command string) error {
 	commands, err := bashkit.ExtractCommands(command)
diff --git a/claudetool/bash_test.go b/claudetool/bash_test.go
index 45dd4fe..6904447 100644
--- a/claudetool/bash_test.go
+++ b/claudetool/bash_test.go
@@ -11,20 +11,19 @@
 	"time"
 )
 
-func TestBashRun(t *testing.T) {
+func TestBashTool(t *testing.T) {
 	// Test basic functionality
 	t.Run("Basic Command", func(t *testing.T) {
 		input := json.RawMessage(`{"command":"echo 'Hello, world!'"}`)
 
-		result, err := BashRun(context.Background(), input)
+		result, err := Bash.Run(context.Background(), input)
 		if err != nil {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 
 		expected := "Hello, world!\n"
-		resultStr := ContentToString(result)
-		if resultStr != expected {
-			t.Errorf("Expected %q, got %q", expected, resultStr)
+		if len(result) == 0 || result[0].Text != expected {
+			t.Errorf("Expected %q, got %q", expected, result[0].Text)
 		}
 	})
 
@@ -32,15 +31,14 @@
 	t.Run("Command With Arguments", func(t *testing.T) {
 		input := json.RawMessage(`{"command":"echo -n foo && echo -n bar"}`)
 
-		result, err := BashRun(context.Background(), input)
+		result, err := Bash.Run(context.Background(), input)
 		if err != nil {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 
 		expected := "foobar"
-		resultStr := ContentToString(result)
-		if resultStr != expected {
-			t.Errorf("Expected %q, got %q", expected, resultStr)
+		if len(result) == 0 || result[0].Text != expected {
+			t.Errorf("Expected %q, got %q", expected, result[0].Text)
 		}
 	})
 
@@ -58,15 +56,14 @@
 			t.Fatalf("Failed to marshal input: %v", err)
 		}
 
-		result, err := BashRun(context.Background(), inputJSON)
+		result, err := Bash.Run(context.Background(), inputJSON)
 		if err != nil {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 
 		expected := "Completed\n"
-		resultStr := ContentToString(result)
-		if resultStr != expected {
-			t.Errorf("Expected %q, got %q", expected, resultStr)
+		if len(result) == 0 || result[0].Text != expected {
+			t.Errorf("Expected %q, got %q", expected, result[0].Text)
 		}
 	})
 
@@ -84,7 +81,7 @@
 			t.Fatalf("Failed to marshal input: %v", err)
 		}
 
-		_, err = BashRun(context.Background(), inputJSON)
+		_, err = Bash.Run(context.Background(), inputJSON)
 		if err == nil {
 			t.Errorf("Expected timeout error, got none")
 		} else if !strings.Contains(err.Error(), "timed out") {
@@ -96,7 +93,7 @@
 	t.Run("Failed Command", func(t *testing.T) {
 		input := json.RawMessage(`{"command":"exit 1"}`)
 
-		_, err := BashRun(context.Background(), input)
+		_, err := Bash.Run(context.Background(), input)
 		if err == nil {
 			t.Errorf("Expected error for failed command, got none")
 		}
@@ -106,7 +103,7 @@
 	t.Run("Invalid JSON Input", func(t *testing.T) {
 		input := json.RawMessage(`{"command":123}`) // Invalid JSON (command must be string)
 
-		_, err := BashRun(context.Background(), input)
+		_, err := Bash.Run(context.Background(), input)
 		if err == nil {
 			t.Errorf("Expected error for invalid input, got none")
 		}
@@ -224,14 +221,14 @@
 			t.Fatalf("Failed to marshal input: %v", err)
 		}
 
-		result, err := BashRun(context.Background(), inputJSON)
+		result, err := Bash.Run(context.Background(), inputJSON)
 		if err != nil {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 
 		// Parse the returned JSON
 		var bgResult BackgroundResult
-		resultStr := ContentToString(result)
+		resultStr := result[0].Text
 		if err := json.Unmarshal([]byte(resultStr), &bgResult); err != nil {
 			t.Fatalf("Failed to unmarshal background result: %v", err)
 		}
@@ -282,14 +279,14 @@
 			t.Fatalf("Failed to marshal input: %v", err)
 		}
 
-		result, err := BashRun(context.Background(), inputJSON)
+		result, err := Bash.Run(context.Background(), inputJSON)
 		if err != nil {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 
 		// Parse the returned JSON
 		var bgResult BackgroundResult
-		resultStr := ContentToString(result)
+		resultStr := result[0].Text
 		if err := json.Unmarshal([]byte(resultStr), &bgResult); err != nil {
 			t.Fatalf("Failed to unmarshal background result: %v", err)
 		}
@@ -340,14 +337,14 @@
 		}
 
 		// Start the command in the background
-		result, err := BashRun(context.Background(), inputJSON)
+		result, err := Bash.Run(context.Background(), inputJSON)
 		if err != nil {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 
 		// Parse the returned JSON
 		var bgResult BackgroundResult
-		resultStr := ContentToString(result)
+		resultStr := result[0].Text
 		if err := json.Unmarshal([]byte(resultStr), &bgResult); err != nil {
 			t.Fatalf("Failed to unmarshal background result: %v", err)
 		}
diff --git a/claudetool/browse/browse.go b/claudetool/browse/browse.go
index 2918abb..f600c72 100644
--- a/claudetool/browse/browse.go
+++ b/claudetool/browse/browse.go
@@ -141,11 +141,6 @@
 	return b.browserCtx, nil
 }
 
-// All tools return this as a response when successful
-type baseResponse struct {
-	Status string `json:"status,omitempty"`
-}
-
 func successResponse() string {
 	return `{"status":"success"}`
 }
diff --git a/claudetool/util.go b/claudetool/util.go
index 88136e4..5715f79 100644
--- a/claudetool/util.go
+++ b/claudetool/util.go
@@ -1,13 +1 @@
 package claudetool
-
-import (
-	"sketch.dev/llm"
-)
-
-// ContentToString extracts text from []llm.Content if available
-func ContentToString(content []llm.Content) string {
-	if len(content) == 0 {
-		return ""
-	}
-	return content[0].Text
-}
diff --git a/dockerimg/tunnel_manager.go b/dockerimg/tunnel_manager.go
index 2b01f8a..89512d4 100644
--- a/dockerimg/tunnel_manager.go
+++ b/dockerimg/tunnel_manager.go
@@ -246,15 +246,3 @@
 		delete(tm.activeTunnels, port)
 	}
 }
-
-// GetActiveTunnels returns a list of currently active tunnels
-func (tm *TunnelManager) GetActiveTunnels() map[string]string {
-	tm.mu.Lock()
-	defer tm.mu.Unlock()
-
-	result := make(map[string]string)
-	for containerPort, tunnel := range tm.activeTunnels {
-		result[containerPort] = tunnel.hostPort
-	}
-	return result
-}
diff --git a/dockerimg/tunnel_manager_test.go b/dockerimg/tunnel_manager_test.go
index f430559..6408ce5 100644
--- a/dockerimg/tunnel_manager_test.go
+++ b/dockerimg/tunnel_manager_test.go
@@ -16,10 +16,9 @@
 		t.Errorf("Expected maxActiveTunnels to be 2, got %d", tm.maxActiveTunnels)
 	}
 
-	// Test that GetActiveTunnels returns empty initially
-	activeTunnels := tm.GetActiveTunnels()
-	if len(activeTunnels) != 0 {
-		t.Errorf("Expected 0 active tunnels initially, got %d", len(activeTunnels))
+	// Test that active tunnels map is empty initially
+	if len(tm.activeTunnels) != 0 {
+		t.Errorf("Expected 0 active tunnels initially, got %d", len(tm.activeTunnels))
 	}
 
 	// Simulate adding tunnels beyond the limit by directly manipulating the internal map
@@ -29,9 +28,8 @@
 	tm.activeTunnels["9090"] = &sshTunnel{containerPort: "9090", hostPort: "9090"}
 
 	// Verify we have 2 active tunnels
-	activeTunnels = tm.GetActiveTunnels()
-	if len(activeTunnels) != 2 {
-		t.Errorf("Expected 2 active tunnels, got %d", len(activeTunnels))
+	if len(tm.activeTunnels) != 2 {
+		t.Errorf("Expected 2 active tunnels, got %d", len(tm.activeTunnels))
 	}
 
 	// Now test that the limit check works - attempt to add a third tunnel
@@ -49,9 +47,8 @@
 	}
 
 	// Verify we still have only 2 active tunnels (didn't exceed limit)
-	activeTunnels = tm.GetActiveTunnels()
-	if len(activeTunnels) != 2 {
-		t.Errorf("Expected exactly 2 active tunnels after limit enforcement, got %d", len(activeTunnels))
+	if len(tm.activeTunnels) != 2 {
+		t.Errorf("Expected exactly 2 active tunnels after limit enforcement, got %d", len(tm.activeTunnels))
 	}
 }
 
@@ -136,8 +133,8 @@
 	tm.activeTunnels["9090"] = &sshTunnel{containerPort: "9090", hostPort: "9090"}
 
 	// Verify we're now at the limit
-	if len(tm.GetActiveTunnels()) != 2 {
-		t.Fatalf("Setup failed: expected 2 active tunnels, got %d", len(tm.GetActiveTunnels()))
+	if len(tm.activeTunnels) != 2 {
+		t.Fatalf("Setup failed: expected 2 active tunnels, got %d", len(tm.activeTunnels))
 	}
 
 	// Now test that createTunnel respects the limit by calling it directly
@@ -146,13 +143,13 @@
 	tm.createTunnel(ctx, "4000")
 
 	// Verify no additional tunnels were added (limit enforcement worked)
-	if len(tm.GetActiveTunnels()) != 2 {
-		t.Errorf("createTunnel should have been blocked by limit, but tunnel count changed from 2 to %d", len(tm.GetActiveTunnels()))
+	if len(tm.activeTunnels) != 2 {
+		t.Errorf("createTunnel should have been blocked by limit, but tunnel count changed from 2 to %d", len(tm.activeTunnels))
 	}
 
 	// Verify we're at the limit
-	if len(tm.GetActiveTunnels()) != 2 {
-		t.Fatalf("Expected 2 active tunnels, got %d", len(tm.GetActiveTunnels()))
+	if len(tm.activeTunnels) != 2 {
+		t.Fatalf("Expected 2 active tunnels, got %d", len(tm.activeTunnels))
 	}
 
 	// Now try to process more port events that would create additional tunnels
@@ -173,24 +170,23 @@
 	tm.processPortEvent(ctx, portEvent2)
 
 	// Verify that no additional tunnels were created
-	activeTunnels := tm.GetActiveTunnels()
-	if len(activeTunnels) != 2 {
-		t.Errorf("Expected exactly 2 active tunnels after limit enforcement, got %d", len(activeTunnels))
+	if len(tm.activeTunnels) != 2 {
+		t.Errorf("Expected exactly 2 active tunnels after limit enforcement, got %d", len(tm.activeTunnels))
 	}
 
 	// Verify the original tunnels are still there
-	if _, exists := activeTunnels["8080"]; !exists {
+	if _, exists := tm.activeTunnels["8080"]; !exists {
 		t.Error("Expected original tunnel for port 8080 to still exist")
 	}
-	if _, exists := activeTunnels["9090"]; !exists {
+	if _, exists := tm.activeTunnels["9090"]; !exists {
 		t.Error("Expected original tunnel for port 9090 to still exist")
 	}
 
 	// Verify the new tunnels were NOT created
-	if _, exists := activeTunnels["3000"]; exists {
+	if _, exists := tm.activeTunnels["3000"]; exists {
 		t.Error("Expected tunnel for port 3000 to NOT be created due to limit")
 	}
-	if _, exists := activeTunnels["4000"]; exists {
+	if _, exists := tm.activeTunnels["4000"]; exists {
 		t.Error("Expected tunnel for port 4000 to NOT be created due to limit")
 	}
 }
diff --git a/loop/agent_test.go b/loop/agent_test.go
index 1fa6a9e..ea93dc6 100644
--- a/loop/agent_test.go
+++ b/loop/agent_test.go
@@ -694,80 +694,6 @@
 	}
 }
 
-func TestContentToString(t *testing.T) {
-	tests := []struct {
-		name     string
-		contents []llm.Content
-		want     string
-	}{
-		{
-			name:     "empty",
-			contents: []llm.Content{},
-			want:     "",
-		},
-		{
-			name: "single text content",
-			contents: []llm.Content{
-				{Type: llm.ContentTypeText, Text: "hello world"},
-			},
-			want: "hello world",
-		},
-		{
-			name: "multiple text content",
-			contents: []llm.Content{
-				{Type: llm.ContentTypeText, Text: "hello "},
-				{Type: llm.ContentTypeText, Text: "world"},
-			},
-			want: "hello world",
-		},
-		{
-			name: "mixed content types",
-			contents: []llm.Content{
-				{Type: llm.ContentTypeText, Text: "hello "},
-				{Type: llm.ContentTypeText, MediaType: "image/png", Data: "base64data"},
-				{Type: llm.ContentTypeText, Text: "world"},
-			},
-			want: "hello world",
-		},
-		{
-			name: "non-text content only",
-			contents: []llm.Content{
-				{Type: llm.ContentTypeToolUse, ToolName: "example"},
-			},
-			want: "",
-		},
-		{
-			name: "nested tool result",
-			contents: []llm.Content{
-				{Type: llm.ContentTypeText, Text: "outer "},
-				{Type: llm.ContentTypeToolResult, ToolResult: []llm.Content{
-					{Type: llm.ContentTypeText, Text: "inner"},
-				}},
-			},
-			want: "outer inner",
-		},
-		{
-			name: "deeply nested tool result",
-			contents: []llm.Content{
-				{Type: llm.ContentTypeToolResult, ToolResult: []llm.Content{
-					{Type: llm.ContentTypeToolResult, ToolResult: []llm.Content{
-						{Type: llm.ContentTypeText, Text: "deeply nested"},
-					}},
-				}},
-			},
-			want: "deeply nested",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := contentToString(tt.contents); got != tt.want {
-				t.Errorf("contentToString() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestPushToOutbox(t *testing.T) {
 	// Create a new agent
 	a := &Agent{