lm-deluge 0.0.12__tar.gz → 0.0.13__tar.gz

{lm_deluge-0.0.12/src/lm_deluge.egg-info → lm_deluge-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.12
+Version: 0.0.13
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -22,8 +22,7 @@ Requires-Dist: lxml
 Requires-Dist: pdf2image
 Requires-Dist: pillow
 Requires-Dist: fastmcp>=2.4
-Requires-Dist: fasttext-wheel
-Requires-Dist: fasttext-langdetect
+Requires-Dist: rich
 Dynamic: license-file
 
 # lm-deluge
@@ -35,6 +34,7 @@ Dynamic: license-file
 - **Spray across models/providers** – Configure a client with multiple models from any provider(s), and sampling weights. The client samples a model for each request.
 - **Tool Use** – Unified API for defining tools for all providers, and creating tools automatically from python functions.
 - **MCP Support** – Instantiate a `Tool` from a local or remote MCP server so that any LLM can use it, whether or not that provider natively supports MCP.
+- **Computer Use** – We support Claude Computer Use via the computer_use argument to process_prompts_sync/async. It works with Anthropic's API; Bedrock's API is broken right now and rejects the tool definitions, but in principle this will work there too when Bedrock gets their sh*t together.
 - **Caching** – Save completions in a local or distributed cache to avoid repeated LLM calls to process the same input.
 - **Convenient message constructor** – No more looking up how to build an Anthropic messages list with images. Our `Conversation` and `Message` classes work great with our client or with the `openai` and `anthropic` packages.
 - **Sync and async APIs** – Use the client from sync or async code.
@@ -233,11 +233,11 @@ asyncio.run(main())
 
 ## Available Models
 
-We support all models in `src/lm_deluge/models.py`. An older version of this client supported Bedrock and Vertex. We plan to re-implement Bedrock support (our previous support was spotty and we need to figure out cross-region inference in order to support the newest Claude models). Vertex support is not currently planned, since Google allows you to connect your Vertex account to AI Studio, and Vertex authentication is a huge pain (requires service account credentials, etc.)
+We support all models in `src/lm_deluge/models.py`. Vertex support is not planned in the short term, since Google allows you to connect your Vertex account to AI Studio, and Vertex authentication is a huge pain (requires service account credentials, etc.)
 
 ## Feature Support
 
-We support structured outputs via `json_mode` parameter provided to `SamplingParams`. Structured outputs with a schema are planned. Reasoning models are supported via the `reasoning_effort` parameter, which is translated to a thinking budget for Claude/Gemini. Image models are supported. We don't support tool use yet, but support is planned (keep an eye out for a unified tool definition spec that works for all models!). We support logprobs for OpenAI models that return them via the `logprobs` argument to the `LLMClient`.
+We support structured outputs via `json_mode` parameter provided to `SamplingParams`. Structured outputs with a schema are planned. Reasoning models are supported via the `reasoning_effort` parameter, which is translated to a thinking budget for Claude/Gemini. Image models are supported. We support tool use as documented above. We support logprobs for OpenAI models that return them.
 
 ## Built‑in tools
 

{lm_deluge-0.0.12 → lm_deluge-0.0.13}/README.md

@@ -7,6 +7,7 @@
 - **Spray across models/providers** – Configure a client with multiple models from any provider(s), and sampling weights. The client samples a model for each request.
 - **Tool Use** – Unified API for defining tools for all providers, and creating tools automatically from python functions.
 - **MCP Support** – Instantiate a `Tool` from a local or remote MCP server so that any LLM can use it, whether or not that provider natively supports MCP.
+- **Computer Use** – We support Claude Computer Use via the computer_use argument to process_prompts_sync/async. It works with Anthropic's API; Bedrock's API is broken right now and rejects the tool definitions, but in principle this will work there too when Bedrock gets their sh*t together.
 - **Caching** – Save completions in a local or distributed cache to avoid repeated LLM calls to process the same input.
 - **Convenient message constructor** – No more looking up how to build an Anthropic messages list with images. Our `Conversation` and `Message` classes work great with our client or with the `openai` and `anthropic` packages.
 - **Sync and async APIs** – Use the client from sync or async code.
@@ -205,11 +206,11 @@ asyncio.run(main())
 
 ## Available Models
 
-We support all models in `src/lm_deluge/models.py`. An older version of this client supported Bedrock and Vertex. We plan to re-implement Bedrock support (our previous support was spotty and we need to figure out cross-region inference in order to support the newest Claude models). Vertex support is not currently planned, since Google allows you to connect your Vertex account to AI Studio, and Vertex authentication is a huge pain (requires service account credentials, etc.)
+We support all models in `src/lm_deluge/models.py`. Vertex support is not planned in the short term, since Google allows you to connect your Vertex account to AI Studio, and Vertex authentication is a huge pain (requires service account credentials, etc.)
 
 ## Feature Support
 
-We support structured outputs via `json_mode` parameter provided to `SamplingParams`. Structured outputs with a schema are planned. Reasoning models are supported via the `reasoning_effort` parameter, which is translated to a thinking budget for Claude/Gemini. Image models are supported. We don't support tool use yet, but support is planned (keep an eye out for a unified tool definition spec that works for all models!). We support logprobs for OpenAI models that return them via the `logprobs` argument to the `LLMClient`.
+We support structured outputs via `json_mode` parameter provided to `SamplingParams`. Structured outputs with a schema are planned. Reasoning models are supported via the `reasoning_effort` parameter, which is translated to a thinking budget for Claude/Gemini. Image models are supported. We support tool use as documented above. We support logprobs for OpenAI models that return them.
 
 ## Built‑in tools
 

{lm_deluge-0.0.12 → lm_deluge-0.0.13}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.12"
+version = "0.0.13"
 authors = [{ name = "Benjamin Anderson", email = "ben@trytaylor.ai" }]
 description = "Python utility for using LLM API models."
 readme = "README.md"
@@ -28,6 +28,5 @@ dependencies = [
     "pdf2image",
     "pillow",
     "fastmcp>=2.4",
-    "fasttext-wheel",
-    "fasttext-langdetect",
+    "rich"
 ]

lm_deluge-0.0.13/src/lm_deluge/__init__.py

@@ -0,0 +1,15 @@
+from .client import LLMClient, SamplingParams, APIResponse
+from .prompt import Conversation, Message
+from .tool import Tool
+import dotenv
+
+dotenv.load_dotenv()
+
+__all__ = [
+    "LLMClient",
+    "SamplingParams",
+    "APIResponse",
+    "Conversation",
+    "Message",
+    "Tool",
+]

{lm_deluge-0.0.12 → lm_deluge-0.0.13}/src/lm_deluge/api_requests/anthropic.py

@@ -1,9 +1,6 @@
-import asyncio
 from aiohttp import ClientResponse
 import json
 import os
-import warnings
-from tqdm import tqdm
 from typing import Callable
 
 from lm_deluge.prompt import (
@@ -14,12 +11,84 @@ from lm_deluge.prompt import (
     Thinking,
     CachePattern,
 )
+from lm_deluge.tool import Tool
 from lm_deluge.usage import Usage
 from .base import APIRequestBase, APIResponse
 
 from ..tracker import StatusTracker
-from ..sampling_params import SamplingParams
+from ..config import SamplingParams
 from ..models import APIModel
+from ..computer_use.anthropic_tools import get_anthropic_cu_tools
+
+
+def _build_anthropic_request(
+    model: APIModel,
+    prompt: Conversation,
+    tools: list[Tool] | None,
+    sampling_params: SamplingParams,
+    cache_pattern: CachePattern | None = None,
+    computer_use: bool = False,
+    display_width: int = 1024,
+    display_height: int = 768,
+):
+    system_message, messages = prompt.to_anthropic(cache_pattern=cache_pattern)
+    request_header = {
+        "x-api-key": os.getenv(model.api_key_env_var),
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json",
+    }
+
+    # Add beta header for Computer Use
+    if computer_use:
+        request_header["anthropic-beta"] = "computer-use-2025-01-24"
+
+    request_json = {
+        "model": model.name,
+        "messages": messages,
+        "temperature": sampling_params.temperature,
+        "top_p": sampling_params.top_p,
+        "max_tokens": sampling_params.max_new_tokens,
+    }
+
+    # handle thinking
+    if model.reasoning_model and sampling_params.reasoning_effort:
+        # translate reasoning effort of low, medium, high to budget tokens
+        budget = {"low": 1024, "medium": 4096, "high": 16384}.get(
+            sampling_params.reasoning_effort
+        )
+        request_json["thinking"] = {
+            "type": "enabled",
+            "budget_tokens": budget,
+        }
+        request_json.pop("top_p")
+        request_json["temperature"] = 1.0
+        request_json["max_tokens"] += budget
+    else:
+        request_json["thinking"] = {"type": "disabled"}
+        if sampling_params.reasoning_effort:
+            print("ignoring reasoning_effort for non-reasoning model")
+    if system_message is not None:
+        request_json["system"] = system_message
+    if tools or computer_use:
+        tool_definitions = []
+        if tools:
+            tool_definitions.extend([tool.dump_for("anthropic") for tool in tools])
+        # Add Computer Use tools
+        if computer_use:
+            cu_tools = get_anthropic_cu_tools(
+                model=model.id,
+                display_width=display_width,  # todo: set from ComputerUseParams
+                display_height=display_height,
+            )
+            tool_definitions.extend(cu_tools)
+
+        # Add cache control to last tool if tools_only caching is specified
+        if cache_pattern == "tools_only" and tool_definitions:
+            tool_definitions[-1]["cache_control"] = {"type": "ephemeral"}
+
+        request_json["tools"] = tool_definitions
+
+    return request_json, request_header
 
 
 class AnthropicRequest(APIRequestBase):
@@ -32,18 +101,19 @@ class AnthropicRequest(APIRequestBase):
         prompt: Conversation,
         attempts_left: int,
         status_tracker: StatusTracker,
-        retry_queue: asyncio.Queue,
         results_arr: list,
         request_timeout: int = 30,
         sampling_params: SamplingParams = SamplingParams(),
-        pbar: tqdm | None = None,
         callback: Callable | None = None,
-        debug: bool = False,
         # for retries
         all_model_names: list[str] | None = None,
         all_sampling_params: list[SamplingParams] | None = None,
         tools: list | None = None,
         cache: CachePattern | None = None,
+        # Computer Use support
+        computer_use: bool = False,
+        display_width: int = 1024,
+        display_height: int = 768,
     ):
         super().__init__(
             task_id=task_id,
@@ -51,18 +121,18 @@ class AnthropicRequest(APIRequestBase):
             prompt=prompt,
             attempts_left=attempts_left,
             status_tracker=status_tracker,
-            retry_queue=retry_queue,
             results_arr=results_arr,
             request_timeout=request_timeout,
             sampling_params=sampling_params,
-            pbar=pbar,
             callback=callback,
-            debug=debug,
             all_model_names=all_model_names,
             all_sampling_params=all_sampling_params,
             tools=tools,
             cache=cache,
         )
+        self.computer_use = computer_use
+        self.display_width = display_width
+        self.display_height = display_height
         self.model = APIModel.from_registry(model_name)
         self.url = f"{self.model.api_base}/messages"
 
@@ -70,52 +140,16 @@ class AnthropicRequest(APIRequestBase):
         if cache is not None:
             prompt.lock_images_as_bytes()
 
-        self.system_message, messages = prompt.to_anthropic(cache_pattern=cache)
-        self.request_header = {
-            "x-api-key": os.getenv(self.model.api_key_env_var),
-            "anthropic-version": "2023-06-01",
-            "content-type": "application/json",
-        }
-
-        self.request_json = {
-            "model": self.model.name,
-            "messages": messages,
-            "temperature": self.sampling_params.temperature,
-            "top_p": self.sampling_params.top_p,
-            "max_tokens": self.sampling_params.max_new_tokens,
-        }
-        # handle thinking
-        if self.model.reasoning_model:
-            if sampling_params.reasoning_effort:
-                # translate reasoning effort of low, medium, high to budget tokens
-                budget = {"low": 1024, "medium": 4096, "high": 16384}.get(
-                    sampling_params.reasoning_effort
-                )
-                self.request_json["thinking"] = {
-                    "type": "enabled",
-                    "budget_tokens": budget,
-                }
-                self.request_json.pop("top_p")
-                self.request_json["temperature"] = 1.0
-                self.request_json["max_tokens"] += (
-                    budget  # assume max tokens is max completion tokens
-                )
-            else:
-                # no thinking
-                self.request_json["thinking"] = {"type": "disabled"}
-        else:
-            if sampling_params.reasoning_effort:
-                warnings.warn(
-                    f"Ignoring reasoning_effort param for non-reasoning model: {model_name}"
-                )
-        if self.system_message is not None:
-            self.request_json["system"] = self.system_message
-        if tools:
-            tool_definitions = [tool.dump_for("anthropic") for tool in tools]
-            # Add cache control to last tool if tools_only caching is specified
-            if cache == "tools_only" and tool_definitions:
-                tool_definitions[-1]["cache_control"] = {"type": "ephemeral"}
-            self.request_json["tools"] = tool_definitions
+        self.request_json, self.request_header = _build_anthropic_request(
+            self.model,
+            prompt,
+            tools,
+            sampling_params,
+            cache,
+            computer_use,
+            display_width,
+            display_height,
+        )
 
     async def handle_response(self, http_response: ClientResponse) -> APIResponse:
         is_error = False
@@ -135,8 +169,6 @@ class AnthropicRequest(APIRequestBase):
             "anthropic-ratelimit-tokens-reset",
         ]:
             rate_limits[header] = http_response.headers.get(header, None)
