lm-deluge 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

lm_deluge/prompt.py

@@ -4,14 +4,14 @@ import tiktoken
 import xxhash
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal, Sequence
+from typing import Literal
 from lm_deluge.models import APIModel
 from lm_deluge.image import Image
 
 ###############################################################################
 # 1. Low-level content blocks – either text or an image                       #
 ###############################################################################
-Role = Literal["system", "user", "assistant"]
+Role = Literal["system", "user", "assistant", "tool"]
 
 
 @dataclass(slots=True)
@@ -40,18 +40,235 @@ class Text:
         return {"type": "text", "text": self.text}
 
 
+@dataclass(slots=True)
+class ToolCall:
+    id: str  # unique identifier
+    name: str  # function name
+    arguments: dict  # parsed arguments
+    type: str = field(init=False, default="tool_call")
+
+    @property
+    def fingerprint(self) -> str:
+        return xxhash.xxh64(
+            f"{self.id}:{self.name}:{json.dumps(self.arguments, sort_keys=True)}".encode()
+        ).hexdigest()
+
+    # ── provider-specific emission ────────────────────────────────────────────
+    def oa_chat(self) -> dict:  # OpenAI Chat Completions
+        return {
+            "id": self.id,
+            "type": "function",
+            "function": {"name": self.name, "arguments": json.dumps(self.arguments)},
+        }
+
+    def oa_resp(self) -> dict:  # OpenAI Responses
+        return {
+            "type": "function_call",
+            "id": self.id,
+            "name": self.name,
+            "arguments": self.arguments,
+        }
+
+    def anthropic(self) -> dict:  # Anthropic Messages
+        return {
+            "type": "tool_use",
+            "id": self.id,
+            "name": self.name,
+            "input": self.arguments,
+        }
+
+    def gemini(self) -> dict:
+        return {"functionCall": {"name": self.name, "args": self.arguments}}
+
+    def mistral(self) -> dict:
+        return {
+            "type": "tool_call",
+            "id": self.id,
+            "function": {"name": self.name, "arguments": json.dumps(self.arguments)},
+        }
+
+
+@dataclass(slots=True)
+class ToolResult:
+    tool_call_id: str  # references the ToolCall.id
+    result: str  # tool execution result
+    type: str = field(init=False, default="tool_result")
+
+    @property
+    def fingerprint(self) -> str:
+        return xxhash.xxh64(f"{self.tool_call_id}:{self.result}".encode()).hexdigest()
+
+    # ── provider-specific emission ────────────────────────────────────────────
+    def oa_chat(
+        self,
+    ) -> dict:  # OpenAI Chat Completions - tool results are separate messages
+        return {"tool_call_id": self.tool_call_id, "content": self.result}
+
+    def oa_resp(self) -> dict:  # OpenAI Responses
+        return {
+            "type": "function_result",
+            "call_id": self.tool_call_id,
+            "result": self.result,
+        }
+
+    def anthropic(self) -> dict:  # Anthropic Messages
+        return {
+            "type": "tool_result",
+            "tool_use_id": self.tool_call_id,
+            "content": self.result,
+        }
+
+    def gemini(self) -> dict:
+        return {
+            "functionResponse": {
+                "name": self.tool_call_id,  # Gemini uses name field for ID
+                "response": {"result": self.result},
+            }
+        }
+
+    def mistral(self) -> dict:
+        return {
+            "type": "tool_result",
+            "tool_call_id": self.tool_call_id,
+            "content": self.result,
+        }
+
+
+@dataclass(slots=True)
+class Thinking:
+    content: str  # reasoning content (o1, Claude thinking, etc.)
+    type: str = field(init=False, default="thinking")
+
+    @property
+    def fingerprint(self) -> str:
+        return xxhash.xxh64(self.content.encode()).hexdigest()
+
+    # ── provider-specific emission ────────────────────────────────────────────
+    def oa_chat(self) -> dict:  # OpenAI Chat Completions
+        # Thinking is typically not emitted back, but if needed:
+        return {"type": "text", "text": f"[Thinking: {self.content}]"}
+
+    def oa_resp(self) -> dict:  # OpenAI Responses
+        return {"type": "reasoning", "content": self.content}
+
+    def anthropic(self) -> dict:  # Anthropic Messages
+        return {"type": "thinking", "thinking": self.content}
+
+    def gemini(self) -> dict:
+        return {"text": f"[Thinking: {self.content}]"}
+
+    def mistral(self) -> dict:
+        return {"type": "text", "text": f"[Thinking: {self.content}]"}
+
+
+Part = Text | Image | ToolCall | ToolResult | Thinking
+
+
 ###############################################################################
 # 2. One conversational turn (role + parts)                                   #
 ###############################################################################
 @dataclass(slots=True)
 class Message:
     role: Role
