Update maxToolRounds to accept TurnContext-based function

- Changed MaxToolRounds type to accept (context: TurnContext) => boolean
- Removed old 3-parameter function signature for simplicity
- Function receives full TurnContext with numberOfTurns, messageHistory, model/models
- Returns true to allow another turn, false to stop execution
- Updated examples to demonstrate the new function signature
- Simplified implementation logic in response-wrapper.ts

This provides more context to the maxToolRounds function and makes
the API more consistent with tool execute functions.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: Matt Apperson

examples/tools-example.ts

@@ -10,6 +10,13 @@
  *
  * The API is simple: just call getResponse() with tools, and await the result.
  * Tools are executed transparently before getMessage() or getText() returns!
+ *
+ * maxToolRounds can be:
+ * - A number: Maximum number of tool execution rounds (default: 5)
+ * - A function: (context: TurnContext) => boolean
+ *   - Return true to allow another turn
+ *   - Return false to stop execution
+ *   - Context includes: numberOfTurns, messageHistory, model/models
  */
 
 import { OpenRouter } from "../src/index.js";
@@ -60,6 +67,11 @@ async function basicToolExample() {
     model: "openai/gpt-4o",
     input: "What's the weather like in San Francisco?",
     tools: [weatherTool],
+    // Example: limit to 3 turns using a function
+    maxToolRounds: (context) => {
+      console.log(`Checking if we should continue (currently on turn ${context.numberOfTurns})`);
+      return context.numberOfTurns < 3; // Allow up to 3 turns
+    },
   });
 
   // Tools are automatically executed! Just get the final message

src/funcs/getResponse.ts

@@ -58,7 +58,7 @@ import { convertEnhancedToolsToAPIFormat } from "../lib/tool-executor.js";
  *       }
  *     }
  *   }],
- *   maxToolRounds: 5, // or function: (round, calls, responses) => boolean
+ *   maxToolRounds: 5, // or function: (context: TurnContext) => boolean
  * });
  * const message = await response.getMessage(); // Tools auto-executed!
  *

src/lib/response-wrapper.ts

@@ -179,11 +179,14 @@ export class ResponseWrapper {
             break;
           }
         } else if (typeof maxToolRounds === "function") {
-          const shouldContinue = maxToolRounds(
-            currentRound,
-            currentToolCalls,
-            this.allToolExecutionRounds.map((r) => r.response)
-          );
+          // Function signature: (context: TurnContext) => boolean
+          const turnContext: TurnContext = {
+            numberOfTurns: currentRound + 1,
+            messageHistory: currentInput,
+            ...(this.options.request.model && { model: this.options.request.model }),
+            ...(this.options.request.models && { models: this.options.request.models }),
+          };
+          const shouldContinue = maxToolRounds(turnContext);
           if (!shouldContinue) {
             break;
           }

src/lib/tool-types.ts

@@ -159,11 +159,7 @@ export interface ToolExecutionResult {
  */
 export type MaxToolRounds =
   | number
-  | ((
-      round: number,
-      toolCalls: ParsedToolCall[],
-      responses: any[] // OpenResponsesNonStreamingResponse[]
-    ) => boolean); // Return true to continue, false to stop
+  | ((context: TurnContext) => boolean); // Return true to allow another turn, false to stop
 
 /**
  * Result of executeTools operation