-        if self.debug:
-            print(f"Rate limits: {rate_limits}")
         if status_code >= 200 and status_code < 300:
             try:
                 data = await http_response.json()

{lm_deluge-0.0.12 → lm_deluge-0.0.13}/src/lm_deluge/api_requests/base.py

@@ -1,20 +1,21 @@
-import aiohttp
 import asyncio
 import json
 import random
-from tqdm import tqdm
-from dataclasses import dataclass
+import traceback
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from typing import Callable
 
-from lm_deluge.prompt import Conversation, Message, CachePattern
+import aiohttp
+from aiohttp import ClientResponse
+
+from lm_deluge.prompt import CachePattern, Conversation, Message
 from lm_deluge.usage import Usage
 
-from ..tracker import StatusTracker
-from ..sampling_params import SamplingParams
-from ..models import APIModel
+from ..config import SamplingParams
 from ..errors import raise_if_modal_exception
-from aiohttp import ClientResponse
+from ..models import APIModel
+from ..tracker import StatusTracker
 
 
 @dataclass
@@ -48,6 +49,10 @@ class APIResponse:
     retry_with_different_model: bool | None = False
     # set to true if should NOT retry with the same model (unrecoverable error)
     give_up_if_no_other_models: bool | None = False
+    # OpenAI Responses API specific - used for computer use continuation
+    response_id: str | None = None
+    # Raw API response for debugging
+    raw_response: dict | None = None
 
     @property
     def completion(self) -> str | None:
