ChatModel: throw ToolExecutionLimitExceededException when over limit tool calling

lambochen · lambochen · commit 86ba6561c239 · 2025-06-24T16:14:31.000+08:00
Signed-off-by: lambochen &lt;lambochen@yeah.net&gt;
diff --git a/models/spring-ai-anthropic/src/main/java/org/springframework/ai/anthropic/AnthropicChatModel.java b/models/spring-ai-anthropic/src/main/java/org/springframework/ai/anthropic/AnthropicChatModel.java
@@ -30,6 +30,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
@@ -223,6 +224,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons
 						response, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 	}
@@ -287,6 +291,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha
 									chatResponse, iterations + 1);
 						}
 					}).subscribeOn(Schedulers.boundedElastic());
+				} else if(this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){
+					throw new ToolExecutionLimitExceededException(iterations);
 				}
 
 				return Mono.just(chatResponse);
diff --git a/models/spring-ai-azure-openai/src/main/java/org/springframework/ai/azure/openai/AzureOpenAiChatModel.java b/models/spring-ai-azure-openai/src/main/java/org/springframework/ai/azure/openai/AzureOpenAiChatModel.java
@@ -62,6 +62,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.scheduler.Schedulers;
 
@@ -291,6 +292,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons
 						response, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 	}
@@ -408,6 +412,9 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha
 						}
 					}).subscribeOn(Schedulers.boundedElastic());
 				}
+				else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+					throw new ToolExecutionLimitExceededException(iterations);
+				}
 
 				Flux<ChatResponse> flux = Flux.just(chatResponse)
 					.doOnError(observation::error)
diff --git a/models/spring-ai-bedrock-converse/src/main/java/org/springframework/ai/bedrock/converse/BedrockProxyChatModel.java b/models/spring-ai-bedrock-converse/src/main/java/org/springframework/ai/bedrock/converse/BedrockProxyChatModel.java
@@ -33,6 +33,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Sinks;
 import reactor.core.publisher.Sinks.EmitFailureHandler;
@@ -262,6 +263,10 @@ private ChatResponse internalCall(Prompt prompt, ChatResponse perviousChatRespon
 						chatResponse, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
+
 		return chatResponse;
 	}
 
@@ -711,6 +716,9 @@ private Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse perviousCh
 						}
 					}).subscribeOn(Schedulers.boundedElastic());
 				}
+				else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+					throw new ToolExecutionLimitExceededException(iterations);
+				}
 				else {
 					return Flux.just(chatResponse);
 				}
diff --git a/models/spring-ai-deepseek/src/main/java/org/springframework/ai/deepseek/DeepSeekChatModel.java b/models/spring-ai-deepseek/src/main/java/org/springframework/ai/deepseek/DeepSeekChatModel.java
@@ -25,6 +25,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
@@ -225,6 +226,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons
 						response, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 	}
@@ -311,6 +315,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha
 									response, iterations + 1);
 						}
 					}).subscribeOn(Schedulers.boundedElastic());
+				} else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){
+					throw new ToolExecutionLimitExceededException(iterations);
 				}
 				else {
 					return Flux.just(response);
diff --git a/models/spring-ai-minimax/src/main/java/org/springframework/ai/minimax/MiniMaxChatModel.java b/models/spring-ai-minimax/src/main/java/org/springframework/ai/minimax/MiniMaxChatModel.java
@@ -26,6 +26,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
@@ -315,6 +316,9 @@ else if (!CollectionUtils.isEmpty(choice.messages())) {
 						iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(requestPrompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 	}
@@ -398,7 +402,10 @@ private Flux<ChatResponse> internalStream(Prompt requestPrompt, int iterations)
 									return this.internalStream(new Prompt(toolExecutionResult.conversationHistory(), requestPrompt.getOptions()), iterations + 1);
 								}
 							}).subscribeOn(Schedulers.boundedElastic());
