lm-deluge 0.0.16__py3-none-any.whl → 0.0.17__py3-none-any.whl

lm_deluge/built_in_tools/{anthropic.py → anthropic/__init__.py}

@@ -1,5 +1,7 @@
 from typing import Literal
 
+# from lm_deluge.prompt import ToolCall
+
 ToolVersion = Literal["2024-10-22", "2025-01-24", "2025-04-29"]
 ToolType = Literal["bash", "computer", "editor"]
 
@@ -102,7 +104,7 @@ def web_search_tool(max_uses: int = 5):
         "type": "web_search_20250305",
         "name": "web_search",
         # Optional: Limit the number of searches per request
-        "max_uses": 5,
+        "max_uses": max_uses,
         # You can use either allowed_domains or blocked_domains, but not both in the same request.
         # Optional: Only include results from these domains
         # "allowed_domains": ["example.com", "trusteddomain.org"],

lm_deluge/built_in_tools/anthropic/editor.py

@@ -0,0 +1,559 @@
+# from collections import defaultdict
+# from pathlib import Path
+# from typing import Any, Literal, get_args
+
+# Command_20250124 = Literal[
+#     "view",
+#     "create",
+#     "str_replace",
+#     "insert",
+#     "undo_edit",
+# ]
+
+# Command_20250429 = Literal[
+#     "view",
+#     "create",
+#     "str_replace",
+#     "insert",
+# ]
+# SNIPPET_LINES: int = 4
+
+
+# class EditTool:
+#     """
+#     An filesystem editor tool that allows the agent to view,
+#     create, and edit files. The tool parameters are defined by
+#     Anthropic and are not editable.
+#     """
+
+#     api_type: Literal["text_editor_20250124"] = "text_editor_20250124"
+#     name: Literal["str_replace_editor"] = "str_replace_editor"
+
+#     _file_history: dict[Path, list[str]]
+
+#     def __init__(self):
+#         self._file_history = defaultdict(list)
+#         super().__init__()
+
+#     def to_params(self) -> Any:
+#         return {
+#             "name": self.name,
+#             "type": self.api_type,
+#         }
+
+#     async def __call__(
+#         self,
+#         *,
+#         command: Command_20250124,
+#         path: str,
+#         file_text: str | None = None,
+#         view_range: list[int] | None = None,
+#         old_str: str | None = None,
+#         new_str: str | None = None,
+#         insert_line: int | None = None,
+#         **kwargs,
+#     ):
+#         _path = Path(path)
+#         self.validate_path(command, _path)
+#         if command == "view":
+#             return await self.view(_path, view_range)
+#         elif command == "create":
+#             if file_text is None:
+#                 raise ToolError("Parameter `file_text` is required for command: create")
+#             self.write_file(_path, file_text)
+#             self._file_history[_path].append(file_text)
+#             return ToolResult(output=f"File created successfully at: {_path}")
+#         elif command == "str_replace":
+#             if old_str is None:
+#                 raise ToolError(
+#                     "Parameter `old_str` is required for command: str_replace"
+#                 )
+#             return self.str_replace(_path, old_str, new_str)
+#         elif command == "insert":
+#             if insert_line is None:
+#                 raise ToolError(
+#                     "Parameter `insert_line` is required for command: insert"
+#                 )
+#             if new_str is None:
+#                 raise ToolError("Parameter `new_str` is required for command: insert")
+#             return self.insert(_path, insert_line, new_str)
+#         elif command == "undo_edit":
+#             return self.undo_edit(_path)
+#         raise ToolError(
+#             f"Unrecognized command {command}. The allowed commands for the {self.name} tool are: {', '.join(get_args(Command_20250124))}"
+#         )
+
+#     def validate_path(self, command: str, path: Path):
+#         """
+#         Check that the path/command combination is valid.
+#         """
+#         # Check if its an absolute path
+#         if not path.is_absolute():
+#             suggested_path = Path("") / path
+#             raise ToolError(
+#                 f"The path {path} is not an absolute path, it should start with `/`. Maybe you meant {suggested_path}?"
+#             )
+#         # Check if path exists
+#         if not path.exists() and command != "create":
+#             raise ToolError(
+#                 f"The path {path} does not exist. Please provide a valid path."
+#             )
+#         if path.exists() and command == "create":
+#             raise ToolError(
+#                 f"File already exists at: {path}. Cannot overwrite files using command `create`."
+#             )
+#         # Check if the path points to a directory
+#         if path.is_dir():
+#             if command != "view":
+#                 raise ToolError(
+#                     f"The path {path} is a directory and only the `view` command can be used on directories"
+#                 )
+
+#     async def view(self, path: Path, view_range: list[int] | None = None):
+#         """Implement the view command"""
+#         if path.is_dir():
+#             if view_range:
+#                 raise ToolError(
+#                     "The `view_range` parameter is not allowed when `path` points to a directory."
+#                 )
+
+#             _, stdout, stderr = await run(
+#                 rf"find {path} -maxdepth 2 -not -path '*/\.*'"
+#             )
+#             if not stderr:
+#                 stdout = f"Here's the files and directories up to 2 levels deep in {path}, excluding hidden items:\n{stdout}\n"
+#             return CLIResult(output=stdout, error=stderr)
+
+#         file_content = self.read_file(path)
+#         init_line = 1
+#         if view_range:
+#             if len(view_range) != 2 or not all(isinstance(i, int) for i in view_range):
+#                 raise ToolError(
+#                     "Invalid `view_range`. It should be a list of two integers."
+#                 )
+#             file_lines = file_content.split("\n")
+#             n_lines_file = len(file_lines)
+#             init_line, final_line = view_range
+#             if init_line < 1 or init_line > n_lines_file:
+#                 raise ToolError(
+#                     f"Invalid `view_range`: {view_range}. Its first element `{init_line}` should be within the range of lines of the file: {[1, n_lines_file]}"
+#                 )
+#             if final_line > n_lines_file:
+#                 raise ToolError(
+#                     f"Invalid `view_range`: {view_range}. Its second element `{final_line}` should be smaller than the number of lines in the file: `{n_lines_file}`"
+#                 )
+#             if final_line != -1 and final_line < init_line:
+#                 raise ToolError(
+#                     f"Invalid `view_range`: {view_range}. Its second element `{final_line}` should be larger or equal than its first `{init_line}`"
+#                 )
+
+#             if final_line == -1:
+#                 file_content = "\n".join(file_lines[init_line - 1 :])
+#             else:
+#                 file_content = "\n".join(file_lines[init_line - 1 : final_line])
+
+#         return CLIResult(
+#             output=self._make_output(file_content, str(path), init_line=init_line)
+#         )
+
+#     def str_replace(self, path: Path, old_str: str, new_str: str | None):
+#         """Implement the str_replace command, which replaces old_str with new_str in the file content"""
+#         # Read the file content
+#         file_content = self.read_file(path).expandtabs()
+#         old_str = old_str.expandtabs()
+#         new_str = new_str.expandtabs() if new_str is not None else ""
+
+#         # Check if old_str is unique in the file
+#         occurrences = file_content.count(old_str)
+#         if occurrences == 0:
+#             raise ToolError(
+#                 f"No replacement was performed, old_str `{old_str}` did not appear verbatim in {path}."
+#             )
+#         elif occurrences > 1:
+#             file_content_lines = file_content.split("\n")
+#             lines = [
+#                 idx + 1
+#                 for idx, line in enumerate(file_content_lines)
+#                 if old_str in line
+#             ]
+#             raise ToolError(
+#                 f"No replacement was performed. Multiple occurrences of old_str `{old_str}` in lines {lines}. Please ensure it is unique"
+#             )
+
+#         # Replace old_str with new_str
+#         new_file_content = file_content.replace(old_str, new_str)
+
+#         # Write the new content to the file
+#         self.write_file(path, new_file_content)
+
+#         # Save the content to history
+#         self._file_history[path].append(file_content)
+
+#         # Create a snippet of the edited section
+#         replacement_line = file_content.split(old_str)[0].count("\n")
+#         start_line = max(0, replacement_line - SNIPPET_LINES)
+#         end_line = replacement_line + SNIPPET_LINES + new_str.count("\n")
+#         snippet = "\n".join(new_file_content.split("\n")[start_line : end_line + 1])
+
+#         # Prepare the success message
+#         success_msg = f"The file {path} has been edited. "
+#         success_msg += self._make_output(
+#             snippet, f"a snippet of {path}", start_line + 1
+#         )
+#         success_msg += "Review the changes and make sure they are as expected. Edit the file again if necessary."
+
+#         return CLIResult(output=success_msg)
+
+#     def insert(self, path: Path, insert_line: int, new_str: str):
+#         """Implement the insert command, which inserts new_str at the specified line in the file content."""
+#         file_text = self.read_file(path).expandtabs()
+#         new_str = new_str.expandtabs()
+#         file_text_lines = file_text.split("\n")
+#         n_lines_file = len(file_text_lines)
+
+#         if insert_line < 0 or insert_line > n_lines_file:
+#             raise ToolError(
+#                 f"Invalid `insert_line` parameter: {insert_line}. It should be within the range of lines of the file: {[0, n_lines_file]}"
+#             )
+
+#         new_str_lines = new_str.split("\n")
+#         new_file_text_lines = (
+#             file_text_lines[:insert_line]
+#             + new_str_lines
+#             + file_text_lines[insert_line:]
+#         )
+#         snippet_lines = (
+#             file_text_lines[max(0, insert_line - SNIPPET_LINES) : insert_line]
+#             + new_str_lines
+#             + file_text_lines[insert_line : insert_line + SNIPPET_LINES]
+#         )
+
+#         new_file_text = "\n".join(new_file_text_lines)
+#         snippet = "\n".join(snippet_lines)
+
+#         self.write_file(path, new_file_text)
+#         self._file_history[path].append(file_text)
+
+#         success_msg = f"The file {path} has been edited. "
+#         success_msg += self._make_output(
+#             snippet,
+#             "a snippet of the edited file",
+#             max(1, insert_line - SNIPPET_LINES + 1),
+#         )
+#         success_msg += "Review the changes and make sure they are as expected (correct indentation, no duplicate lines, etc). Edit the file again if necessary."
+#         return CLIResult(output=success_msg)
+
+#     def undo_edit(self, path: Path):
+#         """Implement the undo_edit command."""
+#         if not self._file_history[path]:
+#             raise ToolError(f"No edit history found for {path}.")
+
+#         old_text = self._file_history[path].pop()
+#         self.write_file(path, old_text)
+
+#         return CLIResult(
+#             output=f"Last edit to {path} undone successfully. {self._make_output(old_text, str(path))}"
+#         )
+
+#     def read_file(self, path: Path):
+#         """Read the content of a file from a given path; raise a ToolError if an error occurs."""
+#         try:
+#             return path.read_text()
+#         except Exception as e:
+#             raise ToolError(f"Ran into {e} while trying to read {path}") from None
+
+#     def write_file(self, path: Path, file: str):
+#         """Write the content of a file to a given path; raise a ToolError if an error occurs."""
+#         try:
+#             path.write_text(file)
+#         except Exception as e:
+#             raise ToolError(f"Ran into {e} while trying to write to {path}") from None
+
+#     def _make_output(
+#         self,
+#         file_content: str,
+#         file_descriptor: str,
+#         init_line: int = 1,
+#         expand_tabs: bool = True,
+#     ):
+#         """Generate output for the CLI based on the content of a file."""
+#         file_content = maybe_truncate(file_content)
+#         if expand_tabs:
+#             file_content = file_content.expandtabs()
+#         file_content = "\n".join(
+#             [
+#                 f"{i + init_line:6}\t{line}"
+#                 for i, line in enumerate(file_content.split("\n"))
+#             ]
+#         )
+#         return (
+#             f"Here's the result of running `cat -n` on {file_descriptor}:\n"
+#             + file_content
+#             + "\n"
+#         )
+
+
+# class EditTool20250429(BaseAnthropicTool):
+#     """
+#     An filesystem editor tool that allows the agent to view, create, and edit files.
+#     The tool parameters are defined by Anthropic and are not editable.
+#     """
+
+#     api_type: Literal["str_replace_based_edit_tool"] = "str_replace_based_edit_tool"
+#     name: Literal["str_replace_based_edit_tool"] = "str_replace_based_edit_tool"
+
+#     _file_history: dict[Path, list[str]]
+
+#     def __init__(self):
+#         self._file_history = defaultdict(list)
+#         super().__init__()
+
+#     def to_params(self) -> Any:
+#         return {
+#             "name": self.name,
+#             "type": self.api_type,
+#         }
+
+#     async def __call__(
+#         self,
+#         *,
+#         command: Command_20250429,
+#         path: str,
+#         file_text: str | None = None,
+#         view_range: list[int] | None = None,
+#         old_str: str | None = None,
+#         new_str: str | None = None,
+#         insert_line: int | None = None,
+#         **kwargs,
+#     ):
+#         _path = Path(path)
+#         self.validate_path(command, _path)
+#         if command == "view":
+#             return await self.view(_path, view_range)
+#         elif command == "create":
+#             if file_text is None:
+#                 raise ToolError("Parameter `file_text` is required for command: create")
+#             self.write_file(_path, file_text)
+#             self._file_history[_path].append(file_text)
+#             return ToolResult(output=f"File created successfully at: {_path}")
+#         elif command == "str_replace":
+#             if old_str is None:
+#                 raise ToolError(
+#                     "Parameter `old_str` is required for command: str_replace"
+#                 )
+#             return self.str_replace(_path, old_str, new_str)
+#         elif command == "insert":
+#             if insert_line is None:
+#                 raise ToolError(
+#                     "Parameter `insert_line` is required for command: insert"
+#                 )
+#             if new_str is None:
+#                 raise ToolError("Parameter `new_str` is required for command: insert")
+#             return self.insert(_path, insert_line, new_str)
+#         # Note: undo_edit command was removed in this version
+#         raise ToolError(
+#             f"Unrecognized command {command}. The allowed commands for the {self.name} tool are: {', '.join(get_args(Command_20250429))}"
+#         )
+
+#     def validate_path(self, command: str, path: Path):
+#         """
+#         Check that the path/command combination is valid.
+#         """
+#         # Check if its an absolute path
+#         if not path.is_absolute():
+#             suggested_path = Path("") / path
+#             raise ToolError(
+#                 f"The path {path} is not an absolute path, it should start with `/`. Maybe you meant {suggested_path}?"
+#             )
+#         # Check if path exists
+#         if not path.exists() and command != "create":
+#             raise ToolError(
+#                 f"The path {path} does not exist. Please provide a valid path."
+#             )
+#         if path.exists() and command == "create":
+#             raise ToolError(
+#                 f"File already exists at: {path}. Cannot overwrite files using command `create`."
+#             )
+#         # Check if the path points to a directory
+#         if path.is_dir():
+#             if command != "view":
+#                 raise ToolError(
+#                     f"The path {path} is a directory and only the `view` command can be used on directories"
+#                 )
+
+#     async def view(self, path: Path, view_range: list[int] | None = None):
+#         """Implement the view command"""
+#         if path.is_dir():
+#             if view_range:
+#                 raise ToolError(
+#                     "The `view_range` parameter is not allowed when `path` points to a directory."
+#                 )
+
+#             _, stdout, stderr = await run(
+#                 rf"find {path} -maxdepth 2 -not -path '*/\.*'"
+#             )
+#             if not stderr:
+#                 stdout = f"Here's the files and directories up to 2 levels deep in {path}, excluding hidden items:\n{stdout}\n"
+#             return CLIResult(output=stdout, error=stderr)
+
+#         file_content = self.read_file(path)
+#         init_line = 1
+#         if view_range:
+#             if len(view_range) != 2 or not all(isinstance(i, int) for i in view_range):
+#                 raise ToolError(
+#                     "Invalid `view_range`. It should be a list of two integers."
+#                 )
+#             file_lines = file_content.split("\n")
+#             n_lines_file = len(file_lines)
+#             init_line, final_line = view_range
+#             if init_line < 1 or init_line > n_lines_file:
+#                 raise ToolError(
+#                     f"Invalid `view_range`: {view_range}. Its first element `{init_line}` should be within the range of lines of the file: {[1, n_lines_file]}"
+#                 )
+#             if final_line > n_lines_file:
+#                 raise ToolError(
+#                     f"Invalid `view_range`: {view_range}. Its second element `{final_line}` should be smaller than the number of lines in the file: `{n_lines_file}`"
+#                 )
+#             if final_line != -1 and final_line < init_line:
+#                 raise ToolError(
+#                     f"Invalid `view_range`: {view_range}. Its second element `{final_line}` should be larger or equal than its first `{init_line}`"
+#                 )
+
+#             if final_line == -1:
+#                 file_content = "\n".join(file_lines[init_line - 1 :])
+#             else:
+#                 file_content = "\n".join(file_lines[init_line - 1 : final_line])
+
+#         return CLIResult(
+#             output=self._make_output(file_content, str(path), init_line=init_line)
+#         )
+
+#     def str_replace(self, path: Path, old_str: str, new_str: str | None):
+#         """Implement the str_replace command, which replaces old_str with new_str in the file content"""
+#         # Read the file content
+#         file_content = self.read_file(path).expandtabs()
+#         old_str = old_str.expandtabs()
+#         new_str = new_str.expandtabs() if new_str is not None else ""
+
+#         # Check if old_str is unique in the file
+#         occurrences = file_content.count(old_str)
+#         if occurrences == 0:
+#             raise ToolError(
+#                 f"No replacement was performed, old_str `{old_str}` did not appear verbatim in {path}."
+#             )
+#         elif occurrences > 1:
+#             file_content_lines = file_content.split("\n")
+#             lines = [
+#                 idx + 1
+#                 for idx, line in enumerate(file_content_lines)
+#                 if old_str in line
+#             ]
+#             raise ToolError(
+#                 f"No replacement was performed. Multiple occurrences of old_str `{old_str}` in lines {lines}. Please ensure it is unique"
+#             )
+
+#         # Replace old_str with new_str
+#         new_file_content = file_content.replace(old_str, new_str)
+
+#         # Write the new content to the file
+#         self.write_file(path, new_file_content)
+
+#         # Save the content to history
+#         self._file_history[path].append(file_content)
+
+#         # Create a snippet of the edited section
+#         replacement_line = file_content.split(old_str)[0].count("\n")
+#         start_line = max(0, replacement_line - SNIPPET_LINES)
+#         end_line = replacement_line + SNIPPET_LINES + new_str.count("\n")
+#         snippet = "\n".join(new_file_content.split("\n")[start_line : end_line + 1])
+
+#         # Prepare the success message
+#         success_msg = f"The file {path} has been edited. "
+#         success_msg += self._make_output(
+#             snippet, f"a snippet of {path}", start_line + 1
+#         )
+#         success_msg += "Review the changes and make sure they are as expected. Edit the file again if necessary."
+
+#         return CLIResult(output=success_msg)
+
+#     def insert(self, path: Path, insert_line: int, new_str: str):
+#         """Implement the insert command, which inserts new_str at the specified line in the file content."""
+#         file_text = self.read_file(path).expandtabs()
+#         new_str = new_str.expandtabs()
+#         file_text_lines = file_text.split("\n")
+#         n_lines_file = len(file_text_lines)
+
+#         if insert_line < 0 or insert_line > n_lines_file:
+#             raise ToolError(
+#                 f"Invalid `insert_line` parameter: {insert_line}. It should be within the range of lines of the file: {[0, n_lines_file]}"
+#             )
+
+#         new_str_lines = new_str.split("\n")
+#         new_file_text_lines = (
+#             file_text_lines[:insert_line]
+#             + new_str_lines
+#             + file_text_lines[insert_line:]
+#         )
+#         snippet_lines = (
+#             file_text_lines[max(0, insert_line - SNIPPET_LINES) : insert_line]
+#             + new_str_lines
+#             + file_text_lines[insert_line : insert_line + SNIPPET_LINES]
+#         )
+
+#         new_file_text = "\n".join(new_file_text_lines)
+#         snippet = "\n".join(snippet_lines)
+
+#         self.write_file(path, new_file_text)
+#         self._file_history[path].append(file_text)
+
+#         success_msg = f"The file {path} has been edited. "
+#         success_msg += self._make_output(
+#             snippet,
+#             "a snippet of the edited file",
+#             max(1, insert_line - SNIPPET_LINES + 1),
+#         )
+#         success_msg += "Review the changes and make sure they are as expected (correct indentation, no duplicate lines, etc). Edit the file again if necessary."
+#         return CLIResult(output=success_msg)
+
+#     # Note: undo_edit method is not implemented in this version as it was removed
+
+#     def read_file(self, path: Path):
+#         """Read the content of a file from a given path; raise a ToolError if an error occurs."""
+#         try:
+#             return path.read_text()
+#         except Exception as e:
+#             raise ToolError(f"Ran into {e} while trying to read {path}") from None
+
+#     def write_file(self, path: Path, file: str):
+#         """Write the content of a file to a given path; raise a ToolError if an error occurs."""
+#         try:
+#             path.write_text(file)
+#         except Exception as e:
+#             raise ToolError(f"Ran into {e} while trying to write to {path}") from None
+
+#     def _make_output(
+#         self,
+#         file_content: str,
+#         file_descriptor: str,
+#         init_line: int = 1,
+#         expand_tabs: bool = True,
+#     ):
+#         """Generate output for the CLI based on the content of a file."""
+#         file_content = maybe_truncate(file_content)
+#         if expand_tabs:
+#             file_content = file_content.expandtabs()
+#         file_content = "\n".join(
+#             [
+#                 f"{i + init_line:6}\t{line}"
+#                 for i, line in enumerate(file_content.split("\n"))
+#             ]
+#         )
+#         return (
+#             f"Here's the result of running `cat -n` on {file_descriptor}:\n"
+#             + file_content
+#             + "\n"
+#         )
+
+
+# class EditTool20241022(EditTool20250124):
+#     api_type: Literal["text_editor_20250429"] = "text_editor_20250429"  # pyright: ignore[reportIncompatibleVariableOverride]