-    parts: list[Text | Image]
+    parts: list[Part]
 
     @property
     def fingerprint(self) -> str:
         return self.role + "," + ",".join(part.fingerprint for part in self.parts)
 
+    @property
+    def completion(self) -> str | None:
+        """Extract text content from the first Text part, for backward compatibility."""
+        for part in self.parts:
+            if isinstance(part, Text):
+                return part.text
+        return None
+
+    @property
+    def tool_calls(self) -> list["ToolCall"]:
+        """Get all tool call parts with proper typing."""
+        return [part for part in self.parts if part.type == "tool_call"]  # type: ignore
+
+    @property
+    def tool_results(self) -> list["ToolResult"]:
+        """Get all tool result parts with proper typing."""
+        return [part for part in self.parts if part.type == "tool_result"]  # type: ignore
+
+    @property
+    def text_parts(self) -> list["Text"]:
+        """Get all text parts with proper typing."""
+        return [part for part in self.parts if part.type == "text"]  # type: ignore
+
+    @property
+    def images(self) -> list[Image]:
+        """Get all image parts with proper typing."""
+        return [part for part in self.parts if part.type == "image"]  # type: ignore
+
+    @property
+    def thinking_parts(self) -> list["Thinking"]:
+        """Get all thinking parts with proper typing."""
+        return [part for part in self.parts if part.type == "thinking"]  # type: ignore
+
+    def to_log(self) -> dict:
+        """
+        Return a JSON-serialisable dict that fully captures the message.
+        """
+        content_blocks: list[dict] = []
+        for p in self.parts:
+            if isinstance(p, Text):
+                content_blocks.append({"type": "text", "text": p.text})
+            elif isinstance(p, Image):  # Image – redact the bytes, keep a hint
+                w, h = p.size
+                content_blocks.append({"type": "image", "tag": f"<Image ({w}×{h})>"})
+            elif isinstance(p, ToolCall):
+                content_blocks.append(
+                    {
+                        "type": "tool_call",
+                        "id": p.id,
+                        "name": p.name,
+                        "arguments": p.arguments,
+                    }
+                )
+            elif isinstance(p, ToolResult):
+                content_blocks.append(
+                    {
+                        "type": "tool_result",
+                        "tool_call_id": p.tool_call_id,
+                        "result": p.result,
+                    }
+                )
+            elif isinstance(p, Thinking):
+                content_blocks.append({"type": "thinking", "content": p.content})
+
+        return {"role": self.role, "content": content_blocks}
+
+    @classmethod
+    def from_log(cls, data: dict) -> "Message":
+        """Re-hydrate a Message previously produced by `to_log()`."""
+        role: Role = data["role"]
+        parts: list[Part] = []
+
+        for p in data["content"]:
+            if p["type"] == "text":
+                parts.append(Text(p["text"]))
+            elif p["type"] == "image":
+                # We only stored a placeholder tag, so keep that placeholder.
+                parts.append(Image(p["tag"], detail="low"))
+            elif p["type"] == "tool_call":
+                parts.append(
+                    ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                )
+            elif p["type"] == "tool_result":
+                parts.append(
+                    ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
+                )
+            elif p["type"] == "thinking":
+                parts.append(Thinking(content=p["content"]))
+            else:
+                raise ValueError(f"Unknown part type {p['type']!r}")
+
+        return cls(role, parts)
+
     def add_text(self, content: str) -> "Message":
         """Append a text block and return self for chaining."""
         self.parts.append(Text(content))