+						} else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(requestPrompt.getOptions(), iterations)){
+							throw new ToolExecutionLimitExceededException(iterations);
 						}
+
 						return Flux.just(response);
 					})
 					.doOnError(observation::error)
diff --git a/models/spring-ai-mistral-ai/src/main/java/org/springframework/ai/mistralai/MistralAiChatModel.java b/models/spring-ai-mistral-ai/src/main/java/org/springframework/ai/mistralai/MistralAiChatModel.java
@@ -27,6 +27,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
@@ -246,6 +247,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons
 						response, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 	}
@@ -340,6 +344,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha
 									response, iterations + 1);
 						}
 					}).subscribeOn(Schedulers.boundedElastic());
+				} else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){
+					throw new ToolExecutionLimitExceededException(iterations);
 				}
 				else {
 					return Flux.just(response);
diff --git a/models/spring-ai-ollama/src/main/java/org/springframework/ai/ollama/OllamaChatModel.java b/models/spring-ai-ollama/src/main/java/org/springframework/ai/ollama/OllamaChatModel.java
@@ -28,6 +28,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.scheduler.Schedulers;
 
@@ -293,6 +294,9 @@ private ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespon
 						response, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 	}
@@ -367,6 +371,8 @@ private Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCh
 									response, iterations + 1);
 						}
 					}).subscribeOn(Schedulers.boundedElastic());
+				} else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){
+					throw new ToolExecutionLimitExceededException(iterations);
 				}
 				else {
 					return Flux.just(response);
diff --git a/models/spring-ai-openai/src/main/java/org/springframework/ai/openai/OpenAiChatModel.java b/models/spring-ai-openai/src/main/java/org/springframework/ai/openai/OpenAiChatModel.java
@@ -29,6 +29,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
@@ -261,6 +262,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons
 						response, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 	}
@@ -389,6 +393,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha
 									response, iterations + 1);
 						}
 					}).subscribeOn(Schedulers.boundedElastic());
+				} else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){
+					throw new ToolExecutionLimitExceededException(iterations);
 				}
 				else {
 					return Flux.just(response);
diff --git a/models/spring-ai-vertex-ai-gemini/src/main/java/org/springframework/ai/vertexai/gemini/VertexAiGeminiChatModel.java b/models/spring-ai-vertex-ai-gemini/src/main/java/org/springframework/ai/vertexai/gemini/VertexAiGeminiChatModel.java
@@ -49,6 +49,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.scheduler.Schedulers;
 
@@ -446,6 +447,9 @@ private ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespon
 						response, iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
 
 		return response;
 
@@ -572,6 +576,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha
 										iterations + 1);
 							}
 						}).subscribeOn(Schedulers.boundedElastic());
+					} else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){
+						throw new ToolExecutionLimitExceededException(iterations);
 					}
 					else {
 						return Flux.just(response);
diff --git a/models/spring-ai-zhipuai/src/main/java/org/springframework/ai/zhipuai/ZhiPuAiChatModel.java b/models/spring-ai-zhipuai/src/main/java/org/springframework/ai/zhipuai/ZhiPuAiChatModel.java
@@ -27,6 +27,7 @@
 import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
@@ -301,6 +302,10 @@ private ChatResponse internalCall(Prompt requestPrompt, int iterations) {
 						iterations + 1);
 			}
 		}
+		else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(requestPrompt.getOptions(), iterations)) {
+			throw new ToolExecutionLimitExceededException(iterations);
+		}
+
 		return response;
 	}
 
@@ -387,6 +392,8 @@ private Flux<ChatResponse> internalStream(Prompt prompt, int iterations) {
 											iterations + 1);
 								}
 							}).subscribeOn(Schedulers.boundedElastic());
+						} else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){
+							throw new ToolExecutionLimitExceededException(iterations);
 						}
 						return Flux.just(response);
 					})
