lm-deluge 0.0.55__tar.gz → 0.0.57__tar.gz

{lm_deluge-0.0.55/src/lm_deluge.egg-info → lm_deluge-0.0.57}/PKG-INFO

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

{lm_deluge-0.0.55 → lm_deluge-0.0.57}/pyproject.toml

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

{lm_deluge-0.0.55 → lm_deluge-0.0.57}/src/lm_deluge/__init__.py

@@ -1,7 +1,7 @@
 from .client import APIResponse, LLMClient, SamplingParams
 from .file import File
 from .prompt import Conversation, Message
-from .tool import Tool
+from .tool import Tool, ToolParams
 
 # dotenv.load_dotenv() - don't do this, fucks with other packages
 
@@ -12,5 +12,6 @@ __all__ = [
     "Conversation",
     "Message",
     "Tool",
+    "ToolParams",
     "File",
 ]

{lm_deluge-0.0.55 → lm_deluge-0.0.57}/src/lm_deluge/client.py

@@ -295,6 +295,7 @@ class _LLMClient(BaseModel):
         # Handle successful response
         if not response.is_error:
             context.status_tracker.task_succeeded(context.task_id)
+            context.status_tracker.track_usage(response)
             # Cache successful responses immediately
             if self.cache and response.completion:
                 # print(f"DEBUG: Caching successful response")
@@ -333,6 +334,8 @@ class _LLMClient(BaseModel):
 
         # No retries left or no retry queue - final failure
         context.status_tracker.task_failed(context.task_id)
+        # Track usage even for failed requests if they made an API call
+        context.status_tracker.track_usage(response)
         context.maybe_callback(response, context.status_tracker)
 
         # Print final error message
@@ -615,23 +618,20 @@ class _LLMClient(BaseModel):
                     mcp_tools = await tool.to_tools()
                     expanded_tools.extend(mcp_tools)
 
-        last_response: APIResponse | None = None
+        response: APIResponse | None = None
 
         for _ in range(max_rounds):
