max iteration support for cagent new

references #227

Signed-off-by: Christopher Petito <chrisjpetito@gmail.com>

Author: krissetto

cmd/root/new.go

@@ -14,8 +14,9 @@ import (
 )
 
 var (
-	modelParam     string
-	maxTokensParam int
+	modelParam         string
+	maxTokensParam     int
+	maxIterationsParam int
 )
 
 // Cmd creates a new command to create a new agent configuration
@@ -93,7 +94,7 @@ func NewNewCmd() *cobra.Command {
 				fmt.Println()
 			}
 
-			out, err := creator.StreamCreateAgent(ctx, ".", prompt, runConfig, modelProvider, model, maxTokensParam)
+			out, rt, err := creator.StreamCreateAgent(ctx, ".", prompt, runConfig, modelProvider, model, maxTokensParam, maxIterationsParam)
 			if err != nil {
 				return err
 			}
@@ -126,6 +127,22 @@ func NewNewCmd() *cobra.Command {
 						llmIsTyping = false
 					}
 					printError(fmt.Errorf("%s", e.Error))
+				case *runtime.MaxIterationsReachedEvent:
+					if llmIsTyping {
+						fmt.Println()
+						llmIsTyping = false
+					}
+
+					result := promptMaxIterationsContinue(e.MaxIterations)
+					switch result {
+					case ConfirmationApprove:
+						rt.Resume(ctx, string(runtime.ResumeTypeApprove))
+					case ConfirmationReject:
+						rt.Resume(ctx, string(runtime.ResumeTypeReject))
+						return nil
+					case ConfirmationAbort:
+						rt.Resume(ctx, string(runtime.ResumeTypeReject))
+					}
 				}
 			}
 			fmt.Print("\n\n")
@@ -135,6 +152,7 @@ func NewNewCmd() *cobra.Command {
 	addGatewayFlags(cmd)
 	cmd.PersistentFlags().StringVar(&modelParam, "model", "", "Model to use, optionally as provider/model where provider is one of: anthropic, openai, google, dmr. If omitted, provider is auto-selected based on available credentials or gateway")
 	cmd.PersistentFlags().IntVar(&maxTokensParam, "max-tokens", 0, "Override max_tokens for the selected model (0 = default)")
+	cmd.PersistentFlags().IntVar(&maxIterationsParam, "max-iterations", 0, "Maximum number of agentic loop iterations to prevent infinite loops (default: 20 for DMR, unlimited for other providers)")
 
 	return cmd
 }

cmd/root/run.go