diff --git a/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolCallingChatOptions.java b/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolCallingChatOptions.java
@@ -85,15 +85,18 @@ public interface ToolCallingChatOptions extends ChatOptions {
 	void setInternalToolExecutionEnabled(@Nullable Boolean internalToolExecutionEnabled);
 
 	/**
-	 * Get the maximum number of iteration for tool execution.
+	 * Get the maximum number of iteration for tool execution. If the number of iterations
+	 * exceeds the limit, an {@link ToolExecutionLimitExceededException} will be thrown.
 	 * @return the maximum number of iteration.
 	 * @see #getInternalToolExecutionEnabled()
+	 * @see ToolExecutionLimitExceededException
 	 */
 	@Nullable
 	Integer getInternalToolExecutionMaxIterations();
 
 	/**
-	 * Set the maximum number of iteration for tool execution.
+	 * Set the maximum number of iteration for tool execution. If the number of iterations
+	 * exceeds the limit, an {@link ToolExecutionLimitExceededException} will be thrown.
 	 * @param internalToolExecutionMaxIterations the maximum number of iteration.
 	 */
 	void setInternalToolExecutionMaxIterations(@Nullable Integer internalToolExecutionMaxIterations);
diff --git a/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolExecutionEligibilityChecker.java b/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolExecutionEligibilityChecker.java
@@ -103,14 +103,25 @@ default boolean isInternalToolExecutionEnabled(ChatOptions chatOptions) {
 	default boolean isInternalToolExecutionEnabled(ChatOptions chatOptions, int toolExecutionIterations) {
 		boolean internalToolExecutionEnabled = isInternalToolExecutionEnabled(chatOptions);
 		if (!internalToolExecutionEnabled) {
-			return internalToolExecutionEnabled;
+			return false;
 		}
 
-		if (chatOptions instanceof ToolCallingChatOptions toolCallingChatOptions) {
+		return !isLimitExceeded(chatOptions, toolExecutionIterations);
+	}
+
+	/**
+	 * Determines if the tool execution limit has been exceeded.
+	 * @param promptOptions The options from the prompt
+	 * @param toolExecutionIterations The number of toolExecutionIterations
+	 * @return true if the tool execution limit has been exceeded, false otherwise
+	 */
+	default boolean isLimitExceeded(ChatOptions promptOptions, int toolExecutionIterations) {
+		if (promptOptions instanceof ToolCallingChatOptions toolCallingChatOptions) {
 			return toolCallingChatOptions.getInternalToolExecutionMaxIterations() == null
 					|| toolExecutionIterations <= toolCallingChatOptions.getInternalToolExecutionMaxIterations();
 		}
-		return internalToolExecutionEnabled;
+
+		return false;
 	}
 
 }
diff --git a/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolExecutionEligibilityPredicate.java b/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolExecutionEligibilityPredicate.java
@@ -57,14 +57,25 @@ default boolean isToolExecutionRequired(ChatOptions promptOptions, ChatResponse
 			int toolExecutionIterations) {
 		boolean isToolExecutionRequired = isToolExecutionRequired(promptOptions, chatResponse);
 		if (!isToolExecutionRequired) {
-			return isToolExecutionRequired;
+			return false;
 		}
 
+		return !isLimitExceeded(promptOptions, toolExecutionIterations);
+	}
+
+	/**
+	 * Determines if the tool execution limit has been exceeded.
+	 * @param promptOptions The options from the prompt
+	 * @param toolExecutionIterations The number of toolExecutionIterations
+	 * @return true if the tool execution limit has been exceeded, false otherwise
+	 */
+	default boolean isLimitExceeded(ChatOptions promptOptions, int toolExecutionIterations) {
 		if (promptOptions instanceof ToolCallingChatOptions toolCallingChatOptions) {
 			return toolCallingChatOptions.getInternalToolExecutionMaxIterations() == null
 					|| toolExecutionIterations <= toolCallingChatOptions.getInternalToolExecutionMaxIterations();
 		}
-		return isToolExecutionRequired;
+
+		return false;
 	}
 
 }
diff --git a/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolExecutionLimitExceededException.java b/spring-ai-model/src/main/java/org/springframework/ai/model/tool/ToolExecutionLimitExceededException.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2025-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.ai.model.tool;
+
+/**
+ * Exception thrown when the tool execution limit is exceeded.
+ *
+ * @author lambochen
+ * @see ToolCallingChatOptions#getInternalToolExecutionMaxIterations()
+ */
+public class ToolExecutionLimitExceededException extends RuntimeException {
+
+	private final Integer maxIterations;
+
+	public ToolExecutionLimitExceededException(Integer maxIterations) {
+		this("Tool execution limit exceeded: " + maxIterations, maxIterations);
+	}
+
+	public ToolExecutionLimitExceededException(String message, Integer maxIterations) {
+		super(message);
+		this.maxIterations = maxIterations;
+	}
+
+	public Integer getMaxIterations() {
+		return maxIterations;
+	}
+
+}

Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@`
`30`	`30`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`31`	`31`	`import org.slf4j.Logger;`
`32`	`32`	`import org.slf4j.LoggerFactory;`
	`33`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`33`	`34`	`import reactor.core.publisher.Flux;`
`34`	`35`	`import reactor.core.publisher.Mono;`
`35`	`36`	`import reactor.core.scheduler.Schedulers;`
`@@ -223,6 +224,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons`
`223`	`224`	`response, iterations + 1);`
`224`	`225`	`}`
`225`	`226`	`}`
	`227`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`228`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`229`	`+ }`
`226`	`230`
`227`	`231`	`return response;`
`228`	`232`	`}`
`@@ -287,6 +291,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha`
`287`	`291`	`chatResponse, iterations + 1);`
`288`	`292`	`}`
`289`	`293`	`}).subscribeOn(Schedulers.boundedElastic());`
	`294`	`+ } else if(this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){`
	`295`	`+ throw new ToolExecutionLimitExceededException(iterations);`
`290`	`296`	`}`
`291`	`297`
`292`	`298`	`return Mono.just(chatResponse);`
Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,7 @@`
`62`	`62`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`63`	`63`	`import org.slf4j.Logger;`
`64`	`64`	`import org.slf4j.LoggerFactory;`
	`65`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`65`	`66`	`import reactor.core.publisher.Flux;`