@@ -176,16 +181,11 @@ class APIRequestBase(ABC):
         prompt: Conversation,
         attempts_left: int,
         status_tracker: StatusTracker,
-        retry_queue: asyncio.Queue,
         # needed in order to retry with a different model and not throw the output away
         results_arr: list["APIRequestBase"],
         request_timeout: int = 30,
         sampling_params: SamplingParams = SamplingParams(),
-        logprobs: bool = False,
-        top_logprobs: int | None = None,
-        pbar: tqdm | None = None,
         callback: Callable | None = None,
-        debug: bool = False,
         all_model_names: list[str] | None = None,
         all_sampling_params: list[SamplingParams] | None = None,
         tools: list | None = None,
@@ -199,16 +199,11 @@ class APIRequestBase(ABC):
         self.prompt = prompt
         self.attempts_left = attempts_left
         self.status_tracker = status_tracker
-        self.retry_queue = retry_queue
         self.request_timeout = request_timeout
         self.sampling_params = sampling_params
-        self.logprobs = logprobs  # len(completion) logprobs
-        self.top_logprobs = top_logprobs
-        self.pbar = pbar
         self.callback = callback
         self.num_tokens = prompt.count_tokens(sampling_params.max_new_tokens)
         self.results_arr = results_arr
-        self.debug = debug
         self.all_model_names = all_model_names
         self.all_sampling_params = all_sampling_params
         self.tools = tools