@@ -349,7 +349,7 @@ func runWithoutTUI(ctx context.Context, agentFilename string, rt runtime.Runtime
 		lastAgent := rt.CurrentAgent().Name()
 		llmIsTyping := false
 		var lastConfirmedToolCallID string
-		for event := range rt.RunStream(loopCtx, sess) {
+		for event := range rt.RunStream(loopCtx, sess, 0) {
 			if event.GetAgentName() != "" && (firstLoop || lastAgent != event.GetAgentName()) {
 				if !firstLoop {
 					if llmIsTyping {

cmd/root/run_text_utils.go

@@ -18,6 +18,7 @@ var (
 	yellow = color.New(color.FgYellow).SprintfFunc()
 	red    = color.New(color.FgRed).SprintfFunc()
 	gray   = color.New(color.FgHiBlack).SprintfFunc()
+	green  = color.New(color.FgGreen).SprintfFunc()
 )
 
 // text styles
@@ -115,6 +116,28 @@ func printToolCallResponse(toolCall tools.ToolCall, response string) {
 	fmt.Printf("\n%s\n", gray("%s response%s", bold(toolCall.Function.Name), formatToolCallResponse(response)))
 }
 
+func promptMaxIterationsContinue(maxIterations int) ConfirmationResult {
+	fmt.Printf("\n%s\n", yellow("⚠️  Maximum iterations (%d) reached. The agent may be stuck in a loop.", maxIterations))
+	fmt.Printf("%s\n", gray("This can happen with smaller or less capable models."))
+	fmt.Printf("\n%s (y/n): ", blue("Do you want to continue for 10 more iterations?"))
+
+	reader := bufio.NewReader(os.Stdin)
+	response, err := reader.ReadString('\n')
+	if err != nil {
+		fmt.Printf("\n%s\n", red("Failed to read input, exiting..."))
+		return ConfirmationAbort
+	}
+
+	response = strings.TrimSpace(strings.ToLower(response))
+	if response == "y" || response == "yes" {
+		fmt.Printf("%s\n\n", green("✓ Continuing..."))
+		return ConfirmationApprove
+	} else {
+		fmt.Printf("%s\n\n", gray("Exiting..."))
+		return ConfirmationReject
+	}
+}
+
 func formatToolCallArguments(arguments string) string {
 	if arguments == "" {
 		return "()"

examples/golibrary/stream/main.go

@@ -44,7 +44,7 @@ func main() {
 
 	sess := session.New(session.WithUserMessage("", "How are you doing?"))
 
-	events := rt.RunStream(ctx, sess)
+	events := rt.RunStream(ctx, sess, 0)
 	for event := range events {
 		switch e := event.(type) {
 		case *runtime.AgentChoiceEvent:

pkg/app/app.go

@@ -58,7 +58,7 @@ func (a *App) Run(ctx context.Context, message string) {
 
 		// User message
 		a.session.AddMessage(session.UserMessage(a.agentFilename, message))
-		for event := range a.runtime.RunStream(ctx, a.session) {
+		for event := range a.runtime.RunStream(ctx, a.session, 0) {
 			a.events <- event
 		}
 	}()

pkg/creator/agent.go

@@ -121,7 +121,14 @@ func CreateAgent(ctx context.Context, baseDir, prompt string, runConfig config.R
 	return messages[len(messages)-1].Message.Content, fsToolset.path, nil
 }
 
-func StreamCreateAgent(ctx context.Context, baseDir, prompt string, runConfig config.RuntimeConfig, providerName, modelNameOverride string, maxTokensOverride int) (<-chan runtime.Event, error) {
+func StreamCreateAgent(ctx context.Context, baseDir, prompt string, runConfig config.RuntimeConfig, providerName, modelNameOverride string, maxTokensOverride, maxIterations int) (<-chan runtime.Event, runtime.Runtime, error) {
+	// Apply default max iterations if not specified (0 means use defaults)
+	if maxIterations == 0 {
+		// Only when using DMR we set a default limit. Local models are more prone to loops
+		if providerName == "dmr" {
+			maxIterations = 20
+		}
+	}
 	defaultModels := map[string]string{
 		"openai":    "gpt-5-mini",
 		"anthropic": "claude-sonnet-4-0",
@@ -184,7 +191,7 @@ func StreamCreateAgent(ctx context.Context, baseDir, prompt string, runConfig co
 		options.WithGateway(runConfig.ModelsGateway),
 	)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create LLM client: %w", err)
+		return nil, nil, fmt.Errorf("failed to create LLM client: %w", err)
 	}
 
 	fmt.Println("Generating agent configuration....")
@@ -222,11 +229,11 @@ func StreamCreateAgent(ctx context.Context, baseDir, prompt string, runConfig co
 			)))
 	rt, err := runtime.New(newTeam)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create runtime: %w", err)
+		return nil, nil, fmt.Errorf("failed to create runtime: %w", err)
 	}
 
 	sess := session.New(session.WithUserMessage("", prompt))
 	sess.ToolsApproved = true
 
-	return rt.RunStream(ctx, sess), nil
+	return rt.RunStream(ctx, sess, maxIterations), rt, nil
 }

pkg/runtime/event.go

@@ -289,3 +289,22 @@ func (e *AuthorizationRequiredEvent) isEvent() {}
 func (e *AuthorizationRequiredEvent) GetAgentName() string {
 	return ""
 }
+
+type MaxIterationsReachedEvent struct {
+	Type          string `json:"type"`
+	MaxIterations int    `json:"max_iterations"`
+	AgentContext
+}
+
+func MaxIterationsReached(maxIterations int) Event {
+	return &MaxIterationsReachedEvent{
+		Type:          "max_iterations_reached",
+		MaxIterations: maxIterations,
+	}
+}
+
+func (e *MaxIterationsReachedEvent) isEvent() {}
+
+func (e *MaxIterationsReachedEvent) GetAgentName() string {
+	return e.AgentName
+}

pkg/runtime/remote_runtime.go

@@ -72,8 +72,9 @@ func (r *RemoteRuntime) CurrentAgent() *agent.Agent {
 	return agent.New(r.currentAgent, fmt.Sprintf("Remote agent: %s", r.currentAgent))
 }
 
-// RunStream starts the agent's interaction loop and returns a channel of events
-func (r *RemoteRuntime) RunStream(ctx context.Context, sess *session.Session) <-chan Event {
+// RunStream starts the agent's interaction loop with an optional iteration limit
+// If maxIterations is 0, there is no limit
+func (r *RemoteRuntime) RunStream(ctx context.Context, sess *session.Session, maxIterations int) <-chan Event {
 	slog.Debug("Starting remote runtime stream", "agent", r.currentAgent, "session_id", r.sessionID)
 	events := make(chan Event, 128)
 
@@ -125,7 +126,7 @@ func (r *RemoteRuntime) RunStream(ctx context.Context, sess *session.Session) <-
 
 // Run starts the agent's interaction loop and returns the final messages
 func (r *RemoteRuntime) Run(ctx context.Context, sess *session.Session) ([]session.Message, error) {
-	eventsChan := r.RunStream(ctx, sess)
+	eventsChan := r.RunStream(ctx, sess, 0)
 
 	for event := range eventsChan {
 		if errEvent, ok := event.(*ErrorEvent); ok {

pkg/runtime/runtime.go

@@ -40,7 +40,7 @@ type Runtime interface {
 	// CurrentAgent returns the currently active agent
 	CurrentAgent() *agent.Agent
 	// RunStream starts the agent's interaction loop and returns a channel of events
-	RunStream(ctx context.Context, sess *session.Session) <-chan Event
+	RunStream(ctx context.Context, sess *session.Session, maxIterations int) <-chan Event
 	// Run starts the agent's interaction loop and returns the final messages
 	Run(ctx context.Context, sess *session.Session) ([]session.Message, error)
 	// Resume allows resuming execution after user confirmation
@@ -168,8 +168,9 @@ func (r *runtime) finalizeEventChannel(ctx context.Context, sess *session.Sessio
 	}
 }
 
-// Run starts the agent's interaction loop
-func (r *runtime) RunStream(ctx context.Context, sess *session.Session) <-chan Event {
+// RunStream starts the agent's interaction loop with an optional iteration limit
+// If maxIterations is 0, there is no limit
+func (r *runtime) RunStream(ctx context.Context, sess *session.Session, maxIterations int) <-chan Event {
 	slog.Debug("Starting runtime stream", "agent", r.currentAgent, "session_id", sess.ID)
 	events := make(chan Event, 128)
 
@@ -206,7 +207,29 @@ func (r *runtime) RunStream(ctx context.Context, sess *session.Session) <-chan E
 			slog.Debug("Failed to get model definition", "error", err)
 		}
 
+		iteration := 0
 		for {
+			// Check iteration limit
+			if maxIterations > 0 && iteration >= maxIterations {
+				slog.Debug("Maximum iterations reached", "agent", a.Name(), "iterations", iteration, "max", maxIterations)
+				events <- MaxIterationsReached(maxIterations)
+
+				// Wait for user decision
+				select {
+				case resumeType := <-r.resumeChan:
+					if resumeType == ResumeTypeApprove {
+						slog.Debug("User chose to continue after max iterations", "agent", a.Name())
+						maxIterations = iteration + 10
+					} else {
+						slog.Debug("User chose to exit after max iterations", "agent", a.Name())
+						return
+					}
+				case <-ctx.Done():
+					slog.Debug("Context cancelled while waiting for max iterations decision", "agent", a.Name())
+					return
+				}
+			}
+			iteration++
 			// Exit immediately if the stream context has been cancelled (e.g., Ctrl+C)
 			if err := ctx.Err(); err != nil {
 				slog.Debug("Runtime stream context cancelled, stopping loop", "agent", a.Name(), "session_id", sess.ID)
@@ -402,7 +425,7 @@ func (r *runtime) ResumeCodeReceived(_ context.Context, code string) error {
 
 // Run starts the agent's interaction loop
 func (r *runtime) Run(ctx context.Context, sess *session.Session) ([]session.Message, error) {
-	eventsChan := r.RunStream(ctx, sess)
+	eventsChan := r.RunStream(ctx, sess, 0)
 
 	for event := range eventsChan {
 		if errEvent, ok := event.(*ErrorEvent); ok {
@@ -821,7 +844,7 @@ func (r *runtime) handleTaskTransfer(ctx context.Context, sess *session.Session,
 	s.Title = "Transferred task"
 	s.ToolsApproved = sess.ToolsApproved
 
-	for event := range r.RunStream(ctx, s) {
+	for event := range r.RunStream(ctx, s, 0) {
 		evts <- event
 		if errEvent, ok := event.(*ErrorEvent); ok {
 			span.RecordError(fmt.Errorf("%s", errEvent.Error))

pkg/server/server.go

@@ -883,7 +883,7 @@ func (s *Server) runAgent(c echo.Context) error {
 	c.Response().Header().Set("Connection", "keep-alive")
 	c.Response().WriteHeader(http.StatusOK)
 
-	streamChan := rt.RunStream(c.Request().Context(), sess)
+	streamChan := rt.RunStream(c.Request().Context(), sess, 0)
 	for event := range streamChan {
 		data, err := json.Marshal(event)
 		if err != nil {