@@ -81,6 +298,21 @@ class Message:
         self.parts.append(img)
         return self
 
+    def add_tool_call(self, id: str, name: str, arguments: dict) -> "Message":
+        """Append a tool call block and return self for chaining."""
+        self.parts.append(ToolCall(id=id, name=name, arguments=arguments))
+        return self
+
+    def add_tool_result(self, tool_call_id: str, result: str) -> "Message":
+        """Append a tool result block and return self for chaining."""
+        self.parts.append(ToolResult(tool_call_id=tool_call_id, result=result))
+        return self
+
+    def add_thinking(self, content: str) -> "Message":
+        """Append a thinking block and return self for chaining."""
+        self.parts.append(Thinking(content=content))
+        return self
+
     # -------- convenient constructors --------
     @classmethod
     def user(
@@ -118,16 +350,32 @@ class Message:
             if msg["role"] in ["developer", "system"]
             else ("user" if msg["role"] == "user" else "assistant")
         )
-        parts: Sequence[Text | Image] = []
+        parts: list[Part] = []
         content = msg["content"]
         if isinstance(content, str):
-            parts.append(Text(content))
+            parts = [Text(content)]
         else:
+            part_list = []
             for item in content:
                 if item["type"] == "text":
-                    parts.append(Text(item["text"]))
+                    part_list.append(Text(item["text"]))
                 elif item["type"] == "image_url":
-                    parts.append(Image(data=item["image_url"]["url"]))
+                    part_list.append(Image(data=item["image_url"]["url"]))
+            parts = part_list
+
+        # Handle tool calls (assistant messages)
+        if "tool_calls" in msg:
+            part_list = list(parts) if parts else []
+            for tool_call in msg["tool_calls"]:
+                part_list.append(
+                    ToolCall(
+                        id=tool_call["id"],
+                        name=tool_call["function"]["name"],
+                        arguments=json.loads(tool_call["function"]["arguments"]),
+                    )
+                )
+            parts = part_list
+
         return cls(role, parts)
 
     @classmethod
@@ -140,10 +388,35 @@ class Message:
 
     # ───── provider-specific emission ─────
     def oa_chat(self) -> dict:
-        content = []
-        for p in self.parts:
-            content.append(p.oa_chat())
-        return {"role": self.role, "content": content}
+        if self.role == "tool":
+            # For tool messages, we expect a single ToolResult part (after splitting in to_openai)
+            tool_results = [p for p in self.parts if isinstance(p, ToolResult)]
+            if len(tool_results) == 1:
+                tool_result = tool_results[0]
+                return {
+                    "role": "tool",
+                    "tool_call_id": tool_result.tool_call_id,
+                    "content": tool_result.result,
+                }
+            else:
+                raise ValueError(
+                    f"Tool role messages must contain exactly one ToolResult part for OpenAI, got {len(tool_results)}"
+                )
+        else:
+            content = []
+            tool_calls = []
+
+            for p in self.parts:
+                if isinstance(p, ToolCall):
+                    tool_calls.append(p.oa_chat())
+                else:
+                    content.append(p.oa_chat())
+
+            result = {"role": self.role, "content": content}
+            if tool_calls:
+                result["tool_calls"] = tool_calls
+
+            return result
 
     def oa_resp(self) -> dict:
         content = [p.oa_resp() for p in self.parts]
@@ -155,7 +428,7 @@ class Message:
             raise ValueError("Anthropic keeps system outside message list")
         content = [p.anthropic() for p in self.parts]
         # Shortcut: single text becomes a bare string