`66`	`67`	`import reactor.core.scheduler.Schedulers;`
`67`	`68`
`@@ -291,6 +292,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons`
`291`	`292`	`response, iterations + 1);`
`292`	`293`	`}`
`293`	`294`	`}`
	`295`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`296`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`297`	`+ }`
`294`	`298`
`295`	`299`	`return response;`
`296`	`300`	`}`
`@@ -408,6 +412,9 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha`
`408`	`412`	`}`
`409`	`413`	`}).subscribeOn(Schedulers.boundedElastic());`
`410`	`414`	`}`
	`415`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`416`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`417`	`+ }`
`411`	`418`
`412`	`419`	`Flux<ChatResponse> flux = Flux.just(chatResponse)`
`413`	`420`	`.doOnError(observation::error)`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@`
`33`	`33`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`34`	`34`	`import org.slf4j.Logger;`
`35`	`35`	`import org.slf4j.LoggerFactory;`
	`36`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`36`	`37`	`import reactor.core.publisher.Flux;`
`37`	`38`	`import reactor.core.publisher.Sinks;`
`38`	`39`	`import reactor.core.publisher.Sinks.EmitFailureHandler;`
`@@ -262,6 +263,10 @@ private ChatResponse internalCall(Prompt prompt, ChatResponse perviousChatRespon`
`262`	`263`	`chatResponse, iterations + 1);`
`263`	`264`	`}`
`264`	`265`	`}`
	`266`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`267`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`268`	`+ }`
	`269`	`+`
`265`	`270`	`return chatResponse;`
`266`	`271`	`}`
`267`	`272`
`@@ -711,6 +716,9 @@ private Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse perviousCh`
`711`	`716`	`}`
`712`	`717`	`}).subscribeOn(Schedulers.boundedElastic());`
`713`	`718`	`}`
	`719`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`720`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`721`	`+ }`
`714`	`722`	`else {`
`715`	`723`	`return Flux.just(chatResponse);`
`716`	`724`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@`
`25`	`25`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`26`	`26`	`import org.slf4j.Logger;`
`27`	`27`	`import org.slf4j.LoggerFactory;`
	`28`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`28`	`29`	`import reactor.core.publisher.Flux;`
`29`	`30`	`import reactor.core.publisher.Mono;`
`30`	`31`	`import reactor.core.scheduler.Schedulers;`
`@@ -225,6 +226,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons`
`225`	`226`	`response, iterations + 1);`
`226`	`227`	`}`
`227`	`228`	`}`
	`229`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`230`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`231`	`+ }`
`228`	`232`
`229`	`233`	`return response;`
`230`	`234`	`}`
`@@ -311,6 +315,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha`
`311`	`315`	`response, iterations + 1);`
`312`	`316`	`}`
`313`	`317`	`}).subscribeOn(Schedulers.boundedElastic());`
	`318`	`+ } else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){`
	`319`	`+ throw new ToolExecutionLimitExceededException(iterations);`
`314`	`320`	`}`
`315`	`321`	`else {`
`316`	`322`	`return Flux.just(response);`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@`
`26`	`26`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`27`	`27`	`import org.slf4j.Logger;`
`28`	`28`	`import org.slf4j.LoggerFactory;`
	`29`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`29`	`30`	`import reactor.core.publisher.Flux;`
`30`	`31`	`import reactor.core.publisher.Mono;`
`31`	`32`	`import reactor.core.scheduler.Schedulers;`
`@@ -315,6 +316,9 @@ else if (!CollectionUtils.isEmpty(choice.messages())) {`
`315`	`316`	`iterations + 1);`
`316`	`317`	`}`
`317`	`318`	`}`
	`319`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(requestPrompt.getOptions(), iterations)) {`
	`320`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`321`	`+ }`
