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

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
@@ -182,6 +185,7 @@ class AnthropicRequest(APIRequestBase):
             error_message = text
 
         # handle special kinds of errors. TODO: make sure these are correct for anthropic
+        retry_with_different_model = status_code in [529, 429, 400, 401, 403, 413]
         if is_error and error_message is not None:
             if (
                 "rate limit" in error_message.lower()
@@ -192,6 +196,7 @@ class AnthropicRequest(APIRequestBase):
             if "context length" in error_message:
                 error_message += " (Context length exceeded, set retries to 0.)"
                 self.context.attempts_left = 0
+            retry_with_different_model = True
 
         return APIResponse(
             id=self.context.task_id,
@@ -205,4 +210,5 @@ class AnthropicRequest(APIRequestBase):
             sampling_params=self.context.sampling_params,
             usage=usage,
             raw_response=data,
+            retry_with_different_model=retry_with_different_model,
         )

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/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/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/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/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,
@@ -156,6 +159,7 @@ class OpenAIRequest(APIRequestBase):
             error_message = text
 
         # handle special kinds of errors
+        retry_with_different_model = status_code in [529, 429, 400, 401, 403, 413]
         if is_error and error_message is not None:
             if "rate limit" in error_message.lower() or status_code == 429:
                 error_message += " (Rate limit error, triggering cooldown.)"
@@ -163,6 +167,7 @@ class OpenAIRequest(APIRequestBase):
             if "context length" in error_message:
                 error_message += " (Context length exceeded, set retries to 0.)"
                 self.context.attempts_left = 0
+            retry_with_different_model = True
 
         return APIResponse(
             id=self.context.task_id,
@@ -178,6 +183,7 @@ class OpenAIRequest(APIRequestBase):
             usage=usage,
             raw_response=data,
             finish_reason=finish_reason,
+            retry_with_different_model=retry_with_different_model,
         )
 
 
@@ -432,6 +438,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 +449,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/client.py

@@ -50,6 +50,7 @@ class LLMClient(BaseModel):
     max_attempts: int = 5
     request_timeout: int = 30
     cache: Any = None
+    extra_headers: dict[str, str] | None = None
     # sampling params - if provided, and sampling_params is not,
     # these override the defaults
     temperature: float = 0.75
@@ -364,6 +365,7 @@ class LLMClient(BaseModel):
                             tools=tools,
                             cache=cache,
                             use_responses_api=use_responses_api,
+                            extra_headers=self.extra_headers,
                         )
                     except StopIteration:
                         prompts_not_finished = False
@@ -451,7 +453,9 @@ class LLMClient(BaseModel):
         model, sampling_params = self._select_model()
         if isinstance(prompt, str):
             prompt = Conversation.user(prompt)
-        async for item in stream_chat(model, prompt, sampling_params, tools, None):
+        async for item in stream_chat(
+            model, prompt, sampling_params, tools, None, self.extra_headers
+        ):
             if isinstance(item, str):
                 print(item, end="", flush=True)
             else:

lm_deluge/image.py

@@ -1,20 +1,23 @@
-import os
-from contextlib import contextmanager
-import io
-import requests
-from PIL import Image as PILImage  # type: ignore
 import base64
+import io
 import mimetypes
+import os
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Literal
 
+import requests
+from PIL import Image as PILImage  # type: ignore
+
+MediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
+
 
 @dataclass(slots=True)
 class Image:
     # raw bytes, pathlike, http url, or base64 data url
     data: bytes | io.BytesIO | Path | str
-    media_type: str | None = None  # inferred if None
+    media_type: MediaType | None = None  # inferred if None
     detail: Literal["low", "high", "auto"] = "auto"
     type: str = field(init=False, default="image")
     _fingerprint_cache: str | None = field(init=False, default=None)

lm_deluge/llm_tools/classify.py

@@ -0,0 +1 @@
+# NOT IMPLEMENTED!!!

lm_deluge/llm_tools/locate.py