@@ -222,8 +217,7 @@ class APIRequestBase(ABC):
         self.region = None
 
     def increment_pbar(self):
-        if self.pbar is not None:
-            self.pbar.update(1)
+        self.status_tracker.increment_pbar()
 
     def call_callback(self):
         if self.callback is not None:
@@ -232,7 +226,6 @@ class APIRequestBase(ABC):
 
     def handle_success(self, data):
         self.call_callback()
-        self.increment_pbar()
         self.status_tracker.task_succeeded(self.task_id)
 
     def handle_error(self, create_new_request=False, give_up_if_no_other_models=False):
@@ -253,7 +246,8 @@ class APIRequestBase(ABC):
         if self.attempts_left > 0:
             self.attempts_left -= 1
             if not create_new_request:
-                self.retry_queue.put_nowait(self)
+                assert self.status_tracker.retry_queue
+                self.status_tracker.retry_queue.put_nowait(self)
                 return
             else:
                 # make sure we have another model to send it to besides the current one
@@ -267,7 +261,8 @@ class APIRequestBase(ABC):
                         print(
                             f"No other models to try for task {self.task_id}. Retrying with same model."
                         )
-                        self.retry_queue.put_nowait(self)
+                        assert self.status_tracker.retry_queue
+                        self.status_tracker.retry_queue.put_nowait(self)
                 else:
                     # two things to change: model_name and sampling_params
                     new_model_name = self.model_name