`318`	`322`
`319`	`323`	`return response;`
`320`	`324`	`}`
`@@ -398,7 +402,10 @@ private Flux<ChatResponse> internalStream(Prompt requestPrompt, int iterations)`
`398`	`402`	`return this.internalStream(new Prompt(toolExecutionResult.conversationHistory(), requestPrompt.getOptions()), iterations + 1);`
`399`	`403`	`}`
`400`	`404`	`}).subscribeOn(Schedulers.boundedElastic());`
	`405`	`+ } else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(requestPrompt.getOptions(), iterations)){`
	`406`	`+ throw new ToolExecutionLimitExceededException(iterations);`
`401`	`407`	`}`
	`408`	`+`
`402`	`409`	`return Flux.just(response);`
`403`	`410`	`})`
`404`	`411`	`.doOnError(observation::error)`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@`
`27`	`27`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`28`	`28`	`import org.slf4j.Logger;`
`29`	`29`	`import org.slf4j.LoggerFactory;`
	`30`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`30`	`31`	`import reactor.core.publisher.Flux;`
`31`	`32`	`import reactor.core.publisher.Mono;`
`32`	`33`	`import reactor.core.scheduler.Schedulers;`
`@@ -246,6 +247,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons`
`246`	`247`	`response, iterations + 1);`
`247`	`248`	`}`
`248`	`249`	`}`
	`250`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`251`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`252`	`+ }`
`249`	`253`
`250`	`254`	`return response;`
`251`	`255`	`}`
`@@ -340,6 +344,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha`
`340`	`344`	`response, iterations + 1);`
`341`	`345`	`}`
`342`	`346`	`}).subscribeOn(Schedulers.boundedElastic());`
	`347`	`+ } else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){`
	`348`	`+ throw new ToolExecutionLimitExceededException(iterations);`
`343`	`349`	`}`
`344`	`350`	`else {`
`345`	`351`	`return Flux.just(response);`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@`
`28`	`28`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`29`	`29`	`import org.slf4j.Logger;`
`30`	`30`	`import org.slf4j.LoggerFactory;`
	`31`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`31`	`32`	`import reactor.core.publisher.Flux;`
`32`	`33`	`import reactor.core.scheduler.Schedulers;`
`33`	`34`
`@@ -293,6 +294,9 @@ private ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespon`
`293`	`294`	`response, iterations + 1);`
`294`	`295`	`}`
`295`	`296`	`}`
	`297`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`298`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`299`	`+ }`
`296`	`300`
`297`	`301`	`return response;`
`298`	`302`	`}`
`@@ -367,6 +371,8 @@ private Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCh`
`367`	`371`	`response, iterations + 1);`
`368`	`372`	`}`
`369`	`373`	`}).subscribeOn(Schedulers.boundedElastic());`
	`374`	`+ } else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){`
	`375`	`+ throw new ToolExecutionLimitExceededException(iterations);`
`370`	`376`	`}`
`371`	`377`	`else {`
`372`	`378`	`return Flux.just(response);`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@`
`29`	`29`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`30`	`30`	`import org.slf4j.Logger;`
`31`	`31`	`import org.slf4j.LoggerFactory;`
	`32`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`32`	`33`	`import reactor.core.publisher.Flux;`
`33`	`34`	`import reactor.core.publisher.Mono;`
`34`	`35`	`import reactor.core.scheduler.Schedulers;`
`@@ -261,6 +262,9 @@ public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespons`
`261`	`262`	`response, iterations + 1);`
`262`	`263`	`}`
`263`	`264`	`}`
	`265`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`266`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`267`	`+ }`
`264`	`268`
`265`	`269`	`return response;`
`266`	`270`	`}`
`@@ -389,6 +393,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha`
`389`	`393`	`response, iterations + 1);`
`390`	`394`	`}`
`391`	`395`	`}).subscribeOn(Schedulers.boundedElastic());`
	`396`	`+ } else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){`
	`397`	`+ throw new ToolExecutionLimitExceededException(iterations);`
`392`	`398`	`}`
`393`	`399`	`else {`
`394`	`400`	`return Flux.just(response);`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,7 @@`
`49`	`49`	`import io.micrometer.observation.contextpropagation.ObservationThreadLocalAccessor;`
`50`	`50`	`import org.slf4j.Logger;`
`51`	`51`	`import org.slf4j.LoggerFactory;`
	`52`	`+import org.springframework.ai.model.tool.ToolExecutionLimitExceededException;`
`52`	`53`	`import reactor.core.publisher.Flux;`
`53`	`54`	`import reactor.core.scheduler.Schedulers;`
`54`	`55`
`@@ -446,6 +447,9 @@ private ChatResponse internalCall(Prompt prompt, ChatResponse previousChatRespon`
`446`	`447`	`response, iterations + 1);`
`447`	`448`	`}`
`448`	`449`	`}`
	`450`	`+ else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)) {`
	`451`	`+ throw new ToolExecutionLimitExceededException(iterations);`
	`452`	`+ }`
`449`	`453`
`450`	`454`	`return response;`
`451`	`455`
`@@ -572,6 +576,8 @@ public Flux<ChatResponse> internalStream(Prompt prompt, ChatResponse previousCha`
`572`	`576`	`iterations + 1);`
`573`	`577`	`}`
`574`	`578`	`}).subscribeOn(Schedulers.boundedElastic());`
	`579`	`+ } else if (this.toolExecutionEligibilityPredicate.isLimitExceeded(prompt.getOptions(), iterations)){`
	`580`	`+ throw new ToolExecutionLimitExceededException(iterations);`
`575`	`581`	`}`
`576`	`582`	`else {`
`577`	`583`	`return Flux.just(response);`