-        if len(content) == 1 and content[0]["type"] == "text":
+        if len(content) == 1 and content[0].get("type") == "text":
             content = content[0]["text"]
         return {"role": self.role, "content": content}
 
@@ -210,9 +483,34 @@ class Conversation:
         self.messages.append(msg)
         return self
 
+    def add_tool_result(self, tool_call_id: str, result: str) -> "Conversation":
+        """Add a tool result to the conversation.
+
+        If the conversation ends with a tool message, append to it (for parallel tool calls).
+        Otherwise, create a new tool message.
+        """
+        if self.messages and self.messages[-1].role == "tool":
+            # Append to existing tool message (parallel tool calls)
+            self.messages[-1].add_tool_result(tool_call_id, result)
+        else:
+            # Create new tool message
+            tool_msg = Message("tool", [])
+            tool_msg.add_tool_result(tool_call_id, result)
+            self.messages.append(tool_msg)
+        return self
+
     # ── conversions -----------------------------------------------------------
     def to_openai(self) -> list[dict]:
-        return [m.oa_chat() for m in self.messages]
+        result = []
+        for m in self.messages:
+            if m.role == "tool" and len(m.tool_results) > 1:
+                # Split tool messages with multiple results into separate messages for OpenAI
+                for tool_result in m.tool_results:
+                    tool_msg = Message("tool", [tool_result])
+                    result.append(tool_msg.oa_chat())
+            else:
+                result.append(m.oa_chat())
+        return result
 
     def to_openai_responses(self) -> dict:
         # OpenAI Responses = single “input” array, role must be user/assistant
@@ -227,7 +525,16 @@ class Conversation:
             ),
             None,
         )
-        other = [m.anthropic() for m in self.messages if m.role != "system"]
+        other = []
+        for m in self.messages:
+            if m.role == "system":
+                continue
+            elif m.role == "tool":
+                # Convert tool messages to user messages for Anthropic
+                user_msg = Message("user", m.parts)
+                other.append(user_msg.anthropic())
+            else:
+                other.append(m.anthropic())
         return system_msg, other
 
     def to_gemini(self) -> tuple[str | None, list[dict]]:
@@ -295,11 +602,30 @@ class Conversation:
             for p in msg.parts:
                 if isinstance(p, Text):
                     content_blocks.append({"type": "text", "text": p.text})
-                else:  # Image – redact the bytes, keep a hint
+                elif isinstance(p, Image):  # Image – redact the bytes, keep a hint
                     w, h = p.size
                     content_blocks.append(
                         {"type": "image", "tag": f"<Image ({w}×{h})>"}
                     )
+                elif isinstance(p, ToolCall):
+                    content_blocks.append(
+                        {
+                            "type": "tool_call",
+                            "id": p.id,
+                            "name": p.name,
+                            "arguments": p.arguments,
+                        }
+                    )
+                elif isinstance(p, ToolResult):
+                    content_blocks.append(
+                        {
+                            "type": "tool_result",
+                            "tool_call_id": p.tool_call_id,
+                            "result": p.result,
+                        }
+                    )
+                elif isinstance(p, Thinking):
+                    content_blocks.append({"type": "thinking", "content": p.content})
             serialized.append({"role": msg.role, "content": content_blocks})
 
         return {"messages": serialized}
@@ -311,7 +637,7 @@ class Conversation:
 
         for m in payload.get("messages", []):
             role: Role = m["role"]  # 'system' | 'user' | 'assistant'
-            parts: list[Text | Image] = []
+            parts: list[Text | Image | ToolCall | ToolResult | Thinking] = []
 
             for p in m["content"]:
                 if p["type"] == "text":
@@ -320,6 +646,16 @@ class Conversation:
                     # We only stored a placeholder tag, so keep that placeholder.
                     # You could raise instead if real image bytes are required.
                     parts.append(Image(p["tag"], detail="low"))