@@ -0,0 +1,162 @@
+# # utilities for locating things in images
+# from dataclasses import dataclass
+# from typing import Literal
+
+# from lm_deluge.util.json import load_json
+# from lm_deluge.util.spatial import Box2D, Point
+
+
+# @dataclass
+# class LocatePrompt:
+#     description: str
+#     task: Literal["click", "detect"] = "click"
+#     orientation: Literal["xy", "yx"] = "xy"
+#     origin: Literal["top-left", "bottom-left"] = "top-left"
+#     coords: Literal["absolute", "relative-1", "relative-1k"] = "absolute"
+#     height: int | None = None
+#     width: int | None = None
+#     output_type: Literal["point", "points", "box", "boxes"] = "point"
+#     output_fmt: Literal["json", "xml"] = "xml"
+
+#     def to_string(self) -> str:
+#         """Compose the full prompt string based on the current configuration."""
+#         parts: list[str] = []
+
+#         if self.task == "click":
+#             parts.append(
+#                 "Given an instruction, determine where to click in the image to complete it. "
+#             )
+#             parts.append(f"\n\nINSTRUCTION: {self.description}\n\n")
+#         else:
+#             if self.output_type.endswith("s"):
+#                 parts.append(
+#                     "Given a description of an object to locate, find ALL instances of that object in the image."
+#                 )
+#             else:
+#                 parts.append(
+#                     "Given a description of an object to locate, find that object in the image."
+#                 )
+#             parts.append(f"\n\nDESCRIPTION: {self.description}\n\n")
+
+#         if self.output_type == "point":
+#             point_type = "(x, y)" if self.orientation == "xy" else "(y, x)"
+#             parts.append(f"Your response should be a single {point_type} point")
+#             if self.output_fmt == "xml":
+#                 parts.append("enclosed in <point></point> tags.")
+#             else:
+#                 parts.append('formatted as JSON, like {"point": [0, 1]}.')
+
+#         elif self.output_type == "points":
+#             point_type = "(x, y)" if self.orientation == "xy" else "(y, x)"
+#             parts.append(f"Your response should be a series of {point_type} points,")
+#             if self.output_fmt == "xml":
+#                 parts.append("each one enclosed in <point></point> tags.")
+#             else:
+#                 parts.append(
+#                     'formatted as a JSON array, like [{"point": [0, 1]}, {"point": [1, 0]}].'
+#                 )
+
+#         elif self.output_type == "box":
+#             box_type = (
+#                 "(x0, y0, x1, y1)" if self.orientation == "xy" else "(y0, x0, y1, x1)"
+#             )
+#             parts.append(f"Your response should be a {box_type} bounding box,")
+
+#             if self.output_fmt == "xml":
+#                 parts.append("enclosed in <box></box> tags.")
+#             else:
+#                 parts.append('formatted as JSON, like {"box_2d": [0, 0, 1, 1]}')
+
+#         elif self.output_type == "boxes":
+#             box_type = (
+#                 "(x0, y0, x1, y1)" if self.orientation == "xy" else "(y0, x0, y1, x1)"
+#             )
+#             parts.append(
+#                 f"Your response should be a series of {box_type} bounding boxes,"
+#             )
+#             if self.output_fmt == "xml":
+#                 parts.append("each one enclosed in <box></box> tags.")
+#             else:
+#                 parts.append(
+#                     'formatted as a JSON array, like [{"box_2d": [0, 0, 1, 1]}, {"box_2d": [0.5, 0.5, 1, 1]}].'
+#                 )
+
+#         if self.coords == "absolute":
+#             parts.append(
+#                 "The returned coordinates should be absolute pixel coordinates in the image. "
+#                 f"The image has a height of {self.height} pixels and a width of {self.width} pixels. "
+#             )
+#             if self.origin == "top-left":
+#                 parts.append("The origin (0, 0) is at the top-left of the image.")
+#             else:
+#                 parts.append("The origin (0, 0) is at the bottom-left of the image.")
+#         elif self.coords == "relative-1":
+#             parts.append(
+#                 "The returned coordinates should be relative coordinates where x are between 0 and 1. "
+#             )
+#             if self.origin == "top-left":
+#                 parts.append(
+#                     "The origin (0, 0) is at the top-left of the image, and (1, 1) is at the bottom-right."
+#                 )
+#             else:
+#                 parts.append(
+#                     "The origin (0, 0) is at the bottom-left of the image, and (1, 1) is at the top-right."
+#                 )
+#         elif self.coords == "relative-1k":
+#             parts.append(
+#                 "The returned coordinates should be relative coordinates where x are between 0 and 1000. "
+#             )
+#             if self.origin == "top-left":
+#                 parts.append(
+#                     "The origin (0, 0) is at the top-left of the image, and (1000, 1000) is at the bottom-right."
+#                 )
+#             else:
+#                 parts.append(
+#                     "The origin (0, 0) is at the bottom-left of the image, and (1000, 1000) is at the top-right."
+#                 )
+
+#         parts.append(
+#             "Return JUST the structured output, no prelude or commentary needed."
+#         )
+
+#         result = ""
+#         for part in parts:
+#             if part.startswith("\n") or result.endswith("\n"):
+#                 result += part
+#             else:
+#                 result += " " + part
+
+#         return result.strip()
+
+#     def parse_output(self, output: str) -> Point | Box2D | list[Point] | list[Box2D]:
+#         if self.output_fmt == "json":
+#             loaded = load_json(output)
+#             if self.output_type == "point":
+#                 assert isinstance(loaded, dict)
+#                 if self.orientation == "xy":
+#                     x, y = loaded["point"]
+#                 else:
+#                     y, x = loaded["point"]
+
+#                     return Point(x=)
+
+#         else:
+#             pass
+
+#         return []
+
+
+# def locate_point():
+#     pass
+
+
+# def locate_points():
+#     pass
+
+
+# def locate_box():
+#     pass
+
+
+# def locate_boxes():
+#     pass