lm_deluge/built_in_tools/base.py

@@ -0,0 +1,9 @@
+class BuiltInTool:
+    def for_anthropic(self):
+        raise NotImplementedError("Not implemented")
+
+    def for_openai_chat(self):
+        raise NotImplementedError("Not implemented")
+
+    def for_openai_responses(self):
+        raise NotImplementedError("Not implemented")

lm_deluge/client.py

@@ -458,6 +458,89 @@ class LLMClient(BaseModel):
                 # final item
                 return item
 
+    async def run_agent_loop(
+        self,
+        conversation: str | Conversation,
+        *,
+        tools: list[Tool | dict] | None = None,
+        max_rounds: int = 5,
+        show_progress: bool = False,
+    ) -> tuple[Conversation, APIResponse]:
+        """Run a simple agent loop until no more tool calls are returned.
+
+        The provided ``conversation`` will be mutated and returned alongside the
+        final ``APIResponse`` from the model. ``tools`` may include ``Tool``
+        instances or built‑in tool dictionaries.
+        """
+
+        if isinstance(conversation, str):
+            conversation = Conversation.user(conversation)
+
+        last_response: APIResponse | None = None
+
+        for _ in range(max_rounds):
+            responses = await self.process_prompts_async(
+                [conversation],
+                tools=tools,  # type: ignore
+                return_completions_only=False,
+                show_progress=show_progress,
+            )
+
+            last_response = responses[0]
+            if last_response is None or last_response.content is None:
+                break
+
+            conversation.add(last_response.content)
+
+            tool_calls = last_response.content.tool_calls
+            if not tool_calls:
+                break
+
+            for call in tool_calls:
+                tool_obj = None
+                if tools:
+                    for t in tools:
+                        if isinstance(t, Tool) and t.name == call.name:
+                            tool_obj = t
+                            break
+
+                if isinstance(tool_obj, Tool) and tool_obj.run is not None:
+                    try:
+                        result = await tool_obj.acall(**call.arguments)
+                    except Exception as e:  # pragma: no cover - best effort
+                        result = f"Error: {e}"
+                else:
+                    result = f"Tool {call.name} not found"
+
+                if not isinstance(result, (str, dict, list)):
+                    result = str(result)
+
+                conversation.add_tool_result(call.id, result)  # type: ignore
+
+        if last_response is None:
+            raise RuntimeError("model did not return a response")
+
+        return conversation, last_response
+
+    def run_agent_loop_sync(
+        self,
+        conversation: str | Conversation,
+        *,
+        tools: list[Tool | dict | MCPServer] | None = None,
+        max_rounds: int = 5,
+        show_progress: bool = False,
+    ) -> tuple[Conversation, APIResponse]:
+        """Synchronous wrapper for :meth:`run_agent_loop`."""
+
+        return asyncio.run(
+            self.run_agent_loop(
+                conversation,
+                tools=tools,  # type: ignore
+                max_rounds=max_rounds,
+                show_progress=show_progress,
+            )
+        )
+
     async def submit_batch_job(
         self,
         prompts: Sequence[str | list[dict] | Conversation],

lm_deluge/tool.py

@@ -255,6 +255,10 @@ class Tool(BaseModel):
             },
         }
 