@@ -292,21 +287,21 @@ class APIRequestBase(ABC):
                         prompt=self.prompt,
                         attempts_left=self.attempts_left,
                         status_tracker=self.status_tracker,
-                        retry_queue=self.retry_queue,
                         results_arr=self.results_arr,
                         request_timeout=self.request_timeout,
                         sampling_params=new_sampling_params,
-                        logprobs=self.logprobs,
-                        top_logprobs=self.top_logprobs,
-                        pbar=self.pbar,
                         callback=self.callback,
                         all_model_names=self.all_model_names,
                         all_sampling_params=self.all_sampling_params,
                         tools=self.tools,
                         cache=self.cache,
+                        computer_use=getattr(self, "computer_use", False),
+                        display_width=getattr(self, "display_width", 1024),
+                        display_height=getattr(self, "display_height", 768),
                     )
                     # PROBLEM: new request is never put into results array, so we can't get the result.
-                    self.retry_queue.put_nowait(new_request)
+                    assert self.status_tracker.retry_queue
+                    self.status_tracker.retry_queue.put_nowait(self)
                     # SOLUTION: just need to make sure it's deduplicated by task_id later.
                     self.results_arr.append(new_request)
         else:
@@ -354,6 +349,8 @@ class APIRequestBase(ABC):
 
         except Exception as e:
             raise_if_modal_exception(e)
