gemini-cli is stupid

convertToPB.go

@@ -21,15 +21,24 @@ func convertToPB(resp *genai.GenerateContentResponse) *chatpb.ChatEntry {
 				PartType: &chatpb.Part_Text{Text: part.Text},
 			})
 		}
-		if part.FunctionCall != nil {
+		if fc := part.FunctionCall; fc != nil {
-			fmt.Printf("Gemini API requested to execute command: %s\n", part.FunctionCall.Name)
+			fmt.Printf("Gemini API requested to execute command: %s\n", fc.Name)
-			// This is a simplified conversion of args.
-			// A more robust implementation would handle different value types.
 			entry.Parts = append(entry.Parts, &chatpb.Part{
 				PartType: &chatpb.Part_FunctionCall{
 					FunctionCall: &chatpb.FunctionCall{
-						Name: part.FunctionCall.Name,
+						Name: fc.Name,
-						Args: &chatpb.ArgsInfo{}, // TODO: Properly map args if needed
+						Args: &chatpb.ArgsInfo{}, // TODO: Properly map args from fc.Args map[string]any
+					},
+				},
+			})
+		}
+		if fr := part.FunctionResponse; fr != nil {
+			// Convert the FunctionResponse to the protobuf equivalent
+			entry.Parts = append(entry.Parts, &chatpb.Part{
+				PartType: &chatpb.Part_FunctionResponse{
+					FunctionResponse: &chatpb.FunctionResponse{
+						Name: fr.Name,
+						// TODO: Properly map the response content
 					},
 				},
 			})

doConnect.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 
+	"go.wit.com/lib/protobuf/chatpb"
 	"go.wit.com/log"
 	"google.golang.org/genai"
 )
@@ -23,6 +24,78 @@ func doConnect() error {
 		return log.Errorf("failed to create new genai client: %w", err)
 	}
 
+	if me.lastChat == nil {
+		log.Info("WTF. lastChat is nil")
+		return nil
+	}
+
+	//	if me.lastChat.Entries == nil {
+	//		me.lastChat.Entries = new(chatpb.ChatEntry)
+	//	}
+
+	// In a real application, you would get user input here.
+	// For now, we'll use a hardcoded prompt.
+	if len(me.lastChat.GetEntries()) == 0 {
+		me.lastChat.Entries = append(me.lastChat.Entries, &chatpb.ChatEntry{
+			Parts: []*chatpb.Part{
+				{PartType: &chatpb.Part_Text{Text: "hello, how are you"}},
+			},
+		})
+	}
+
+	lastEntry := me.lastChat.GetEntries()[len(me.lastChat.GetEntries())-1]
+	genaiContents, err := convertToGenai(lastEntry.GetGeminiRequest())
+	if err != nil {
+		return err
+	}
+
+	resp, err := me.client.Models.GenerateContent(me.ctx, "gemini-2.5-flash", genaiContents, nil)
+	if err != nil {
+		return log.Errorf("error sending message: %v", err)
+	}
+
+	if resp == nil || len(resp.Candidates) == 0 || resp.Candidates[0].Content == nil {
+		log.Info("Received an empty response from the API. Stopping.")
+		return nil
+	}
+
+	// Append the model's response to the history
+	me.lastChat.Entries = append(me.lastChat.Entries, convertToPB(resp))
+
+	// Check for a function call
+	hasFunctionCall := false
+	for _, part := range resp.Candidates[0].Content.Parts {
+		if fc := part.FunctionCall; fc != nil {
+			hasFunctionCall = true
+			functionResponse := handleFunctionCall(fc)
+			// Append the function response to the history for the next turn
+			me.lastChat.Entries = append(me.lastChat.Entries, &chatpb.ChatEntry{
+				Parts: []*chatpb.Part{
+					{PartType: &chatpb.Part_FunctionResponse{
+						FunctionResponse: &chatpb.FunctionResponse{
+							Name: functionResponse.Name,
+							// TODO: map response
+						},
+					}},
+				},
+			})
+		}
+	}
+
+	// If there was no function call, print the text and stop.
+	if !hasFunctionCall {
+		log.Info("Response from API:")
+		for _, cand := range resp.Candidates {
+			if cand.Content != nil {
+				for _, part := range cand.Content.Parts {
+					if part.Text != "" {
+						fmt.Println(part.Text)
+					}
+				}
+			}
+		}
+	}
+
 	return nil
 }
 

dumpchat.go

@@ -24,7 +24,7 @@ func dumpchat(chat *chatpb.Chat) error {
 		if lastEntry.GeminiRequest == nil {
 			return log.Errorf("lastEntry.GeminiRequest == nil")
 		}
-		aichat, err := convertToGenai(lastEntry.GeminiRequest)
+		aichat, err := convertToGenai(lastEntry.GetGeminiRequest())
 		if err != nil {
 			log.Info("convertToGenai() returned with error", err)
 			return err

handleFunctionCall.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+
+	"go.wit.com/log"
+	"google.golang.org/genai"
+)
+
+// handleFunctionCall executes a command requested by the Gemini API and returns the result.
+func handleFunctionCall(fc *genai.FunctionCall) *genai.FunctionResponse {
+	if fc == nil {
+		return nil
+	}
+
+	if fc.Name != "run_shell_command" {
+		log.Infof("Unsupported function call: %s", fc.Name)
+		return &genai.FunctionResponse{
+			Name: fc.Name,
+			Response: map[string]any{
+				"error": fmt.Sprintf("Unsupported function call: %s", fc.Name),
+			},
+		}
+	}
+
+	// Extract arguments
+	cmd, _ := fc.Args["command"].(string)
+	dir, _ := fc.Args["directory"].(string)
+
+	if cmd == "" {
+		return &genai.FunctionResponse{
+			Name: fc.Name,
+			Response: map[string]any{
+				"error": "missing command argument",
+			},
+		}
+	}
+
+	// Execute the command (this is a placeholder for the actual execution)
+	// In a real implementation, you would use the run_shell_command tool here.
+	log.Infof("Executing command: '%s' in directory: '%s'", cmd, dir)
+	// For now, we'll return a dummy response.
+	// TODO: Replace this with actual command execution.
+
+	return &genai.FunctionResponse{
+		Name: fc.Name,
+		Response: map[string]any{
+			"output": "command executed successfully (dummy response)",
+		},
+	}
+}