lm-deluge 0.0.16__tar.gz → 0.0.18__tar.gz

{lm_deluge-0.0.16/src/lm_deluge.egg-info → lm_deluge-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.16
+Version: 0.0.18
 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 → lm_deluge-0.0.18}/README.md

@@ -184,6 +184,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 → lm_deluge-0.0.18}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.16"
+version = "0.0.18"
 authors = [{ name = "Benjamin Anderson", email = "ben@trytaylor.ai" }]
 description = "Python utility for using LLM API models."
 readme = "README.md"

{lm_deluge-0.0.16 → lm_deluge-0.0.18}/src/lm_deluge/api_requests/anthropic.py

@@ -36,7 +36,7 @@ def _build_anthropic_request(
     cache_pattern: CachePattern | None = None,
 ):
     system_message, messages = prompt.to_anthropic(cache_pattern=cache_pattern)
-    request_header = {
+    base_headers = {
         "x-api-key": os.getenv(model.api_key_env_var),
         "anthropic-version": "2023-06-01",
         "content-type": "application/json",
@@ -83,13 +83,13 @@ def _build_anthropic_request(
                     "text_editor_20241022",
                     "bash_20241022",
                 ]:
-                    _add_beta(request_header, "computer-use-2024-10-22")
+                    _add_beta(base_headers, "computer-use-2024-10-22")
                 elif tool["type"] == "computer_20250124":
-                    _add_beta(request_header, "computer-use-2025-01-24")
+                    _add_beta(base_headers, "computer-use-2025-01-24")
                 elif tool["type"] == "code_execution_20250522":
-                    _add_beta(request_header, "code-execution-2025-05-22")
+                    _add_beta(base_headers, "code-execution-2025-05-22")
             elif isinstance(tool, MCPServer):
-                _add_beta(request_header, "mcp-client-2025-04-04")
+                _add_beta(base_headers, "mcp-client-2025-04-04")
                 mcp_servers.append(tool.for_anthropic())
 
         # Add cache control to last tool if tools_only caching is specified
@@ -100,7 +100,7 @@ def _build_anthropic_request(
         if len(mcp_servers) > 0:
             request_json["mcp_servers"] = mcp_servers
 
-    return request_json, request_header
+    return request_json, base_headers
 
 
 class AnthropicRequest(APIRequestBase):
@@ -114,13 +114,16 @@ class AnthropicRequest(APIRequestBase):
         if self.context.cache is not None:
             self.context.prompt.lock_images_as_bytes()
 
-        self.request_json, self.request_header = _build_anthropic_request(
+        self.request_json, base_headers = _build_anthropic_request(
             self.model,
             self.context.prompt,
             self.context.tools,
             self.context.sampling_params,
             self.context.cache,
         )
+        self.request_header = self.merge_headers(
+            base_headers, exclude_patterns=["openai", "gemini", "mistral"]
+        )
 
     async def handle_response(self, http_response: ClientResponse) -> APIResponse:
         data = None

{lm_deluge-0.0.16 → lm_deluge-0.0.18}/src/lm_deluge/api_requests/base.py

@@ -46,6 +46,29 @@ class APIRequestBase(ABC):
             # the APIResponse in self.result includes all the information
             self.context.callback(self.result[-1], self.context.status_tracker)
 
+    def merge_headers(
+        self, base_headers: dict[str, str], exclude_patterns: list[str] | None = None
+    ) -> dict[str, str]:
+        """Merge extra_headers with base headers, giving priority to extra_headers."""
+        if not self.context.extra_headers:
+            return base_headers
+
+        # Filter out headers that match exclude patterns
+        filtered_extra = {}
+        if exclude_patterns:
+            for key, value in self.context.extra_headers.items():
+                if not any(
+                    pattern.lower() in key.lower() for pattern in exclude_patterns
+                ):
+                    filtered_extra[key] = value
+        else:
+            filtered_extra = dict(self.context.extra_headers)
+
+        # Start with base headers, then overlay filtered extra headers (extra takes precedence)
+        merged = dict(base_headers)
+        merged.update(filtered_extra)
+        return merged
+
     def handle_success(self, data):
         self.call_callback()
         if self.context.status_tracker:

{lm_deluge-0.0.16 → lm_deluge-0.0.18}/src/lm_deluge/api_requests/bedrock.py

@@ -85,7 +85,7 @@ def _build_anthropic_bedrock_request(
     )
 
     # Setup basic headers (AWS4Auth will add the Authorization header)
-    request_header = {
+    base_headers = {
         "Content-Type": "application/json",
     }
 
@@ -115,11 +115,11 @@ def _build_anthropic_bedrock_request(
                     "text_editor_20241022",
                     "bash_20241022",
                 ]:
-                    _add_beta(request_header, "computer-use-2024-10-22")
+                    _add_beta(base_headers, "computer-use-2024-10-22")
                 elif tool["type"] == "computer_20250124":
-                    _add_beta(request_header, "computer-use-2025-01-24")
+                    _add_beta(base_headers, "computer-use-2025-01-24")
                 elif tool["type"] == "code_execution_20250522":
-                    _add_beta(request_header, "code-execution-2025-05-22")
+                    _add_beta(base_headers, "code-execution-2025-05-22")
             elif isinstance(tool, MCPServer):
                 raise ValueError("bedrock doesn't support MCP connector right now")
                 # _add_beta(request_header, "mcp-client-2025-04-04")
@@ -133,7 +133,7 @@ def _build_anthropic_bedrock_request(
         if len(mcp_servers) > 0:
             request_json["mcp_servers"] = mcp_servers
 
-    return request_json, request_header, auth, url
+    return request_json, base_headers, auth, url
 
 
 class BedrockRequest(APIRequestBase):
@@ -147,7 +147,7 @@ class BedrockRequest(APIRequestBase):
         if self.context.cache is not None:
             self.context.prompt.lock_images_as_bytes()
 
-        self.request_json, self.request_header, self.auth, self.url = (
+        self.request_json, base_headers, self.auth, self.url = (
             _build_anthropic_bedrock_request(
                 self.model,
                 context.prompt,
@@ -156,6 +156,9 @@ class BedrockRequest(APIRequestBase):
                 context.cache,
             )
         )
+        self.request_header = self.merge_headers(
+            base_headers, exclude_patterns=["anthropic", "openai", "gemini", "mistral"]
+        )
 
     async def execute_once(self) -> APIResponse:
         """Override execute_once to handle AWS4Auth signing."""

{lm_deluge-0.0.16 → lm_deluge-0.0.18}/src/lm_deluge/api_requests/gemini.py

@@ -77,9 +77,12 @@ class GeminiRequest(APIRequestBase):
         self.model = APIModel.from_registry(self.context.model_name)
         # Gemini API endpoint format: https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent
         self.url = f"{self.model.api_base}/models/{self.model.name}:generateContent"
-        self.request_header = {
+        base_headers = {
             "Content-Type": "application/json",
         }
+        self.request_header = self.merge_headers(
+            base_headers, exclude_patterns=["anthropic", "openai", "mistral"]
+        )
 
         # Add API key as query parameter for Gemini
         api_key = os.getenv(self.model.api_key_env_var)

{lm_deluge-0.0.16 → lm_deluge-0.0.18}/src/lm_deluge/api_requests/mistral.py

@@ -22,9 +22,12 @@ class MistralRequest(APIRequestBase):
             )
         self.model = APIModel.from_registry(self.context.model_name)
         self.url = f"{self.model.api_base}/chat/completions"
-        self.request_header = {
+        base_headers = {
             "Authorization": f"Bearer {os.getenv(self.model.api_key_env_var)}"
         }
+        self.request_header = self.merge_headers(
+            base_headers, exclude_patterns=["anthropic", "openai", "gemini"]
+        )
         self.request_json = {
             "model": self.model.name,
             "messages": self.context.prompt.to_mistral(),

{lm_deluge-0.0.16 → lm_deluge-0.0.18}/src/lm_deluge/api_requests/openai.py

@@ -73,9 +73,12 @@ class OpenAIRequest(APIRequestBase):
             )
         self.model = APIModel.from_registry(self.context.model_name)
         self.url = f"{self.model.api_base}/chat/completions"
-        self.request_header = {
+        base_headers = {
             "Authorization": f"Bearer {os.getenv(self.model.api_key_env_var)}"
         }
+        self.request_header = self.merge_headers(
+            base_headers, exclude_patterns=["anthropic"]
+        )
 
         self.request_json = _build_oa_chat_request(
             self.model,
@@ -432,6 +435,7 @@ async def stream_chat(
     sampling_params: SamplingParams = SamplingParams(),
     tools: list | None = None,
     cache: CachePattern | None = None,
+    extra_headers: dict[str, str] | None = None,
 ):
     if cache is not None:
         warnings.warn(
@@ -442,7 +446,16 @@ async def stream_chat(
     if model.api_spec != "openai":
         raise ValueError("streaming only supported on openai models for now")
     url = f"{model.api_base}/chat/completions"
-    request_header = {"Authorization": f"Bearer {os.getenv(model.api_key_env_var)}"}
+    base_headers = {"Authorization": f"Bearer {os.getenv(model.api_key_env_var)}"}
+
+    # Merge extra headers, filtering out anthropic headers
+    request_header = dict(base_headers)
+    if extra_headers:
+        filtered_extra = {
+            k: v for k, v in extra_headers.items() if "anthropic" not in k.lower()
+        }
+        request_header.update(filtered_extra)
+
     request_json = _build_oa_chat_request(model, prompt, tools, sampling_params)
     request_json["stream"] = True
 

lm_deluge-0.0.16/src/lm_deluge/built_in_tools/anthropic.py → lm_deluge-0.0.18/src/lm_deluge/built_in_tools/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"],