-            responses = await self.process_prompts_async(
-                [conversation],
+            response = await self.start(
+                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:
+            if response is None or response.content is None:
                 break
 
-            conversation = conversation.with_message(last_response.content)
+            conversation = conversation.with_message(response.content)
 
-            tool_calls = last_response.content.tool_calls
+            tool_calls = response.content.tool_calls
             if not tool_calls:
                 break
 
@@ -654,12 +654,12 @@ class _LLMClient(BaseModel):
                 if not isinstance(result, (str, dict, list)):
                     result = str(result)
 
-                conversation.add_tool_result(call.id, result)  # type: ignore
+                conversation.with_tool_result(call.id, result)  # type: ignore
 
-        if last_response is None:
+        if response is None:
             raise RuntimeError("model did not return a response")
 
-        return conversation, last_response
+        return conversation, response
 
     def run_agent_loop_sync(
         self,

{lm_deluge-0.0.55 → lm_deluge-0.0.57}/src/lm_deluge/prompt.py

@@ -144,8 +144,8 @@ class ToolResult:
     def oa_chat(
         self,
     ) -> dict:  # OpenAI Chat Completions - tool results are separate messages
-        print("serializing toolresult with oa_chat...")
-        print("typeof self.result:", type(self.result))
+        # print("serializing toolresult with oa_chat...")
+        # print("typeof self.result:", type(self.result))
         if isinstance(self.result, str):
             return {
                 "role": "tool",
@@ -174,8 +174,7 @@ class ToolResult:
             raise ValueError("result type not supported")
 
     def oa_resp(self) -> dict:  # OpenAI Responses
-        print("serializing toolresult with oa_chat...")
-        print("typeof self.result:", type(self.result))
+        # print("typeof self.result:", type(self.result))
         # if normal (not built-in just return the regular output
         if not self.built_in:
             result = (
@@ -466,7 +465,7 @@ class Message:
         self.parts.append(ToolCall(id=id, name=name, arguments=arguments))
         return self
 
-    def add_tool_result(
+    def with_tool_result(
         self, tool_call_id: str, result: str | list[ToolResultPart]
     ) -> "Message":
         """Append a tool result block and return self for chaining."""
@@ -1189,11 +1188,11 @@ class Conversation:
         """
         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)
+            self.messages[-1].with_tool_result(tool_call_id, result)
         else:
             # Create new tool message
             tool_msg = Message("tool", [])
-            tool_msg.add_tool_result(tool_call_id, result)
+            tool_msg.with_tool_result(tool_call_id, result)
             self.messages.append(tool_msg)
         return self
 

{lm_deluge-0.0.55 → lm_deluge-0.0.57}/src/lm_deluge/tool.py

@@ -1,7 +1,17 @@
 import asyncio
 import inspect
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Callable, Coroutine, Literal, TypedDict, get_type_hints
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Literal,
+    Type,
+    TypedDict,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from fastmcp import Client  # pip install fastmcp >= 2.0
 from mcp.types import Tool as MCPTool
@@ -11,6 +21,196 @@ from lm_deluge.image import Image
 from lm_deluge.prompt import Text, ToolResultPart
 
 
+def _python_type_to_json_schema_enhanced(python_type: Any) -> dict[str, Any]:
+    """
+    Convert Python type annotations to JSON Schema.
+    Handles: primitives, Optional, Literal, list[T], dict[str, T], Union.
+    """
+    # Get origin and args for generic types
+    origin = get_origin(python_type)
+    args = get_args(python_type)
+
+    # Handle Optional[T] or T | None
+    if origin is type(None) or python_type is type(None):
+        return {"type": "null"}
+
+    # Handle Union types (including Optional)
+    if origin is Literal:
+        # Literal["a", "b"] -> enum
+        return {"type": "string", "enum": list(args)}
+
+    # Handle list[T]
+    if origin is list:
+        if args:
+            items_schema = _python_type_to_json_schema_enhanced(args[0])
+            return {"type": "array", "items": items_schema}
+        return {"type": "array"}
+
+    # Handle dict[str, T]
+    if origin is dict:
+        if len(args) >= 2:
+            # For dict[str, T], we can set additionalProperties
+            value_schema = _python_type_to_json_schema_enhanced(args[1])
+            return {"type": "object", "additionalProperties": value_schema}
+        return {"type": "object"}
+
+    # Handle basic types
+    if python_type is int:
+        return {"type": "integer"}
+    elif python_type is float:
+        return {"type": "number"}
+    elif python_type is str:
+        return {"type": "string"}
+    elif python_type is bool:
+        return {"type": "boolean"}
+    elif python_type is list:
+        return {"type": "array"}
+    elif python_type is dict:
+        return {"type": "object"}
+    else:
+        # Default to string for unknown types
+        return {"type": "string"}
+
+
+class ToolParams:
+    """
+    Helper class for constructing tool parameters more easily.
+
+    Usage:
+        # Simple constructor with Python types
+        params = ToolParams({"city": str, "age": int})
+
+        # With extras (description, enum, etc)
+        params = ToolParams({
+            "operation": (str, {"enum": ["add", "sub"], "description": "Math operation"}),
+            "value": (int, {"description": "The value"})
+        })
+
+        # From Pydantic model
+        params = ToolParams.from_pydantic(MyModel)
+
+        # From TypedDict
+        params = ToolParams.from_typed_dict(MyTypedDict)
+
+        # From existing JSON Schema
+        params = ToolParams.from_json_schema(schema_dict, required=["field1"])
+    """
+
+    def __init__(self, spec: dict[str, Any]):
+        """
+        Create ToolParams from a dict mapping parameter names to types or (type, extras) tuples.
+
+        Args:
+            spec: Dict where values can be:
+                - A Python type (str, int, list[str], etc.)
+                - A tuple of (type, extras_dict) for additional JSON Schema properties
+                - An already-formed JSON Schema dict (passed through as-is)
+        """
+        self.parameters: dict[str, Any] = {}
+        self.required: list[str] = []
+
+        for param_name, param_spec in spec.items():
+            # If it's a tuple, extract (type, extras)
+            if isinstance(param_spec, tuple):
+                param_type, extras = param_spec
+                schema = _python_type_to_json_schema_enhanced(param_type)
+                schema.update(extras)
+                self.parameters[param_name] = schema
+                # Mark as required unless explicitly marked as optional
+                if extras.get("optional") is not True:
+                    self.required.append(param_name)
+            # If it's already a dict with "type" key, use as-is
+            elif isinstance(param_spec, dict) and "type" in param_spec:
+                self.parameters[param_name] = param_spec
+                # Assume required unless marked optional
+                if param_spec.get("optional") is not True:
+                    self.required.append(param_name)
+            # Otherwise treat as a Python type
+            else:
+                self.parameters[param_name] = _python_type_to_json_schema_enhanced(
+                    param_spec
+                )
+                self.required.append(param_name)
+
+    @classmethod
+    def from_pydantic(cls, model: Type[BaseModel]) -> "ToolParams":
+        """
+        Create ToolParams from a Pydantic model.
+
+        Args:
+            model: A Pydantic BaseModel class
+        """
+        # Get the JSON schema from Pydantic
+        schema = model.model_json_schema()
+        properties = schema.get("properties", {})
+        required = schema.get("required", [])
+
+        return cls.from_json_schema(properties, required)
+
+    @classmethod
+    def from_typed_dict(cls, typed_dict: Type) -> "ToolParams":
+        """
+        Create ToolParams from a TypedDict.
+
+        Args:
+            typed_dict: A TypedDict class
+        """
+        hints = get_type_hints(typed_dict)
+
+        # TypedDict doesn't have a built-in way to mark optional fields,
+        # but we can check for Optional in the type hints
+        params = {}
+        required = []
+
+        for field_name, field_type in hints.items():
+            # Check if it's Optional (Union with None)
+            origin = get_origin(field_type)
+            # args = get_args(field_type)
+
+            is_optional = False
+            actual_type = field_type
+
+            # Check for Union types (including Optional[T] which is Union[T, None])
+            if origin is type(None):
+                is_optional = True
+                actual_type = type(None)
+
+            # For now, treat all TypedDict fields as required unless they're explicitly Optional
+            schema = _python_type_to_json_schema_enhanced(actual_type)
+            params[field_name] = schema
+
+            if not is_optional:
+                required.append(field_name)
+
+        instance = cls.__new__(cls)
+        instance.parameters = params
+        instance.required = required
+        return instance
+
+    @classmethod
+    def from_json_schema(
+        cls, properties: dict[str, Any], required: list[str] | None = None
+    ) -> "ToolParams":
+        """
+        Create ToolParams from an existing JSON Schema properties dict.
+
+        Args:
+            properties: The "properties" section of a JSON Schema
+            required: List of required field names
+        """
+        instance = cls.__new__(cls)
+        instance.parameters = properties
+        instance.required = required or []
+        return instance
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Convert to a dict with 'parameters' and 'required' keys.
+        Useful for unpacking into Tool constructor.
+        """
+        return {"parameters": self.parameters, "required": self.required}
+
+
 async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
     metas: list[MCPTool] = await client.list_tools()
 
@@ -79,6 +279,24 @@ class Tool(BaseModel):
             )
         return v
 
+    @field_validator("parameters", mode="before")
+    @classmethod
+    def validate_parameters(cls, v: Any) -> dict[str, Any] | None:
+        """Accept ToolParams objects and convert to dict for backwards compatibility."""
+        if isinstance(v, ToolParams):
+            return v.parameters
+        return v
+
+    def model_post_init(self, __context: Any) -> None:
+        """
+        After validation, if parameters came from ToolParams, also update required list.
+        This is called by Pydantic after __init__.
+        """
+        # This is a bit tricky - we need to capture the required list from ToolParams
+        # Since Pydantic has already converted it in the validator, we can't access it here
+        # Instead, we'll handle this differently in the convenience constructors
+        pass
+
     def _is_async(self) -> bool:
         return inspect.iscoroutinefunction(self.run)
 
@@ -143,7 +361,7 @@ class Tool(BaseModel):
             param_type = type_hints.get(param_name, str)
 
             # Convert Python types to JSON Schema types
-            json_type = cls._python_type_to_json_schema(param_type)
+            json_type = _python_type_to_json_schema_enhanced(param_type)
 
             parameters[param_name] = json_type
 
@@ -209,6 +427,119 @@ class Tool(BaseModel):
                 return t
         raise ValueError(f"Tool '{tool_name}' not found on that server")
 
+    @classmethod
+    def from_params(
+        cls,
+        name: str,
+        params: ToolParams,
+        *,
+        description: str | None = None,
+        run: Callable | None = None,
+        **kwargs,
+    ) -> "Tool":
+        """
+        Create a Tool from a ToolParams object.
+
+        Args:
+            name: Tool name
+            params: ToolParams object defining the parameter schema
+            description: Optional description
+            run: Optional callable to execute the tool
+            **kwargs: Additional Tool arguments
+
+        Example:
+            params = ToolParams({"city": str, "age": int})
+            tool = Tool.from_params("get_user", params, run=my_function)
+        """
+        return cls(
+            name=name,
+            description=description,
+            parameters=params.parameters,
+            required=params.required,
+            run=run,
+            **kwargs,
+        )
+
+    @classmethod
+    def from_pydantic(
+        cls,
+        name: str,
+        model: Type[BaseModel],
+        *,
+        description: str | None = None,
+        run: Callable | None = None,
+        **kwargs,
+    ) -> "Tool":
+        """
+        Create a Tool from a Pydantic model.
+
+        Args:
+            name: Tool name
+            model: Pydantic BaseModel class
+            description: Optional description (defaults to model docstring)
+            run: Optional callable to execute the tool
+            **kwargs: Additional Tool arguments
+
+        Example:
+            class UserQuery(BaseModel):
+                city: str
+                age: int
+
+            tool = Tool.from_pydantic("get_user", UserQuery, run=my_function)
+        """
+        params = ToolParams.from_pydantic(model)
+
+        # Use model docstring as default description if not provided
+        if description is None and model.__doc__:
+            description = model.__doc__.strip()
+
+        return cls(
+            name=name,
+            description=description,
+            parameters=params.parameters,
+            required=params.required,
+            run=run,
+            **kwargs,
+        )
+
+    @classmethod
+    def from_typed_dict(
+        cls,
+        name: str,
+        typed_dict: Type,
+        *,
+        description: str | None = None,
+        run: Callable | None = None,
+        **kwargs,
+    ) -> "Tool":
+        """
+        Create a Tool from a TypedDict.
+
+        Args:
+            name: Tool name
+            typed_dict: TypedDict class
+            description: Optional description
+            run: Optional callable to execute the tool
+            **kwargs: Additional Tool arguments
+
+        Example:
+            class UserQuery(TypedDict):
+                city: str
+                age: int
+
+            tool = Tool.from_typed_dict("get_user", UserQuery, run=my_function)
+        """
+        params = ToolParams.from_typed_dict(typed_dict)
+
+        return cls(
+            name=name,
+            description=description,
+            parameters=params.parameters,
+            required=params.required,
+            run=run,
+            **kwargs,
+        )
+
     @staticmethod
     def _tool_from_meta(meta: dict[str, Any], runner) -> "Tool":
         props = meta["inputSchema"].get("properties", {})
@@ -225,22 +556,11 @@ class Tool(BaseModel):
 
     @staticmethod
     def _python_type_to_json_schema(python_type) -> dict[str, Any]:
-        """Convert Python type to JSON Schema type definition."""
-        if python_type is int:
-            return {"type": "integer"}
-        elif python_type is float:
-            return {"type": "number"}
-        elif python_type is str:
-            return {"type": "string"}
-        elif python_type is bool:
-            return {"type": "boolean"}
-        elif python_type is list:
-            return {"type": "array"}
-        elif python_type is dict:
-            return {"type": "object"}
-        else:
-            # Default to string for unknown types
-            return {"type": "string"}
+        """
+        Convert Python type to JSON Schema type definition.
+        Now delegates to enhanced version for better type support.
+        """
+        return _python_type_to_json_schema_enhanced(python_type)
 
     def _json_schema(
         self, include_additional_properties=False, remove_defaults=False

{lm_deluge-0.0.55 → lm_deluge-0.0.57}/src/lm_deluge/tracker.py

@@ -33,6 +33,13 @@ class StatusTracker:
     total_requests: int = 0
     retry_queue: asyncio.Queue = field(default_factory=asyncio.Queue)
 
+    # Cumulative usage tracking
+    total_cost: float = 0.0
+    total_input_tokens: int = 0  # non-cached input tokens
+    total_cache_read_tokens: int = 0
+    total_cache_write_tokens: int = 0
+    total_output_tokens: int = 0
+
     # Progress bar configuration
     use_progress_bar: bool = True
     progress_bar_total: int | None = None
@@ -131,6 +138,25 @@ class StatusTracker:
         self.num_tasks_in_progress -= 1
         self.num_tasks_failed += 1
 
+    def track_usage(self, response):
+        """Accumulate usage statistics from a completed request.
+
+        Args:
+            response: APIResponse object containing usage and cost information
+        """
+        if response.cost:
+            self.total_cost += response.cost
+
+        if response.usage:
+            self.total_output_tokens += response.usage.output_tokens
+            self.total_input_tokens += response.usage.input_tokens
+
+            if response.usage.cache_read_tokens:
+                self.total_cache_read_tokens += response.usage.cache_read_tokens
+
+            if response.usage.cache_write_tokens:
+                self.total_cache_write_tokens += response.usage.cache_write_tokens
+
     def log_final_status(self):
         # Close progress bar before printing final status
         self.close_progress_bar()
@@ -144,6 +170,26 @@ class StatusTracker:
                 f"{self.num_rate_limit_errors} rate limit errors received. Consider running at a lower rate."
             )
 
+        # Display cumulative usage stats if available
+        if (
+            self.total_cost > 0
+            or self.total_input_tokens > 0
+            or self.total_output_tokens > 0
+        ):
+            usage_parts = []
+            if self.total_cost > 0:
+                usage_parts.append(f"💰 Cost: ${self.total_cost:.4f}")
+            if self.total_input_tokens > 0 or self.total_output_tokens > 0:
+                usage_parts.append(
+                    f"🔡 Tokens: {self.total_input_tokens:,} in / {self.total_output_tokens:,} out"
+                )
+            if self.total_cache_read_tokens > 0:
+                usage_parts.append(f"Cache: {self.total_cache_read_tokens:,} read")
+            if self.total_cache_write_tokens > 0:
+                usage_parts.append(f"{self.total_cache_write_tokens:,} write")
+
+            print("  ", " • ".join(usage_parts))
+
     @property
     def pbar(self) -> tqdm | None:
         """Backward compatibility property to access progress bar."""
@@ -229,7 +275,28 @@ class StatusTracker:
                     f"   [gold3]Capacity:[/gold3] {tokens_info} • {reqs_info}"
                 )
 
-                display = Group(self._rich_progress, in_progress, capacity_text)
+                # Format usage stats
+                usage_parts = []
+                if self.total_cost > 0:
+                    usage_parts.append(f"${self.total_cost:.4f}")
+                if self.total_input_tokens > 0 or self.total_output_tokens > 0:
+                    input_k = self.total_input_tokens / 1000
+                    output_k = self.total_output_tokens / 1000
+                    usage_parts.append(f"{input_k:.1f}k in • {output_k:.1f}k out")
+                if self.total_cache_read_tokens > 0:
+                    cache_k = self.total_cache_read_tokens / 1000
+                    usage_parts.append(f"{cache_k:.1f}k cached")
+
+                usage_text = ""
+                if usage_parts:
+                    usage_text = f"   [gold3]Usage:[/gold3] {' • '.join(usage_parts)}"
+
+                if usage_text:
+                    display = Group(
+                        self._rich_progress, in_progress, capacity_text, usage_text
+                    )
+                else:
+                    display = Group(self._rich_progress, in_progress, capacity_text)
                 live.update(display)
 
                 await asyncio.sleep(0.1)

{lm_deluge-0.0.55 → lm_deluge-0.0.57/src/lm_deluge.egg-info}/PKG-INFO

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

{lm_deluge-0.0.55 → lm_deluge-0.0.57}/src/lm_deluge.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@ LICENSE
 README.md
 pyproject.toml
 src/lm_deluge/__init__.py
-src/lm_deluge/agent.py
 src/lm_deluge/batches.py
 src/lm_deluge/cache.py
 src/lm_deluge/cli.py
@@ -11,7 +10,6 @@ src/lm_deluge/config.py
 src/lm_deluge/embed.py
 src/lm_deluge/errors.py
 src/lm_deluge/file.py
-src/lm_deluge/gemini_limits.py
 src/lm_deluge/image.py
 src/lm_deluge/prompt.py
 src/lm_deluge/request_context.py

lm_deluge-0.0.55/src/lm_deluge/gemini_limits.py

@@ -1,65 +0,0 @@
-gemini_flash_limits = {
-    "asia-east1": 2000,
-    "asia-east2": 200,
-    "asia-northeast1": 200,
-    "asia-northeast3": 200,
-    "asia-south1": 200,
-    "asia-southeast1": 3_000,
-    "australia-southeast1": 200,
-    "europe-central2": 200,
-    "europe-north1": 200,
-    "europe-southwest1": 200,
-    "europe-west1": 10_000,
-    "europe-west2": 200,
-    "europe-west3": 200,
-    "europe-west4": 200,
-    "europe-west6": 200,
-    "europe-west8": 200,
-    "europe-west9": 200,
-    # 'me-central1': 200,
-    "me-central2": 200,
-    "me-west1": 200,
-    "northamerica-northeast1": 200,
-    "southamerica-east1": 200,
-    "us-central1": 5_000,
-    "us-east1": 3_000,
-    "us-east4": 200,
-    # 'us-east5': 200,
-    "us-south1": 3_000,
-    "us-west1": 5_000,
-    "us-west4": 200,
-}
-
-# total: 7_520
-gemini_1_5_pro_limits = {
-    "asia-east1": 500,
-    "asia-east2": 500,
-    "asia-northeast1": 500,
-    # "asia-northeast2": 500,
-    "asia-northeast3": 500,
-    "asia-south1": 500,
-    "asia-southeast1": 500,
-    "australia-southeast1": 60,
-    "europe-central2": 500,
-    "europe-north1": 60,
-    "europe-southwest1": 60,
-    "europe-west1": 500,
-    "europe-west2": 60,
-    "europe-west3": 60,
-    "europe-west4": 60,
-    "europe-west6": 60,
-    "europe-west8": 60,
-    "europe-west9": 60,
-    "me-central1": 60,
-    "me-central2": 60,
-    "me-west1": 60,
-    "northamerica-northeast1": 60,
-    "southamerica-east1": 500,
-    "us-central1": 500,
-    "us-east1": 500,
-    "us-east4": 60,
-    # "us-east5": 60,
-    "us-south1": 60,
-    "us-west1": 500,
-    "us-west4": 60,
-}