+                elif p["type"] == "tool_call":
+                    parts.append(
+                        ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                    )
+                elif p["type"] == "tool_result":
+                    parts.append(
+                        ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
+                    )
+                elif p["type"] == "thinking":
+                    parts.append(Thinking(content=p["content"]))
                 else:
                     raise ValueError(f"Unknown part type {p['type']!r}")
 

lm_deluge/tool.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Literal, Callable
+from typing import Any, Literal, Callable
 from pydantic import BaseModel, Field
 
 
@@ -9,7 +9,7 @@ class ToolSpec(BaseModel):
 
     name: str
     description: str
-    parameters: Dict[str, Any]
+    parameters: dict[str, Any]
     required: list[str] = Field(default_factory=list)
     additionalProperties: bool | None = None  # only
     # if desired, can provide a callable to run the tool
@@ -20,21 +20,20 @@ class ToolSpec(BaseModel):
             raise ValueError("No run function provided")
         return self.run(**kwargs)
 
-    def _json_schema(self, include_additional_properties=False) -> Dict[str, Any]:
-        return {
+    def _json_schema(self, include_additional_properties=False) -> dict[str, Any]:
+        res = {
             "type": "object",
             "properties": self.parameters,
-            "required": self.required or [],
-            **(
-                {"additionalProperties": self.additionalProperties}
-                if self.additionalProperties is not None
-                and include_additional_properties
-                else {}
-            ),
+            # for openai all must be required
+            "required": list(self.parameters.keys()),
         }
+        if include_additional_properties:
+            res["additionalProperties"] = False
+
+        return res
 
     # ---------- dumpers ----------
-    def for_openai_responses(self) -> Dict[str, Any]:
+    def for_openai_responses(self) -> dict[str, Any]:
         return {
             "type": "function",
             "name": self.name,
@@ -42,25 +41,25 @@ class ToolSpec(BaseModel):
             "parameters": self._json_schema(include_additional_properties=True),
         }
 
-    def for_openai_completions(self, *, strict: bool = True) -> Dict[str, Any]:
+    def for_openai_completions(self, *, strict: bool = True) -> dict[str, Any]:
         return {
             "type": "function",
             "function": {
                 "name": self.name,
                 "description": self.description,
-                "parameters": self._json_schema(),
+                "parameters": self._json_schema(include_additional_properties=True),
                 "strict": strict,
             },
         }
 
-    def for_anthropic(self) -> Dict[str, Any]:
+    def for_anthropic(self) -> dict[str, Any]:
         return {
             "name": self.name,
             "description": self.description,
             "input_schema": self._json_schema(),
         }
 
-    def for_google(self) -> Dict[str, Any]:
+    def for_google(self) -> dict[str, Any]:
         """
         Shape used by google.genai docs.
         """
@@ -76,7 +75,7 @@ class ToolSpec(BaseModel):
             "openai-responses", "openai-completions", "anthropic", "google"
         ],
         **kw,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         if provider == "openai-responses":
             return self.for_openai_responses()
         if provider == "openai-completions":
@@ -86,21 +85,3 @@ class ToolSpec(BaseModel):
         if provider == "google":
             return self.for_google()
         raise ValueError(provider)
-
-
-# ---- computer tools (for non-CUA models) ----
-_BUTTONS = ["left", "right", "wheel", "back", "forward"]
-
-# --- helpers ----
-_COORD_OBJECT = {
-    "type": "object",
-    "properties": {
-        "x": {"type": "integer", "description": "X-coordinate in pixels"},
-        "y": {"type": "integer", "description": "Y-coordinate in pixels"},
-    },
-    "required": ["x", "y"],
-}
-
-
-def _coord_field(desc: str):
-    return {"type": "integer", "description": desc}