+            tb = traceback.format_exc()
+            print(tb)
             self.result.append(
                 APIResponse(
                     id=self.task_id,
@@ -381,39 +378,52 @@ def create_api_request(
     prompt: Conversation,
     attempts_left: int,
     status_tracker: StatusTracker,
-    retry_queue: asyncio.Queue,
     results_arr: list["APIRequestBase"],
     request_timeout: int = 30,
     sampling_params: SamplingParams = SamplingParams(),
-    logprobs: bool = False,
-    top_logprobs: int | None = None,
-    pbar: tqdm | None = None,
     callback: Callable | None = None,
     all_model_names: list[str] | None = None,
     all_sampling_params: list[SamplingParams] | None = None,
     tools: list | None = None,
     cache: CachePattern | None = None,
+    computer_use: bool = False,
+    display_width: int = 1024,
+    display_height: int = 768,
+    use_responses_api: bool = False,
 ) -> APIRequestBase:
     from .common import CLASSES  # circular import so made it lazy, does this work?
 
     model_obj = APIModel.from_registry(model_name)
-    request_class = CLASSES.get(model_obj.api_spec, None)
+
+    # Choose API spec based on use_responses_api flag and model support
+    api_spec = model_obj.api_spec
+    if use_responses_api and model_obj.supports_responses and api_spec == "openai":
+        api_spec = "openai-responses"
+
+    request_class = CLASSES.get(api_spec, None)
     if request_class is None:
-        raise ValueError(f"Unsupported API spec: {model_obj.api_spec}")
-    kwargs = (
-        {} if not logprobs else {"logprobs": logprobs, "top_logprobs": top_logprobs}
-    )
+        raise ValueError(f"Unsupported API spec: {api_spec}")
+    kwargs = {}
+    # Add computer_use to kwargs if the request class supports it
+    model_obj = APIModel.from_registry(model_name)
+    if computer_use and api_spec in ["anthropic", "bedrock", "openai-responses"]:
+        kwargs.update(
+            {
+                "computer_use": computer_use,
+                "display_width": display_width,
+                "display_height": display_height,
+            }
+        )
+
     return request_class(
         task_id=task_id,
         model_name=model_name,
         prompt=prompt,
         attempts_left=attempts_left,
         status_tracker=status_tracker,
-        retry_queue=retry_queue,
         results_arr=results_arr,
         request_timeout=request_timeout,
         sampling_params=sampling_params,
-        pbar=pbar,
         callback=callback,
         all_model_names=all_model_names,
         all_sampling_params=all_sampling_params,
@@ -421,3 +431,22 @@ def create_api_request(
         cache=cache,
         **kwargs,
     )
+
+
+def deduplicate_responses(results: list[APIRequestBase]) -> list[APIResponse]:
+    deduplicated = {}
+    for request in results:
+        if request.task_id not in deduplicated:
+            deduplicated[request.task_id] = request.result[-1]
+        else:
+            current_response: APIResponse = deduplicated[request.task_id]
+            # only replace if the current request has no completion and the new one does
+            if (
+                request.result[-1].completion is not None
+                and current_response.completion is None
+            ):
+                deduplicated[request.task_id] = request.result[-1]
+
+    output = [deduplicated[request.task_id] for request in results]
+
+    return output

{lm_deluge-0.0.12 → lm_deluge-0.0.13}/src/lm_deluge/api_requests/bedrock.py

@@ -2,7 +2,6 @@ import asyncio
 import json
 import os
 from aiohttp import ClientResponse
-from tqdm import tqdm
 from typing import Callable
 
 try:
@@ -24,7 +23,7 @@ from lm_deluge.usage import Usage
 from .base import APIRequestBase, APIResponse
 
 from ..tracker import StatusTracker
-from ..sampling_params import SamplingParams
+from ..config import SamplingParams
 from ..models import APIModel
 
 
@@ -36,17 +35,18 @@ class BedrockRequest(APIRequestBase):
         prompt: Conversation,
         attempts_left: int,
         status_tracker: StatusTracker,
-        retry_queue: asyncio.Queue,
         results_arr: list,
         request_timeout: int = 30,
         sampling_params: SamplingParams = SamplingParams(),
-        pbar: tqdm | None = None,
         callback: Callable | None = None,
-        debug: bool = False,
         all_model_names: list[str] | None = None,
         all_sampling_params: list[SamplingParams] | None = None,
         tools: list | None = None,
         cache: CachePattern | None = None,
+        # Computer Use support
+        computer_use: bool = False,
+        display_width: int = 1024,
+        display_height: int = 768,
     ):
         super().__init__(
             task_id=task_id,
@@ -54,19 +54,20 @@ class BedrockRequest(APIRequestBase):
             prompt=prompt,
             attempts_left=attempts_left,
             status_tracker=status_tracker,
-            retry_queue=retry_queue,
             results_arr=results_arr,
             request_timeout=request_timeout,
             sampling_params=sampling_params,
-            pbar=pbar,
             callback=callback,
-            debug=debug,
             all_model_names=all_model_names,
             all_sampling_params=all_sampling_params,
             tools=tools,
             cache=cache,
         )
 
+        self.computer_use = computer_use
+        self.display_width = display_width
+        self.display_height = display_height
+
         # Lock images as bytes if caching is enabled
         if cache is not None:
             prompt.lock_images_as_bytes()
@@ -115,11 +116,34 @@ class BedrockRequest(APIRequestBase):
         if self.system_message is not None:
             self.request_json["system"] = self.system_message
 
-        if tools:
-            tool_definitions = [tool.dump_for("anthropic") for tool in tools]
+        if tools or self.computer_use:
+            tool_definitions = []
+
+            # Add Computer Use tools at the beginning if enabled
+            if self.computer_use:
+                from ..computer_use.anthropic_tools import get_anthropic_cu_tools
+
+                cu_tools = get_anthropic_cu_tools(
+                    model=self.model.id,
+                    display_width=self.display_width,
+                    display_height=self.display_height,
+                )
+                tool_definitions.extend(cu_tools)
+
+                # Add computer use display parameters to the request
+                self.request_json["computer_use_display_width_px"] = self.display_width
+                self.request_json["computer_use_display_height_px"] = (
+                    self.display_height
+                )
+
+            # Add user-provided tools
+            if tools:
+                tool_definitions.extend([tool.dump_for("anthropic") for tool in tools])
+
             # Add cache control to last tool if tools_only caching is specified
             if cache == "tools_only" and tool_definitions:
                 tool_definitions[-1]["cache_control"] = {"type": "ephemeral"}
+
             self.request_json["tools"] = tool_definitions
 
         # Setup AWS4Auth for signing

{lm_deluge-0.0.12 → lm_deluge-0.0.13}/src/lm_deluge/api_requests/common.py

@@ -1,10 +1,11 @@
-from .openai import OpenAIRequest
+from .openai import OpenAIRequest, OpenAIResponsesRequest
 from .anthropic import AnthropicRequest
 from .mistral import MistralRequest
 from .bedrock import BedrockRequest
 
 CLASSES = {
     "openai": OpenAIRequest,
+    "openai-responses": OpenAIResponsesRequest,
     "anthropic": AnthropicRequest,
     "mistral": MistralRequest,
     "bedrock": BedrockRequest,