Enhance tool calling to support multi-step orchestration

This commit improves the Meta Llama tool calling infinite loop fix by
replacing the overly restrictive single-tool limitation with intelligent
multi-step support that allows up to 8 sequential tool calls.

Changes:
- Add max_sequential_tool_calls parameter (default: 8) to OCIGenAIBase
- Implement loop detection algorithm that identifies when the same tool
  is called repeatedly with identical arguments
- Replace unconditional tool_choice="none" with conditional logic that
  only forces stop when limit exceeded or loop detected
- Otherwise allow default model behavior for continued tool calling

Benefits:
- Prevents infinite loops (original goal maintained)
- Enables multi-step tool orchestration (new capability)
- Fully backward compatible via default parameter
- Configurable per use case
- Domain-agnostic implementation

Tested with integration tests showing successful multi-step workflows
for diagnostic and remediation scenarios.

Author: fede-kamel

libs/oci/langchain_oci/chat_models/oci_generative_ai.py

@@ -747,14 +747,71 @@ def messages_to_oci_params(
             "api_format": self.chat_api_format,
         }
 
-        # BUGFIX: If tool results have been received and tools are bound,
-        # set tool_choice to "none" to prevent the model from making
-        # additional tool calls in a loop.
+        # BUGFIX: Intelligently manage tool_choice to prevent infinite loops
+        # while allowing legitimate multi-step tool orchestration.
         # This addresses a known issue with Meta Llama models that
         # continue calling tools even after receiving results.
+
+        def _should_allow_more_tool_calls(
+            messages: List[BaseMessage],
+            max_tool_calls: int
+        ) -> bool:
+            """
+            Determine if the model should be allowed to call more tools.
+
+            Returns False (force stop) if:
+            - Tool call limit exceeded
+            - Infinite loop detected (same tool called repeatedly with same args)
+
+            Returns True otherwise to allow multi-step tool orchestration.
+
+            Args:
+                messages: Conversation history
+                max_tool_calls: Maximum number of tool calls before forcing stop
+            """
+            # Count total tool calls made so far
+            tool_call_count = sum(
+                1 for msg in messages
+                if isinstance(msg, ToolMessage)
+            )
+
+            # Safety limit: prevent runaway tool calling
+            if tool_call_count >= max_tool_calls:
+                return False
+
+            # Detect infinite loop: same tool called with same arguments in succession
+            recent_calls = []
+            for msg in reversed(messages):
+                if hasattr(msg, 'tool_calls') and msg.tool_calls:
+                    for tc in msg.tool_calls:
+                        # Create signature: (tool_name, sorted_args)
+                        try:
+                            args_str = json.dumps(tc.get('args', {}), sort_keys=True)
+                            signature = (tc.get('name', ''), args_str)
+
+                            # Check if this exact call was made in last 2 calls
+                            if signature in recent_calls[-2:]:
+                                return False  # Infinite loop detected
+
+                            recent_calls.append(signature)
+                        except Exception:
+                            # If we can't serialize args, be conservative and continue
+                            pass
+
+                # Only check last 4 AI messages (last 4 tool call attempts)
+                if len(recent_calls) >= 4:
+                    break
+
+            return True
+
         has_tool_results = any(isinstance(msg, ToolMessage) for msg in messages)
         if has_tool_results and "tools" in kwargs and "tool_choice" not in kwargs:
-            result["tool_choice"] = self.oci_tool_choice_none()
+            if not _should_allow_more_tool_calls(
+                messages, self.max_sequential_tool_calls
+            ):
+                # Force model to stop and provide final answer
+                result["tool_choice"] = self.oci_tool_choice_none()
+            # else: Allow model to decide (default behavior)
 
         return result
 

libs/oci/langchain_oci/llms/oci_generative_ai.py

@@ -116,6 +116,10 @@ class OCIGenAIBase(BaseModel, ABC):
     is_stream: bool = False
     """Whether to stream back partial progress"""
 
+    max_sequential_tool_calls: int = 8
+    """Maximum tool calls before forcing final answer.
+    Prevents infinite loops while allowing multi-step orchestration."""
+
     model_config = ConfigDict(
         extra="forbid", arbitrary_types_allowed=True, protected_namespaces=()
     )