{lm_deluge-0.0.7.dist-info → lm_deluge-0.0.9.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.7
+Version: 0.0.9
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: python-dotenv
 Requires-Dist: json5
 Requires-Dist: PyYAML
@@ -22,10 +23,11 @@ Requires-Dist: pdf2image
 Requires-Dist: pillow
 Requires-Dist: fasttext-wheel
 Requires-Dist: fasttext-langdetect
+Dynamic: license-file
 
-# lm_deluge
+# lm-deluge
 
-`lm_deluge` is a lightweight helper library for maxing out your rate limits with LLM providers. It provides the following:
+`lm-deluge` is a lightweight helper library for maxing out your rate limits with LLM providers. It provides the following:
 
 - **Unified client** – Send prompts to all relevant models with a single client.
 - **Massive concurrency with throttling** – Set `max_tokens_per_minute` and `max_requests_per_minute` and let it fly. The client will process as many requests as possible while respecting rate limits and retrying failures.
@@ -77,11 +79,7 @@ print(resp[0].completion)
 
 API calls can be customized in a few ways.
 
-1. **Sampling Parameters.** This determines things like structured outputs, maximum completion tokens, nucleus sampling, etc. Provide a custom `SamplingParams` to the `LLMClient` to set temperature, top_p, json_mode, max_new_tokens, and/or reasoning_effort.
-
-You can pass 1 `SamplingParams` to use for all models, or a list of `SamplingParams` that's the same length as the list of models. You can also pass many of these arguments directly to `LLMClient.basic` so you don't have to construct an entire `SamplingParams` object.
-
-
+1. **Sampling Parameters.** This determines things like structured outputs, maximum completion tokens, nucleus sampling, etc. Provide a custom `SamplingParams` to the `LLMClient` to set temperature, top_p, json_mode, max_new_tokens, and/or reasoning_effort. You can pass 1 `SamplingParams` to use for all models, or a list of `SamplingParams` that's the same length as the list of models. You can also pass many of these arguments directly to `LLMClient.basic` so you don't have to construct an entire `SamplingParams` object.
 2. **Arguments to LLMClient.** This is where you set request timeout, rate limits, model name(s), model weight(s) for distributing requests across models, retries, and caching.
 3. **Arguments to process_prompts.** Per-call, you can set verbosity, whether to display progress, and whether to return just completions (rather than the full APIResponse object).
 

{lm_deluge-0.0.7.dist-info → lm_deluge-0.0.9.dist-info}/RECORD

@@ -1,22 +1,23 @@
 lm_deluge/__init__.py,sha256=rndOr4Rcfnpttz-onWU3vVEm-MM0WDFgz6KexKPAx0k,222
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=ERH0SkNvdM1zc8HYS5dxRGxVxUb4CXpUhveG3mz-w2I,28533
+lm_deluge/client.py,sha256=rk0YAUvC5kF3OuxnmYlkT8I6NjAmEJ6TUfryQbRkmXw,28960
 lm_deluge/embed.py,sha256=m-X8UK4gV9KKD7Wv3yarAceMQaj7gR1JwzD_sB0MOQY,13183
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
 lm_deluge/gemini_limits.py,sha256=V9mpS9JtXYz7AY6OuKyQp5TuIMRH1BVv9YrSNmGmHNA,1569
 lm_deluge/image.py,sha256=hFbRajqEVQbkirAfOxsTPkeq-27Zl-so4AWBFeUbpBI,7161
-lm_deluge/models.py,sha256=67bgQnDoJKIen3B_cmWGtkW8Pi6zUWsnQFfPWMWOErM,41939
-lm_deluge/prompt.py,sha256=bhDAlfUQ_Fq6Wh-L9jOfoiMbDGyVKGkjGicnwKJWpcI,12680
+lm_deluge/models.py,sha256=qdUsHC1kz82ZwduUU_rBcvJP4j2JXCL3Q2RtbHWc1H8,44998
+lm_deluge/prompt.py,sha256=_pJYwgjL39lDzMNmae8pPIBoORm_ekSM_9qU2iGGpOc,25445
 lm_deluge/rerank.py,sha256=tW1c3gQCAqaF8Ez-r-4qxYAcdKqxnLMxwHApKOUKwk4,11289
 lm_deluge/sampling_params.py,sha256=E2kewh1vz-1Qcy5xNBCzihfGgT_GcHYMfzaWb3FLiXs,739
-lm_deluge/tool.py,sha256=RVUW3E3FW11jCM-R7pIL1GpRs1YKCOjvTkL1D5xPetk,3196
+lm_deluge/tool.py,sha256=zXletfGtpgBCXuqietZn-eaOItbIyOROskTbaSjfwEk,2701
 lm_deluge/tracker.py,sha256=Dk99scN_NeDEO0gkLO5efXiZq11Ga-k6cerUHWN7IWY,1292
 lm_deluge/api_requests/__init__.py,sha256=_aSpD6CJL9g6OpLPoChXiHjl4MH_OlGcKgfZaW8cgLM,71
-lm_deluge/api_requests/anthropic.py,sha256=URbiD-ANn_P3StFJVP2JoDWuoloZVsAUly8CGSyV2Kw,6618
-lm_deluge/api_requests/base.py,sha256=Yt5Bxd5C5mZrbAMQYDghk0KRhUChSbTEsVI8DoThZBs,14805
-lm_deluge/api_requests/common.py,sha256=EjwTnKrvgBx-HnRVt0kSJZ9RM7CM-QyhlIQkr1jxP-4,220
-lm_deluge/api_requests/mistral.py,sha256=ThlV1jBfhpAwkaqPKhdUq-lIq2OienRbhEaSK4cctvI,5370
-lm_deluge/api_requests/openai.py,sha256=YgJMUio23ks6VLv6BDBZAW6Bnfd2fpidSidaHXzyXFY,6135
+lm_deluge/api_requests/anthropic.py,sha256=MMI_w9hVbevQpcqP3NVVindpTmLb2KHqjJQpIzCi5RM,7240
+lm_deluge/api_requests/base.py,sha256=w0MEOCIccxxy2c67Y2Y-QBox9rinIxQ7MLnp8953sjQ,15954
+lm_deluge/api_requests/bedrock.py,sha256=cvB85BFvL9HKTUsP9qFUCLQzJh83IQNAcLXuW6ReZK8,10520
+lm_deluge/api_requests/common.py,sha256=U0mX_wC3Tzg2-1u9nYUCTQqYzuYJqvLrICCNW_dbbJM,287
+lm_deluge/api_requests/mistral.py,sha256=gCi4R61oh759ZX6TKrT-fnQwIQaOGcPXhWrDsjJwPOY,5388
+lm_deluge/api_requests/openai.py,sha256=BuMiM_2zJQXfnUjTT94JxJi3ZX5V-KQQueRG-R0SGuc,7361
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
 lm_deluge/api_requests/deprecated/deepseek.py,sha256=FEApI93VAWDwuaqTooIyKMgONYqRhdUmiAPBRme-IYs,4582
@@ -30,7 +31,8 @@ lm_deluge/util/json.py,sha256=dCeG9j1D17rXmQJbKJH79X0CGof4Wlqd55TDg4D6ky8,5388
 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.7.dist-info/METADATA,sha256=YQhMtiQrQcz1eaCWmcb_FUDg6gwddZbAJHbUaoomQVA,8035
-lm_deluge-0.0.7.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-lm_deluge-0.0.7.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.7.dist-info/RECORD,,
+lm_deluge-0.0.9.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.9.dist-info/METADATA,sha256=hIv-9R30IJXuh6AHR0pZkktvsbSihThOuu9D9AniKIg,8076
+lm_deluge-0.0.9.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+lm_deluge-0.0.9.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.9.dist-info/RECORD,,

lm_deluge-0.0.9.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025, Taylor AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.