lm_deluge/prompt.py

@@ -8,7 +8,7 @@ import tiktoken
 import xxhash
 
 from lm_deluge.file import File
-from lm_deluge.image import Image
+from lm_deluge.image import Image, MediaType
 
 CachePattern = Literal[
     "tools_only",
@@ -348,7 +348,7 @@ class Message:
         self,
         data: bytes | str | Path | io.BytesIO,
         *,
-        media_type: str | None = None,
+        media_type: MediaType | None = None,
         detail: Literal["low", "high", "auto"] = "auto",
         max_size: int | None = None,
     ) -> "Message":

lm_deluge/request_context.py

@@ -34,6 +34,7 @@ class RequestContext:
     tools: list | None = None
     cache: CachePattern | None = None
     use_responses_api: bool = False
+    extra_headers: dict[str, str] | None = None
 
     # Computed properties
     cache_key: str = field(init=False)

lm_deluge/util/spatial.py

@@ -0,0 +1,139 @@
+from dataclasses import dataclass
+from functools import partial
+
+from PIL import Image, ImageDraw
+
+
+@dataclass
+class Point:
+    def __init__(self, x: float, y: float, description: str | None = None):
+        self.x = x
+        self.y = y
+        self.description = description
+
+    def __getitem__(self, index):
+        if index == 0:
+            return self.x
+        elif index == 1:
+            return self.y
+        elif index == "x":
+            return self.x
+        elif index == "y":
+            return self.y
+        else:
+            raise IndexError("Index out of range")
+
+    def __iter__(self):
+        yield self.x
+        yield self.y
+
+    def __str__(self):
+        return f"Point(x={self.x}, y={self.y})"
+
+    def __repr__(self):
+        return f"Point(x={self.x}, y={self.y})"
+
+    @classmethod
+    def from_tuple(cls, point: tuple, description: str | None = None):
+        return cls(point[0], point[1], description)
+
+    @classmethod
+    def from_dict(cls, point: dict, description: str | None = None):
+        return cls(point["x"], point["y"], description)
+
+
+@dataclass
+class Box2D:
+    def __init__(
+        self,
+        xmin: float,
+        ymin: float,
+        xmax: float,
+        ymax: float,
+        description: str | None = None,
+    ):
+        self.xmin = xmin
+        self.ymin = ymin
+        self.xmax = xmax
+        self.ymax = ymax
+        self.description = description
+
+    def __repr__(self):
+        return f"Box2D(xmin={self.xmin}, ymin={self.ymin}, xmax={self.xmax}, ymax={self.ymax})"
+
+    def __str__(self):
+        return f"Box2D(xmin={self.xmin}, ymin={self.ymin}, xmax={self.xmax}, ymax={self.ymax})"
+
+    @classmethod
+    def from_list(cls, box: list):
+        return cls(box[1], box[0], box[3], box[2])
+
+    def center(self):
+        return Point((self.xmin + self.xmax) / 2, (self.ymin + self.ymax) / 2)
+
+
+def scale(
+    obj: Point | Box2D | tuple | dict,
+    src_width: int,
+    src_height: int,
+    dst_width: int,
+    dst_height: int,
+    return_integers: bool = True,
+):
+    if isinstance(obj, tuple):
+        if len(obj) == 2:
+            obj = Point(obj[0], obj[1])
+        elif len(obj) == 4:
+            obj = Box2D(obj[0], obj[1], obj[2], obj[3])
+        else:
+            raise ValueError("Invalid tuple length")
+    elif isinstance(obj, dict):
+        if "x" in obj and "y" in obj:
+            obj = Point(obj["x"], obj["y"])
+        elif "xmin" in obj and "ymin" in obj and "xmax" in obj and "ymax" in obj:
+            obj = Box2D(obj["xmin"], obj["ymin"], obj["xmax"], obj["ymax"])
+        else:
+            raise ValueError("Invalid dictionary keys")
+    scale_x = dst_width / src_width
+    scale_y = dst_height / src_height
+
+    if isinstance(obj, Point):
+        x = obj.x * scale_x
+        y = obj.y * scale_y
+        if return_integers:
+            return Point(int(x), int(y), obj.description)
+        return Point(x, y)
+    elif isinstance(obj, Box2D):
+        xmin = obj.xmin * scale_x
+        ymin = obj.ymin * scale_y
+        xmax = obj.xmax * scale_x
+        ymax = obj.ymax * scale_y
+        if return_integers:
+            return Box2D(int(xmin), int(ymin), int(xmax), int(ymax), obj.description)
+        return Box2D(xmin, ymin, xmax, ymax, obj.description)
+    else:
+        raise TypeError("Unsupported type")
+
+
+normalize_point = partial(scale, dst_width=1, dst_height=1, return_integers=False)
+denormalize_point = partial(scale, src_width=1, src_height=1, return_integers=False)
+normalize_point_1k = partial(
+    scale, dst_width=1000, dst_height=1000, return_integers=True
+)
+denormalize_point_1k = partial(
+    scale, src_width=1000, src_height=1000, return_integers=False
+)
+
+
+def draw_box(image: Image.Image | str, box: Box2D):
+    if isinstance(image, str):
+        image = Image.open(image)
+    draw = ImageDraw.Draw(image)
+    draw.rectangle((box.xmin, box.ymin, box.xmax, box.ymax), outline="red", width=2)
+    return image
+
+
+def draw_point(image: Image.Image, point: Point):
+    draw = ImageDraw.Draw(image)
+    draw.ellipse((point[0] - 2, point[1] - 2, point[0] + 2, point[1] + 2), fill="red")
+    return image

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.17
+Version: 0.0.19
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10

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