+    def for_openai(self, strict: bool = True, **kwargs):
+        """just an alias for the above"""
+        return self.for_openai_completions(strict=strict, **kwargs)
+
     def for_openai_responses(self, **kwargs) -> dict[str, Any]:
         if self.built_in:
             return {"type": self.type, **self.built_in_args, **kwargs}

{lm_deluge-0.0.16.dist-info → lm_deluge-0.0.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.16
+Version: 0.0.17
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -211,6 +211,16 @@ for tool_call in resps[0].tool_calls:
     # this is dumb sorry will make it better
     tool_to_call = [x for x in tools if x.name == tool_call.name][0]
     tool_to_call.call(**tool_call.arguments) # in async code, use .acall()
+
+# or use the built-in agent loop to handle this automatically
+import asyncio
+
+async def main():
+    conv = Conversation.user("List the files in the current directory")
+    conv, resp = await client.run_agent_loop(conv, tools=tools)
+    print(resp.content.completion)
+
+asyncio.run(main())
 ```
 
 ### Prompt Caching (Anthropic)

{lm_deluge-0.0.16.dist-info → lm_deluge-0.0.17.dist-info}/RECORD

@@ -2,7 +2,7 @@ lm_deluge/__init__.py,sha256=mAztMuxINmh7dGbYnT8tsmw1eryQAvd0jpY8yHzd0EE,315
 lm_deluge/agent.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lm_deluge/batches.py,sha256=05t8UL1xCKjLRKtZLkfbexLqro6T_ufFVsaNIMk05Fw,17725
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=Qn44_3x73PI0AxlmbGwO1MNz7fzjrkjB-RkhGf7k0Jo,22691
+lm_deluge/client.py,sha256=yE82ssvJnAzaYPQchd-cAsbdVFefLGMp-D29aFkZKlE,25530
 lm_deluge/config.py,sha256=H1tQyJDNHGFuwxqQNL5Z-CjWAC0luHSBA3iY_pxmACM,932
 lm_deluge/embed.py,sha256=CO-TOlC5kOTAM8lcnicoG4u4K664vCBwHF1vHa-nAGg,13382
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
@@ -13,7 +13,7 @@ lm_deluge/models.py,sha256=6ZCirxOpdcg_M24cKUABYbRpLK-r9dlkXxUS9aeh0UY,49657
 lm_deluge/prompt.py,sha256=SaLcUjfzgeIZRzb6fxLp6PTFLxpvcSlaazJq3__2Sqs,35248
 lm_deluge/request_context.py,sha256=SfPu9pl5NgDVLaWGQkSXdQZ7Mm-Vw4GSTlOu-PAOE3k,2290
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
-lm_deluge/tool.py,sha256=-jeP6lYbJxwLhuiS7m84LAfgbwCjgyH-yuUCt031L58,12239
+lm_deluge/tool.py,sha256=X6NDabz53BVe1pokaKCeTLCF1-AlMAxOn1_KWiCSb7c,12407
 lm_deluge/tracker.py,sha256=-EkFDAklh5mclIFR-5SthAwNL4p1yKS8LUN7rhpOVPQ,9266
 lm_deluge/usage.py,sha256=VMEKghePFIID5JFBObqYxFpgYxnbYm_dnHy7V1-_T6M,4866
 lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -30,8 +30,12 @@ lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4
 lm_deluge/api_requests/deprecated/deepseek.py,sha256=FEApI93VAWDwuaqTooIyKMgONYqRhdUmiAPBRme-IYs,4582
 lm_deluge/api_requests/deprecated/mistral.py,sha256=pOfOZUM4U35I3Plch84SnAFpDAzouHcSNNMtgxRvjy4,4709
 lm_deluge/api_requests/deprecated/vertex.py,sha256=ygXz2RjdXErPCSBbiHLEWbf5_sSTIi31WoX0UaoYzRI,15275
-lm_deluge/built_in_tools/anthropic.py,sha256=ZvO-8hBSQdD_RzWYF0APytr8grBnBovICA76yHYTFNA,4478
+lm_deluge/built_in_tools/base.py,sha256=FLYdKVAqlffA6WOu4j8wQVRd0iHMsyBW_T3vfl--aXo,276
 lm_deluge/built_in_tools/openai.py,sha256=aLuJdXbANvXVIU38Vo2zsir7zlwWgX0d8oDPT7Ql64A,721
+lm_deluge/built_in_tools/anthropic/__init__.py,sha256=Dxm8MJTUwMhyXT_78uIdRe8dJsLHZcHThJ9UEurTw18,4526
+lm_deluge/built_in_tools/anthropic/bash.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lm_deluge/built_in_tools/anthropic/computer_use.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lm_deluge/built_in_tools/anthropic/editor.py,sha256=DyC_DrHVTm1khU9QDL39vBuhu4tO5mS5H7xMRIT0Ng4,23327
 lm_deluge/llm_tools/__init__.py,sha256=TbZTETq9i_9yYskFWQKOG4pGh5ZiyE_D-h3RArfhGp4,231
 lm_deluge/llm_tools/extract.py,sha256=C3drVAMaoFx5jNE38Xi5cXxrqboyoZ9cE7nX5ylWbXw,4482
 lm_deluge/llm_tools/ocr.py,sha256=7fDlvs6uUOvbxMasvGGNJx5Fj6biM6z3lijKZaGN26k,23
@@ -41,8 +45,8 @@ lm_deluge/util/json.py,sha256=_4Oar2Cmz2L1DK3EtPLPDxD6rsYHxjROmV8ZpmMjQ-4,5822
 lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11768
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-lm_deluge-0.0.16.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.16.dist-info/METADATA,sha256=hfp55fuKt7dlheGj1uOcOoSMzSLmddXA85Gqe1U4KAM,12689
-lm_deluge-0.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.16.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.16.dist-info/RECORD,,
+lm_deluge-0.0.17.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.17.dist-info/METADATA,sha256=vjbrAWwFloi0nwrDXWcUT31DmhomLoielYzsCf_2y7E,12978
+lm_deluge-0.0.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.17.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.17.dist-info/RECORD,,