webscout 3.0b0__py3-none-any.whl → 3.1__py3-none-any.whl

webscout/Local/__init__.py

@@ -8,3 +8,4 @@ from . import utils
 
 from .model  import Model
 from .thread import Thread
+from .rawdog import *

webscout/Local/_version.py

@@ -1,3 +1,3 @@
 from llama_cpp import __version__ as __llama_cpp_version__
 
-__version__ = '2.9'
+__version__ = '3.1'

webscout/Local/model.py

@@ -27,6 +27,8 @@ class ModelUnloadedException(Exception):
     """Exception raised when trying to use a Model that has been unloaded"""
     def __init__(self, message):
         self.message = message
+        self.tool_code_start = "```tool_code\n"  # Define tool code markers
+        self.tool_code_end = "\n```tool_code```"
         super().__init__(self.message)
         self.add_note('Are you trying to use a Model that has been unloaded?')
 
@@ -271,51 +273,41 @@ class Model:
             print_verbose(f" gguf: rope_freq_base_train == {rope_freq_base_train}")
             print_verbose(f"param: rope_freq_base       == {rope_freq_base}")
     def register_tool(self, name: str, function: Callable):
-        """
-        Registers a tool for function calling.
-
-        Args:
-            name: The name of the tool.
-            function: The Python function to execute when the tool is called.
-        """
+        """Registers a tool for function calling."""
         self.tools[name] = function
 
     def _extract_tool_code(self, text: str) -> dict:
-        """
-        Extracts tool code from the model's output using the chatml-function-calling format.
-        
-        Args:
-            text: The model's generated text.
-
-        Returns:
-            A dictionary containing the tool name and arguments, or None if no tool call is found.
-        """
+        """Extracts tool code from the model's output."""
         try:
-            # Assuming tool code is enclosed in ```tool_code\n...\n```tool_code```
-            start = text.find("```tool_code\n") + len("```tool_code\n")
-            end = text.find("\n```tool_code```")
+            start = text.find(self.tool_code_start) + len(self.tool_code_start)
+            end = text.find(self.tool_code_end)
             tool_code_json = text[start:end]
             tool_code = json.loads(tool_code_json)
             return tool_code
         except (ValueError, json.JSONDecodeError):
             return None
-
+    def _should_call_tool(self, response_text: str) -> bool:
+        """Determines if the model suggests a tool call."""
+        # Simple check for tool code markers in response
+        return self.tool_code_start in response_text and self.tool_code_end in response_text
     def generate(
         self,
         prompt: Union[str, list[int]],
         stops: list[Union[str, int]] = [],
-        sampler: SamplerSettings = DefaultSampling
+        sampler: SamplerSettings = DefaultSampling,
+        max_iterations: int = 3, # Maximum iterations for tool calls
     ) -> str:
         """
-        Given a prompt, return a generated string, potentially calling and executing tools.
+        Generates text and handles tool calls.
 
         Args:
-            prompt: The text from which to generate.
-            stops: A list of strings and/or token IDs at which to end the generation early.
-            sampler: The SamplerSettings object used to control text generation.
+            prompt (Union[str, list[int]]): The input prompt.
+            stops (list[Union[str, int]]): Stop sequences.
+            sampler (SamplerSettings): Sampler settings.
+            max_iterations (int): Maximum number of tool call iterations. 
 
         Returns:
-            The generated string.
+            str: The generated text.
         """
         assert_model_is_loaded(self)
         response_text = self.llama.create_completion(
@@ -331,15 +323,21 @@ class Model:
             stop=stops
         )['choices'][0]['text']
 
-        tool_code = self._extract_tool_code(response_text)
-        if tool_code:
-            # Execute the tool and get its output
-            tool_name = tool_code.get("function", {}).get("name")
-            arguments = tool_code.get("function", {}).get("arguments", "")
-            if tool_name and arguments and tool_name in self.tools:
-                tool_output = self.tools[tool_name](**json.loads(arguments))
-                # Append the tool output to the response
-                response_text += f"\n{tool_output}" 
+        iteration = 0
+        while self._should_call_tool(response_text) and iteration < max_iterations:
+            tool_code = self._extract_tool_code(response_text)
+            if tool_code:
+                tool_name = tool_code.get("function", {}).get("name")
+                arguments = tool_code.get("function", {}).get("arguments", "")
+                if tool_name and arguments and tool_name in self.tools:
+                    # Execute the tool and append its output
+                    tool_output = self.tools[tool_name](**json.loads(arguments))
+                    response_text = response_text.replace(
+                        f"{self.tool_code_start}{json.dumps(tool_code)}{self.tool_code_end}", 
+                        tool_output
+                    )
+            iteration += 1
+
         return response_text
     def __repr__(self) -> str:
         return \