@@ -2,28 +2,28 @@ 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=yE82ssvJnAzaYPQchd-cAsbdVFefLGMp-D29aFkZKlE,25530
+lm_deluge/client.py,sha256=KFkI8uzHxwIvDS1PV4KjykHUMQ48wo6h-Yn4IJKUDbg,25682
 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
 lm_deluge/file.py,sha256=zQH1STMjCG9pczO7Fk9Jw0_0Pj_8CogcdIxTe4J4AJw,5414
 lm_deluge/gemini_limits.py,sha256=V9mpS9JtXYz7AY6OuKyQp5TuIMRH1BVv9YrSNmGmHNA,1569
-lm_deluge/image.py,sha256=SIf6vh4pZ5ccrBvWc3zB_ncsWeFw2lKuIJfP3ovo6hk,7444
+lm_deluge/image.py,sha256=D8kMh2yu8sTuOchKpW9DE3XKbE6oUiFl9cRi6H1GpDc,7526
 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/prompt.py,sha256=T8o2hwv3RuxG7-fL5pCl0v14WVpmV09PdRzCZzLNszE,35265
+lm_deluge/request_context.py,sha256=l1DrPTtG80WtUhyDWblTiyT695K7Al9lWWDfdl6PMK0,2338
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
 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
-lm_deluge/api_requests/anthropic.py,sha256=nO4Gf59ZddZUURDqkiR3P3Mbr7De7sEcGL6fdYdbozU,7699
-lm_deluge/api_requests/base.py,sha256=wKB6a5nNwD-ST_nNRVUlA3l_O9HhccPcGA2fJut7kfw,4430
-lm_deluge/api_requests/bedrock.py,sha256=EDYzE7zeYscUeyIai-uHd-fDuPXZszWfSPn55XgUbCI,10846
+lm_deluge/api_requests/anthropic.py,sha256=Tc_LuovLEAXsqWlzJe08YCKighBXadp-cZztqoiBb1Y,8011
+lm_deluge/api_requests/base.py,sha256=O3-Dsl_hr-xtLTekPLdrNnL5mTTfnfsN6Fcwq0-eKMg,5355
+lm_deluge/api_requests/bedrock.py,sha256=kZtKp6GqF73RpmLJKzEj4XTbllB8Kyq9-QydUuh2iu0,10977
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
-lm_deluge/api_requests/gemini.py,sha256=6brxdouJcsJSEb8OZxklrTaqbZ1M-gWulNkGJqAKWV8,7400
-lm_deluge/api_requests/mistral.py,sha256=diflr8NlsJGpSlY1F5Ay0GMZhBDdv9L2JV70UaHnOBs,4431
-lm_deluge/api_requests/openai.py,sha256=4MgEoEQ9n_vwsNOyM2tWaPIV3IN5x7UUCrXFlqeZYLk,20782
+lm_deluge/api_requests/gemini.py,sha256=N_94TpjpBLyekdrBjax2w0jPqYf70JycaRgZUNSsAAY,7531
+lm_deluge/api_requests/mistral.py,sha256=5EqYZgu9AfGrWs5-ucr8uJK_0cMEoUKKlEjBV3O6EPc,4561
+lm_deluge/api_requests/openai.py,sha256=fEIBchry-tLqkf0fhdFsS3CIjXbB_AV39Ig-PwAsT1I,21424
 lm_deluge/api_requests/response.py,sha256=JFSwHAs-yaJYkscOgTAyHkt-v8FDZ5mgER9NmueXTGk,5866
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
@@ -37,16 +37,19 @@ lm_deluge/built_in_tools/anthropic/bash.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 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/classify.py,sha256=OdMwV5u4XoPlVhjOHX0sng5KPBIKFJmQeOE2fmnPgLU,21
 lm_deluge/llm_tools/extract.py,sha256=C3drVAMaoFx5jNE38Xi5cXxrqboyoZ9cE7nX5ylWbXw,4482
+lm_deluge/llm_tools/locate.py,sha256=lYNbKTmy9dTvj0lEQkOQ7yrxyqsgYzjD0C_byJKI_4w,6271
 lm_deluge/llm_tools/ocr.py,sha256=7fDlvs6uUOvbxMasvGGNJx5Fj6biM6z3lijKZaGN26k,23
 lm_deluge/llm_tools/score.py,sha256=9oGA3-k2U5buHQXkXaEI9M4Wb5yysNhTLsPbGeghAlQ,2580
 lm_deluge/llm_tools/translate.py,sha256=iXyYvQZ8bC44FWhBk4qpdqjKM1WFF7Shq-H2PxhPgg4,1452
 lm_deluge/util/json.py,sha256=_4Oar2Cmz2L1DK3EtPLPDxD6rsYHxjROmV8ZpmMjQ-4,5822
 lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11768
+lm_deluge/util/spatial.py,sha256=BsF_UKhE-x0xBirc-bV1xSKZRTUhsOBdGqsMKme20C8,4099
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-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,,
+lm_deluge-0.0.19.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.19.dist-info/METADATA,sha256=jijI0xaH6637Dodw2KJJRvwaD3l5Ij0Ep9dAJz1ewdU,12978
+lm_deluge-0.0.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.19.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.19.dist-info/RECORD,,